From 279b2aa10a7115445a8569d21e7077901ae26483 Mon Sep 17 00:00:00 2001 From: dapan1121 Date: Tue, 19 Dec 2023 11:17:39 +0800 Subject: [PATCH] enh: add join ut --- include/common/ttokendef.h | 164 +- include/libs/nodes/querynodes.h | 1 - source/libs/executor/test/CMakeLists.txt | 24 +- source/libs/executor/test/joinTests.cpp | 1274 +++++ source/libs/parser/inc/sql.y | 1 - source/libs/parser/src/parTokenizer.c | 2 +- source/libs/parser/src/sql.c | 5872 +++++++++++----------- source/libs/planner/src/planOptimizer.c | 11 + 8 files changed, 4301 insertions(+), 3048 deletions(-) create mode 100755 source/libs/executor/test/joinTests.cpp diff --git a/include/common/ttokendef.h b/include/common/ttokendef.h index c6128f14d0..2096e1de53 100644 --- a/include/common/ttokendef.h +++ b/include/common/ttokendef.h @@ -290,88 +290,88 @@ #define TK_OUTER 271 #define TK_SEMI 272 #define TK_ANTI 273 -#define TK_ANY 274 -#define TK_ASOF 275 -#define TK_WINDOW 276 -#define TK_WINDOW_OFFSET 277 -#define TK_JLIMIT 278 -#define TK_SELECT 279 -#define TK_NK_HINT 280 -#define TK_DISTINCT 281 -#define TK_WHERE 282 -#define TK_PARTITION 283 -#define TK_BY 284 -#define TK_SESSION 285 -#define TK_STATE_WINDOW 286 -#define TK_EVENT_WINDOW 287 -#define TK_SLIDING 288 -#define TK_FILL 289 -#define TK_VALUE 290 -#define TK_VALUE_F 291 -#define TK_NONE 292 -#define TK_PREV 293 -#define TK_NULL_F 294 -#define TK_LINEAR 295 -#define TK_NEXT 296 -#define TK_HAVING 297 -#define TK_RANGE 298 -#define TK_EVERY 299 -#define TK_ORDER 300 -#define TK_SLIMIT 301 -#define TK_SOFFSET 302 -#define TK_LIMIT 303 -#define TK_OFFSET 304 -#define TK_ASC 305 -#define TK_NULLS 306 -#define TK_ABORT 307 -#define TK_AFTER 308 -#define TK_ATTACH 309 -#define TK_BEFORE 310 -#define TK_BEGIN 311 -#define TK_BITAND 312 -#define TK_BITNOT 313 -#define TK_BITOR 314 -#define TK_BLOCKS 315 -#define TK_CHANGE 316 -#define TK_COMMA 317 -#define TK_CONCAT 318 -#define TK_CONFLICT 319 -#define TK_COPY 320 -#define TK_DEFERRED 321 -#define TK_DELIMITERS 322 -#define TK_DETACH 323 -#define TK_DIVIDE 324 -#define TK_DOT 325 -#define TK_EACH 326 -#define TK_FAIL 327 -#define TK_FILE 328 -#define TK_FOR 329 -#define TK_GLOB 330 -#define TK_ID 331 -#define TK_IMMEDIATE 332 -#define TK_IMPORT 333 -#define TK_INITIALLY 334 -#define TK_INSTEAD 335 -#define TK_ISNULL 336 -#define TK_KEY 337 -#define TK_MODULES 338 -#define TK_NK_BITNOT 339 -#define TK_NK_SEMI 340 -#define TK_NOTNULL 341 -#define TK_OF 342 -#define TK_PLUS 343 -#define TK_PRIVILEGE 344 -#define TK_RAISE 345 -#define TK_RESTRICT 346 -#define TK_ROW 347 -#define TK_STAR 348 -#define TK_STATEMENT 349 -#define TK_STRICT 350 -#define TK_STRING 351 -#define TK_TIMES 352 -#define TK_VALUES 353 -#define TK_VARIABLE 354 -#define TK_WAL 355 +#define TK_ASOF 274 +#define TK_WINDOW 275 +#define TK_WINDOW_OFFSET 276 +#define TK_JLIMIT 277 +#define TK_SELECT 278 +#define TK_NK_HINT 279 +#define TK_DISTINCT 280 +#define TK_WHERE 281 +#define TK_PARTITION 282 +#define TK_BY 283 +#define TK_SESSION 284 +#define TK_STATE_WINDOW 285 +#define TK_EVENT_WINDOW 286 +#define TK_SLIDING 287 +#define TK_FILL 288 +#define TK_VALUE 289 +#define TK_VALUE_F 290 +#define TK_NONE 291 +#define TK_PREV 292 +#define TK_NULL_F 293 +#define TK_LINEAR 294 +#define TK_NEXT 295 +#define TK_HAVING 296 +#define TK_RANGE 297 +#define TK_EVERY 298 +#define TK_ORDER 299 +#define TK_SLIMIT 300 +#define TK_SOFFSET 301 +#define TK_LIMIT 302 +#define TK_OFFSET 303 +#define TK_ASC 304 +#define TK_NULLS 305 +#define TK_ABORT 306 +#define TK_AFTER 307 +#define TK_ATTACH 308 +#define TK_BEFORE 309 +#define TK_BEGIN 310 +#define TK_BITAND 311 +#define TK_BITNOT 312 +#define TK_BITOR 313 +#define TK_BLOCKS 314 +#define TK_CHANGE 315 +#define TK_COMMA 316 +#define TK_CONCAT 317 +#define TK_CONFLICT 318 +#define TK_COPY 319 +#define TK_DEFERRED 320 +#define TK_DELIMITERS 321 +#define TK_DETACH 322 +#define TK_DIVIDE 323 +#define TK_DOT 324 +#define TK_EACH 325 +#define TK_FAIL 326 +#define TK_FILE 327 +#define TK_FOR 328 +#define TK_GLOB 329 +#define TK_ID 330 +#define TK_IMMEDIATE 331 +#define TK_IMPORT 332 +#define TK_INITIALLY 333 +#define TK_INSTEAD 334 +#define TK_ISNULL 335 +#define TK_KEY 336 +#define TK_MODULES 337 +#define TK_NK_BITNOT 338 +#define TK_NK_SEMI 339 +#define TK_NOTNULL 340 +#define TK_OF 341 +#define TK_PLUS 342 +#define TK_PRIVILEGE 343 +#define TK_RAISE 344 +#define TK_RESTRICT 345 +#define TK_ROW 346 +#define TK_STAR 347 +#define TK_STATEMENT 348 +#define TK_STRICT 349 +#define TK_STRING 350 +#define TK_TIMES 351 +#define TK_VALUES 352 +#define TK_VARIABLE 353 +#define TK_WAL 354 + diff --git a/include/libs/nodes/querynodes.h b/include/libs/nodes/querynodes.h index efb118d4ed..33a3b6aba7 100644 --- a/include/libs/nodes/querynodes.h +++ b/include/libs/nodes/querynodes.h @@ -219,7 +219,6 @@ typedef enum EJoinSubType { JOIN_STYPE_OUTER, JOIN_STYPE_SEMI, JOIN_STYPE_ANTI, - JOIN_STYPE_ANY, JOIN_STYPE_ASOF, JOIN_STYPE_WIN, JOIN_STYPE_MAX_VALUE diff --git a/source/libs/executor/test/CMakeLists.txt b/source/libs/executor/test/CMakeLists.txt index 18ca954813..bb53213431 100644 --- a/source/libs/executor/test/CMakeLists.txt +++ b/source/libs/executor/test/CMakeLists.txt @@ -19,17 +19,17 @@ IF(NOT TD_DARWIN) ) ENDIF () -# SET(CMAKE_CXX_STANDARD 11) -# AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST) +SET(CMAKE_CXX_STANDARD 11) +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST) -# ADD_EXECUTABLE(tSimpleHashTest tSimpleHashTests.cpp) -# TARGET_LINK_LIBRARIES( -# tSimpleHashTest -# PRIVATE os util common executor gtest_main -# ) +ADD_EXECUTABLE(joinTests joinTests.cpp) +TARGET_LINK_LIBRARIES( + joinTests + PRIVATE os util common executor gtest_main qcom +) -# TARGET_INCLUDE_DIRECTORIES( -# tSimpleHashTest -# PUBLIC "${TD_SOURCE_DIR}/include/common" -# PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../inc" -# ) \ No newline at end of file +TARGET_INCLUDE_DIRECTORIES( + joinTests + PUBLIC "${TD_SOURCE_DIR}/include/common" + PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../inc" +) diff --git a/source/libs/executor/test/joinTests.cpp b/source/libs/executor/test/joinTests.cpp new file mode 100755 index 0000000000..47a3fe367c --- /dev/null +++ b/source/libs/executor/test/joinTests.cpp @@ -0,0 +1,1274 @@ +/* + * 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 +#include + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wwrite-strings" +#pragma GCC diagnostic ignored "-Wunused-function" +#pragma GCC diagnostic ignored "-Wunused-variable" +#pragma GCC diagnostic ignored "-Wsign-compare" +#include "os.h" + +#include "executor.h" +#include "executorInt.h" +#include "function.h" +#include "operator.h" +#include "taos.h" +#include "tdatablock.h" +#include "tdef.h" +#include "tvariant.h" + +namespace { + +typedef struct { + bool succeed; + int32_t blkNum; + int32_t rowNum; + int32_t addRowNum; + int32_t subRowNum; + int32_t mismatchNum; + int32_t matchNum; +} SJoinTestResInfo; + +typedef struct { + bool filter; + bool asc; + int32_t leftMaxRows; + int32_t leftMaxGrpRows; + int32_t rightMaxRows; + int32_t rightMaxGrpRows; + int32_t blkRows; + int32_t colCond; + int32_t joinType; + int32_t subType; + + int32_t leftTotalRows; + int32_t rightTotalRows; + int32_t blkRowSize; + + int32_t colEqNum; + int32_t colEqList[MAX_SLOT_NUM]; + + int32_t colOnNum; + int32_t colOnList[MAX_SLOT_NUM]; + + int32_t leftFilterNum; + int32_t leftFilterColList[MAX_SLOT_NUM]; + + int32_t rightFilterNum; + int32_t rightFilterColList[MAX_SLOT_NUM]; + + int32_t keyInSlotIdx; + int32_t keyOutSlotIdx; + int32_t keyColOffset; + + int32_t resColNum; + int32_t resColInSlot[MAX_SLOT_NUM * 2]; + int32_t resColList[MAX_SLOT_NUM * 2]; + int32_t resColOffset[MAX_SLOT_NUM * 2]; + int32_t resColSize; + void* resColBuf; + + int32_t colRowDataBufSize; + void* colRowDataBuf; + int32_t colRowOffset[MAX_SLOT_NUM]; + + int64_t curTs; + + int32_t leftBlkReadIdx; + SArray* leftBlkList; + int32_t rightBlkReadIdx; + SArray* rightBlkList; + + SSHashObj* jtResRows; + + SOperatorInfo* pJoinOp; +} SJoinTestCtrlInfo; + +enum { + TEST_NO_COND = 1, + TEST_EQ_COND, + TEST_ON_COND, + TEST_FULL_COND +}; + +#define LEFT_BLK_ID 0 +#define RIGHT_BLK_ID 1 +#define RES_BLK_ID 2 +#define MAX_SLOT_NUM 4 + +#define JT_KEY_SOLT_ID 3 +int32_t jtInputColType[MAX_SLOT_NUM] = {TSDB_DATA_TYPE_TIMESTAMP, TSDB_DATA_TYPE_INT, TSDB_DATA_TYPE_INT, TSDB_DATA_TYPE_BIGINT}; + +char* jtColCondStr[] = {"", "NO COND", "EQ COND", "ON COND", "FULL COND"}; +char* jtJoinTypeStr[] = {"INNER", "LEFT", "RIGHT", "FULL"}; +char* jtSubTypeStr[] = {"", "OUTER", "SEMI", "ANTI", "ASOF", "WINDOW"}; + +int64_t TIMESTAMP_FILTER_VALUE = 1000000000; +int32_t INT_FILTER_VALUE = 32767; +int64_t BIGINT_FILTER_VALUE = 1000000000000000; + +int64_t jtFilterValue[] = {TIMESTAMP_FILTER_VALUE, INT_FILTER_VALUE, INT_FILTER_VALUE, BIGINT_FILTER_VALUE}; + +bool jtErrorRerun = true; +bool jtInRerun = false; + +SJoinTestCtrlInfo jtCtrl = {0}; +SJoinTestResInfo jtRes = {0}; + + + +void printResRow(void* value, int32_t type) { + for (int32_t i = 0; i < jtCtrl.resColNum; ++i) { + int32_t slot = jtCtrl.resColInSlot[i]; + switch (jtInputColType[slot % MAX_SLOT_NUM]) { + case TSDB_DATA_TYPE_TIMESTAMP: + printf("\t%" PRId64 , *(int64_t*)(value + jtCtrl.resColOffset[slot])); + break; + case TSDB_DATA_TYPE_INT: + printf("\t%d", *(int32_t*)(value + jtCtrl.resColOffset[slot])); + break; + case TSDB_DATA_TYPE_BIGINT: + printf("\t%d", *(int64_t*)(value + jtCtrl.resColOffset[slot])); + break; + } + } + printf("\t %s\n", 0 == type ? "-" : (1 == type ? "+" : "")); +} + +SOperatorInfo* createDummyDownstreamOperators(int32_t num) { + SOperatorInfo* p = taosMemoryCalloc(num, sizeof(SOperatorInfo)); + for (int32_t i = 0; i < num; ++i) { + p->resultDataBlockId = i; + } + return p; +} + +void createTargetSlotList(SSortMergeJoinPhysiNode* p) { + int32_t leftTargetNum = taosRand() % MAX_SLOT_NUM; + int32_t rightTargetNum = 0; + if (0 == leftTargetNum) { + do { + rightTargetNum = taosRand() % MAX_SLOT_NUM; + } while (0 == rightTargetNum); + } else { + leftTargetNum = taosRand() % MAX_SLOT_NUM; + } + + memset(jtCtrl.resColList, 0, sizeof(jtCtrl.resColList)); + jtCtrl.resColSize = MAX_SLOT_NUM * 2 * sizeof(bool); + + int32_t idx = 0; + int32_t dstIdx = 0; + int32_t dstOffset = jtCtrl.resColSize; + for (int32_t i = 0; i < leftTargetNum; ) { + if (0 == i) { + jtCtrl.resColList[JT_KEY_SOLT_ID] = 1; + ++i; + jtCtrl.keyInSlotIdx = JT_KEY_SOLT_ID; + continue; + } + + idx = taosRand() % MAX_SLOT_NUM; + if (jtCtrl.resColList[idx]) { + continue; + } + jtCtrl.resColList[idx] = 1; + ++i; + } + + for (int32_t i = 0; i < rightTargetNum; ) { + if (0 == i && leftTargetNum <= 0) { + jtCtrl.resColList[MAX_SLOT_NUM + JT_KEY_SOLT_ID] = 1; + ++i; + jtCtrl.keyInSlotIdx = MAX_SLOT_NUM + JT_KEY_SOLT_ID; + continue; + } + + idx = taosRand() % MAX_SLOT_NUM; + if (jtCtrl.resColList[MAX_SLOT_NUM + idx]) { + continue; + } + jtCtrl.resColList[MAX_SLOT_NUM + idx] = 1; + ++i; + } + + for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) { + if (jtCtrl.resColList[i]) { + jtCtrl.resColOffset[dstIdx] = dstOffset; + jtCtrl.resColInSlot[dstIdx] = i; + if (jtCtrl.keyInSlotIdx == i) { + jtCtrl.keyColOffset = dstOffset; + jtCtrl.keyOutSlotIdx = dstIdx; + } + + STargetNode* pTarget = (STargetNode*)nodesMakeNode(QUERY_NODE_TARGET); + SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + pCol->dataBlockId = LEFT_BLK_ID; + pCol->slotId = i; + pTarget->dataBlockId = RES_BLK_ID; + pTarget->slotId = dstIdx++; + pTarget->pExpr = (SNode*)pCol; + dstOffset += tDataTypes[jtInputColType[i]].bytes; + jtCtrl.resColSize += tDataTypes[jtInputColType[i]].bytes; + + nodesListMakeStrictAppend(p->pTargets, pTarget); + } + } + + for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) { + if (jtCtrl.resColList[MAX_SLOT_NUM + i]) { + jtCtrl.resColOffset[dstIdx] = dstOffset; + jtCtrl.resColInSlot[dstIdx] = i + MAX_SLOT_NUM; + if (jtCtrl.keyInSlotIdx == (i + MAX_SLOT_NUM)) { + jtCtrl.keyColOffset = dstOffset; + jtCtrl.keyOutSlotIdx = dstIdx; + } + + STargetNode* pTarget = (STargetNode*)nodesMakeNode(QUERY_NODE_TARGET); + SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + pCol->dataBlockId = RIGHT_BLK_ID; + pCol->slotId = i; + pTarget->dataBlockId = RES_BLK_ID; + pTarget->slotId = dstIdx++; + pTarget->pExpr = (SNode*)pCol; + dstOffset += tDataTypes[jtInputColType[i]].bytes; + jtCtrl.resColSize += tDataTypes[jtInputColType[i]].bytes; + + nodesListMakeStrictAppend(p->pTargets, pTarget); + } + } + + jtCtrl.resColNum = leftTargetNum + rightTargetNum; + jtCtrl.resColBuf = taosMemoryCalloc(jtCtrl.resColSize, 1); +} + +void createColEqCond(SSortMergeJoinPhysiNode* p) { + jtCtrl.colEqNum = 0; + do { + jtCtrl.colEqNum = taosRand() % MAX_SLOT_NUM; + } while (0 == jtCtrl.colEqNum); + + int32_t idx = 0; + memset(jtCtrl.colEqList, 0, sizeof(jtCtrl.colEqList)); + for (int32_t i = 0; i < jtCtrl.colEqNum; ) { + idx = taosRand() % MAX_SLOT_NUM; + if (jtCtrl.colEqList[idx]) { + continue; + } + jtCtrl.colEqList[idx] = 1; + ++i; + } + + SLogicConditionNode* pLogic = NULL; + if (jtCtrl.colEqNum > 1) { + pLogic = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); + pLogic->condType = LOGIC_COND_TYPE_AND; + } + + for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) { + if (jtCtrl.colEqList[i]) { + SColumnNode* pCol1 = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + pCol1->dataBlockId = LEFT_BLK_ID; + pCol1->slotId = i; + pCol1->node.resType.type = jtInputColType[i]; + pCol1->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes; + + nodesListMakeStrictAppend(p->pEqLeft, pCol1); + + SColumnNode* pCol2 = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + pCol2->dataBlockId = RIGHT_BLK_ID; + pCol2->slotId = i; + pCol2->node.resType.type = jtInputColType[i]; + pCol2->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes; + + nodesListMakeStrictAppend(p->pEqRight, pCol2); + + SOperatorNode* pOp = nodesMakeNode(QUERY_NODE_OPERATOR); + pOp->opType = OP_TYPE_EQUAL; + pOp->pLeft = nodesCloneNode(pCol1); + pOp->pRight = nodesCloneNode(pCol2); + + if (jtCtrl.colEqNum > 1) { + nodesListMakeStrictAppend(&pLogic->pParameterList, pOp); + } else { + p->pFullOnCond = pOp; + break; + } + } + } + + if (jtCtrl.colEqNum > 1) { + p->pFullOnCond = pLogic; + } +} + +void createColOnCond(SSortMergeJoinPhysiNode* p) { + jtCtrl.colOnNum = 0; + do { + jtCtrl.colOnNum = taosRand() % MAX_SLOT_NUM; + } while (0 == jtCtrl.colOnNum || (jtCtrl.colOnNum + jtCtrl.colEqNum) > MAX_SLOT_NUM); + + int32_t idx = 0; + memset(jtCtrl.colOnList, 0, sizeof(jtCtrl.colOnList)); + for (int32_t i = 0; i < jtCtrl.colOnNum; ) { + idx = taosRand() % MAX_SLOT_NUM; + if (jtCtrl.colOnList[idx] || jtCtrl.colEqList[idx]) { + continue; + } + jtCtrl.colOnList[idx] = 1; + ++i; + } + + SLogicConditionNode* pLogic = NULL; + if (jtCtrl.colOnNum > 1) { + pLogic = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); + pLogic->condType = LOGIC_COND_TYPE_AND; + } + + for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) { + if (jtCtrl.colOnList[i]) { + SColumnNode* pCol1 = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + pCol1->dataBlockId = LEFT_BLK_ID; + pCol1->slotId = i; + pCol1->node.resType.type = jtInputColType[i]; + pCol1->node.resType.bytes = (TSDB_DATA_TYPE_BINARY != jtInputColType[i]) ? tDataTypes[jtInputColType[i]].bytes : MJ_TEST_BINARY_BYTES; + + nodesListMakeStrictAppend(p->pEqLeft, pCol1); + + SColumnNode* pCol2 = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + pCol2->dataBlockId = RIGHT_BLK_ID; + pCol2->slotId = i; + pCol2->node.resType.type = jtInputColType[i]; + pCol2->node.resType.bytes = (TSDB_DATA_TYPE_BINARY != jtInputColType[i]) ? tDataTypes[jtInputColType[i]].bytes : MJ_TEST_BINARY_BYTES; + + nodesListMakeStrictAppend(p->pEqRight, pCol2); + + SOperatorNode* pOp = nodesMakeNode(QUERY_NODE_OPERATOR); + pOp->opType = OP_TYPE_GREATER_THAN; + pOp->pLeft = nodesCloneNode(pCol1); + pOp->pRight = nodesCloneNode(pCol2); + + if (jtCtrl.colOnNum > 1) { + nodesListMakeStrictAppend(&pLogic->pParameterList, pOp); + } else { + p->pColOnCond = pOp; + break; + } + } + } + + if (jtCtrl.colOnNum > 1) { + p->pColOnCond = pLogic; + } + + mergeEqCond(&p->pFullOnCond, nodesCloneNode(p->pColOnCond)); +} + + +void createColCond(SSortMergeJoinPhysiNode* p, int32_t cond) { + jtCtrl.colCond = cond; + switch (cond) { + case TEST_NO_COND: + jtCtrl.colEqNum = 0; + jtCtrl.colOnNum = 0; + memset(jtCtrl.colEqList, 0, sizeof(jtCtrl.colEqList)); + memset(jtCtrl.colOnList, 0, sizeof(jtCtrl.colOnList)); + break; + case TEST_EQ_COND: + createColEqCond(p); + jtCtrl.colOnNum = 0; + memset(jtCtrl.colOnList, 0, sizeof(jtCtrl.colOnList)); + break; + case TEST_ON_COND: + createColOnCond(p); + jtCtrl.colEqNum = 0; + memset(jtCtrl.colEqList, 0, sizeof(jtCtrl.colEqList)); + break; + case TEST_FULL_COND: + createColEqCond(p); + createColOnCond(p); + break; + default: + break; + } +} + +void* getFilterValue(int32_t type) { + switch (type) { + case TSDB_DATA_TYPE_TIMESTAMP: + return &TIMESTAMP_FILTER_VALUE; + case TSDB_DATA_TYPE_INT: + return &INT_FILTER_VALUE; + case TSDB_DATA_TYPE_BIGINT: + return &BIGINT_FILTER_VALUE; + default: + return NULL; + } +} + +void createFilterCond(SSortMergeJoinPhysiNode* p, bool filter) { + jtCtrl.filter = filter; + if (!filter) { + jtCtrl.leftFilterNum = 0; + jtCtrl.rightFilterNum = 0; + memset(jtCtrl.leftFilterColList, 0, sizeof(jtCtrl.leftFilterColList)); + memset(jtCtrl.rightFilterColList, 0, sizeof(jtCtrl.rightFilterColList)); + return; + } + + jtCtrl.leftFilterNum = taosRand() % MAX_SLOT_NUM; + if (0 == jtCtrl.leftFilterNum) { + do { + jtCtrl.rightFilterNum = taosRand() % MAX_SLOT_NUM; + } while (0 == jtCtrl.rightFilterNum); + } else { + jtCtrl.rightFilterNum = taosRand() % MAX_SLOT_NUM; + } + + int32_t idx = 0; + memset(jtCtrl.leftFilterColList, 0, sizeof(jtCtrl.leftFilterColList)); + memset(jtCtrl.rightFilterColList, 0, sizeof(jtCtrl.rightFilterColList)); + for (int32_t i = 0; i < jtCtrl.leftFilterNum; ) { + idx = taosRand() % MAX_SLOT_NUM; + if (jtCtrl.leftFilterColList[idx]) { + continue; + } + jtCtrl.leftFilterColList[idx] = 1; + ++i; + } + + for (int32_t i = 0; i < jtCtrl.rightFilterNum; ) { + idx = taosRand() % MAX_SLOT_NUM; + if (jtCtrl.rightFilterColList[idx]) { + continue; + } + jtCtrl.rightFilterColList[idx] = 1; + ++i; + } + + SLogicConditionNode* pLogic = NULL; + if ((jtCtrl.leftFilterNum + jtCtrl.rightFilterNum) > 1) { + pLogic = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); + pLogic->condType = taosRand() % 2 ? LOGIC_COND_TYPE_AND : LOGIC_COND_TYPE_OR; + } + + for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) { + if (jtCtrl.leftFilterColList[i]) { + SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + pCol->dataBlockId = LEFT_BLK_ID; + pCol->slotId = i; + pCol->node.resType.type = jtInputColType[i]; + pCol->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes; + + SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + nodesSetValueNodeValue(pVal, getFilterValue(jtInputColType[i])); + pVal->node.resType.type = jtInputColType[i]; + pVal->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes; + + SOperatorNode* pOp = nodesMakeNode(QUERY_NODE_OPERATOR); + pOp->opType = OP_TYPE_GREATER_THAN; + pOp->pLeft = pCol; + pOp->pRight = pVal; + + if ((jtCtrl.leftFilterNum + jtCtrl.rightFilterNum) > 1) { + nodesListMakeStrictAppend(&pLogic->pParameterList, pOp); + } else { + p->node.pConditions = pOp; + break; + } + } + } + + for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) { + if (jtCtrl.rightFilterColList[i]) { + SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + pCol->dataBlockId = RIGHT_BLK_ID; + pCol->slotId = i; + pCol->node.resType.type = jtInputColType[i]; + pCol->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes; + + SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + nodesSetValueNodeValue(pVal, getFilterValue(jtInputColType[i])); + pVal->node.resType.type = jtInputColType[i]; + pVal->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes; + + SOperatorNode* pOp = nodesMakeNode(QUERY_NODE_OPERATOR); + pOp->opType = OP_TYPE_GREATER_THAN; + pOp->pLeft = pCol; + pOp->pRight = pVal; + + if ((jtCtrl.leftFilterNum + jtCtrl.rightFilterNum) > 1) { + nodesListMakeStrictAppend(&pLogic->pParameterList, pOp); + } else { + p->node.pConditions = pOp; + break; + } + } + } + + if ((jtCtrl.leftFilterNum + jtCtrl.rightFilterNum) > 1) { + p->node.pConditions = pLogic; + } +} + +void updateColRowInfo() { + jtCtrl.blkRowSize = MAX_SLOT_NUM * sizeof(bool); + + for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) { + jtCtrl.colRowOffset[i] = jtCtrl.blkRowSize; + jtCtrl.blkRowSize += tDataTypes[jtInputColType[i]].bytes; + } +} + +SSortMergeJoinPhysiNode* createDummySortMergeJoinPhysiNode(EJoinType type, EJoinSubType sub, int32_t cond, bool filter, bool asc) { + SSortMergeJoinPhysiNode* p = taosMemoryCalloc(1, sizeof(SSortMergeJoinPhysiNode)); + p->joinType = type; + p->subType = sub; + p->leftPrimSlotId = LEFT_BLK_ID; + p->rightPrimSlotId = RIGHT_BLK_ID; + p->node.inputTsOrder = asc ? ORDER_ASC : ORDER_DESC; + + jtCtrl.joinType = type; + jtCtrl.subType = sub; + jtCtrl.asc = asc; + + createColCond(p, cond); + createTargetSlotList(p); + createFilterCond(p, filter); + updateColRowInfo(); + + return p; +} + +SExecTaskInfo* createDummyTaskInfo(char* taskId) { + SExecTaskInfo* p = taosMemoryCalloc(1, sizeof(SExecTaskInfo)); + p->id.str = taskId; +} + +SSDataBlock* createDummyBlock(int32_t blkId) { + SSDataBlock* p = createDataBlock(); + + p->info.id.blockId = blkId; + p->info.type = STREAM_INVALID; + p->info.calWin = (STimeWindow){.skey = INT64_MIN, .ekey = INT64_MAX}; + p->info.watermark = INT64_MIN; + + for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) { + SColumnInfoData idata = + createColumnInfoData(jtInputColType[i]), (TSDB_DATA_TYPE_BINARY != jtInputColType[i]) ? tDataTypes[jtInputColType[i]].bytes : MJ_TEST_BINARY_BYTES, i); + + blockDataAppendColInfo(p, &idata); + } + + return p; +} + +void initJoinTest() { + jtCtrl.leftBlkList = taosArrayInit(10, POINTER_BYTES); + jtCtrl.rightBlkList = taosArrayInit(10, POINTER_BYTES); + + jtCtrl.jtResRows = tSimpleHashInit(10000000, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT)); +} + +void createGrpRows(SSDataBlock** ppBlk, int32_t blkId, int32_t grpRows) { + if (grpRows <= 0) { + return; + } + + if (NULL == ppBlk) { + *ppBlk = createDummyBlock((blkId == LEFT_BLK_ID) ? LEFT_BLK_ID : RIGHT_BLK_ID); + blockDataEnsureCapacity(*ppBlk, jtCtrl.blkRows); + taosArrayPush((blkId == LEFT_BLK_ID) ? jtCtrl.leftBlkList : jtCtrl.rightBlkList, ppBlk); + } + + int32_t tableOffset = 0; + int32_t peerOffset = 0; + bool keepRes = false; + if (blkId == LEFT_BLK_ID) { + if ((jtCtrl.joinType == JOIN_TYPE_LEFT || jtCtrl.joinType == JOIN_TYPE_FULL) && jtCtrl.subType != JOIN_STYPE_SEMI) { + keepRes = true; + } + peerOffset = MAX_SLOT_NUM; + } else { + if ((jtCtrl.joinType == JOIN_TYPE_RIGHT || jtCtrl.joinType == JOIN_TYPE_FULL) && jtCtrl.subType != JOIN_STYPE_SEMI) { + keepRes = true; + } + tableOffset = MAX_SLOT_NUM; + } + + int32_t filterNum = (blkId == LEFT_BLK_ID) ? jtCtrl.leftFilterNum : jtCtrl.rightFilterNum; + int32_t peerFilterNum = (blkId == LEFT_BLK_ID) ? jtCtrl.rightFilterNum : jtCtrl.leftFilterNum; + int32_t* filterCol = (blkId == LEFT_BLK_ID) ? jtCtrl.leftFilterColList : jtCtrl.rightFilterColList; + + void* pData = NULL; + int32_t tmpInt = 0; + int64_t tmpBigint = 0; + bool isNull = false; + bool filterOut = false; + for (int32_t i = 0; i < grpRows; ++i) { + if ((*ppBlk)->info.rows >= (*ppBlk)->info.capacity) { + *ppBlk = createDummyBlock((blkId == LEFT_BLK_ID) ? LEFT_BLK_ID : RIGHT_BLK_ID); + blockDataEnsureCapacity(*ppBlk, jtCtrl.blkRows); + taosArrayPush((blkId == LEFT_BLK_ID) ? jtCtrl.leftBlkList : jtCtrl.rightBlkList, ppBlk); + } + + filterOut = peerFilterNum > 0 ? true : false; + if (!filterOut) { + memset(jtCtrl.resColBuf, 0, jtCtrl.resColSize); + } + + for (int32_t c = 0; c < MAX_SLOT_NUM; ++c) { + switch (jtInputColType[c]) { + case TSDB_DATA_TYPE_TIMESTAMP: + ++jtCtrl.curTs; + pData = &jtCtrl.curTs; + isNull = false; + if (!filterOut && filterNum && filterCol[c] && jtCtrl.curTs <= TIMESTAMP_FILTER_VALUE) { + filterOut = true; + } + break; + case TSDB_DATA_TYPE_INT: + if (taosRand() % 2) { + tmpInt = (taosRand() % 2) ? INT_FILTER_VALUE + taosRand() % 3 : INT_FILTER_VALUE - taosRand() % 3; + pData = &tmpInt; + isNull = false; + if (filterNum && filterCol[c] && tmpInt <= INT_FILTER_VALUE) { + filterOut = true; + } + } else { + isNull = true; + filterOut = (filterNum && filterCol[c]) ? true : false; + } + break; + case TSDB_DATA_TYPE_BIGINT: + tmpBigint = (taosRand() % 2) ? BIGINT_FILTER_VALUE + taosRand() % 3 : BIGINT_FILTER_VALUE - taosRand() % 3; + pData = &tmpBigint; + isNull = false; + if (filterNum && filterCol[c] && tmpBigint <= BIGINT_FILTER_VALUE) { + filterOut = true; + } + break; + default: + break; + } + + SColumnInfoData* pCol = taosArrayGet((*ppBlk)->pDataBlock, c); + colDataSetVal(pCol, (*ppBlk)->info.rows, pData, isNull); + + if (keepRes && !filterOut && jtCtrl.resColList[tableOffset + c]) { + if (isNull) { + *(char*)(jtCtrl.resColBuf + tableOffset + c) = true; + } else { + memcpy(jtCtrl.resColBuf + jtCtrl.resColOffset[tableOffset + c], pData, tDataTypes[jtInputColType[c]].bytes); + } + } + } + + if (keepRes && !filterOut) { + for (int32_t c = 0; c < MAX_SLOT_NUM; ++c) { + if (jtCtrl.resColList[peerOffset + c]) { + *(char*)(jtCtrl.resColBuf + peerOffset + c) = true; + } + } + + tSimpleHashPut(jtCtrl.jtResRows, jtCtrl.resColBuf + jtCtrl.keyColOffset, sizeof(int64_t), jtCtrl.resColBuf, jtCtrl.resColSize); + } + + (*ppBlk)->info.rows++; + } +} + +void createRowData(SSDataBlock* pBlk, int64_t tbOffset, int32_t rowIdx) { + int32_t tmpInt = 0; + int64_t tmpBig = 0; + void *pData = NULL; + + for (int32_t c = 0; c < MAX_SLOT_NUM; ++c) { + SColumnInfoData* pCol = taosArrayGet(pBlk->pDataBlock, c); + + int32_t rv = taosRand() % 2; + switch (jtInputColType[c]) { + case TSDB_DATA_TYPE_TIMESTAMP: + *(int64_t*)(jtCtrl.colRowDataBuf + tbOffset + rowIdx * jtCtrl.blkRowSize + jtCtrl.colRowOffset[c]) = jtCtrl.curTs; + colDataSetVal(pCol, pBlk->info.rows, &jtCtrl.curTs, false); + break; + case TSDB_DATA_TYPE_INT: + if (0 == rv) { + tmpInt = (taosRand() % 2) ? INT_FILTER_VALUE + taosRand() % 3 : INT_FILTER_VALUE - taosRand() % 3; + *(int32_t*)(jtCtrl.colRowDataBuf + tbOffset + rowIdx * jtCtrl.blkRowSize + jtCtrl.colRowOffset[c]) = tmpInt; + colDataSetVal(pCol, pBlk->info.rows, &tmpInt, false); + } else { + *(bool*)(jtCtrl.colRowDataBuf + tbOffset + rowIdx * jtCtrl.blkRowSize + c) = true; + colDataSetVal(pCol, pBlk->info.rows, NULL, true); + } + break; + case TSDB_DATA_TYPE_BIGINT: + if (0 == rv) { + tmpBig = (taosRand() % 2) ? BIGINT_FILTER_VALUE + taosRand() % 3 : BIGINT_FILTER_VALUE - taosRand() % 3; + *(int64_t*)(jtCtrl.colRowDataBuf + tbOffset + rowIdx * jtCtrl.blkRowSize + jtCtrl.colRowOffset[c]) = tmpBig; + colDataSetVal(pCol, pBlk->info.rows, &tmpBig, false); + } else { + *(bool*)(jtCtrl.colRowDataBuf + tbOffset + rowIdx * jtCtrl.blkRowSize + c) = true; + colDataSetVal(pCol, pBlk->info.rows, NULL, true); + } + break; + default: + break; + } + } + +} + +void makeAppendBlkData(SSDataBlock** ppLeft, SSDataBlock** ppRight, int32_t leftGrpRows, int32_t rightGrpRows) { + int64_t totalSize = (leftGrpRows + rightGrpRows) * jtCtrl.blkRowSize; + int64_t rightOffset = leftGrpRows * jtCtrl.blkRowSize; + + if (jtCtrl.colRowDataBufSize < totalSize) { + jtCtrl.colRowDataBuf = taosMemoryRealloc(jtCtrl.colRowDataBuf, totalSize); + } + + memset(jtCtrl.colRowDataBuf, 0, totalSize); + + for (int32_t i = 0; i < leftGrpRows; ++i) { + if ((*ppLeft)->info.rows >= (*ppLeft)->info.capacity) { + *ppLeft = createDummyBlock(LEFT_BLK_ID); + blockDataEnsureCapacity(*ppLeft, jtCtrl.blkRows); + taosArrayPush(jtCtrl.leftBlkList, ppLeft); + } + + createRowData(*ppLeft, 0, i); + } + + for (int32_t i = 0; i < rightGrpRows; ++i) { + if ((*ppRight)->info.rows >= (*ppRight)->info.capacity) { + *ppRight = createDummyBlock(RIGHT_BLK_ID); + blockDataEnsureCapacity(*ppRight, jtCtrl.blkRows); + taosArrayPush(jtCtrl.rightBlkList, ppRight); + } + + createRowData(*ppRight, rightOffset, i); + } + +} + +void putNMatchRowToRes(void* lrow, int32_t tableOffset, int32_t peerOffset) { + for (int32_t c = 0; c < MAX_SLOT_NUM; ++c) { + if (jtCtrl.resColList[tableOffset + c]) { + if (*(bool*)(lrow + c)) { + *(bool*)(jtCtrl.resColBuf + tableOffset + c) = true; + } else { + memcpy(jtCtrl.resColBuf + jtCtrl.resColOffset[tableOffset + c], lrow + jtCtrl.colRowOffset[c], tDataTypes[jtInputColType[c]].bytes); + } + } + } + + for (int32_t c = 0; c < MAX_SLOT_NUM; ++c) { + if (jtCtrl.resColList[peerOffset + c]) { + *(bool*)(jtCtrl.resColBuf + peerOffset + c) = true; + } + } + + tSimpleHashPut(jtCtrl.jtResRows, jtCtrl.resColBuf + jtCtrl.keyColOffset, sizeof(int64_t), jtCtrl.resColBuf, jtCtrl.resColSize); +} + +void putMatchRowToRes(void* lrow, void* rrow) { + for (int32_t c = 0; c < MAX_SLOT_NUM; ++c) { + if (jtCtrl.resColList[c]) { + if (*(bool*)(lrow + c)) { + *(bool*)(jtCtrl.resColBuf + c) = true; + } else { + memcpy(jtCtrl.resColBuf + jtCtrl.resColOffset[c], lrow + jtCtrl.colRowOffset[c], tDataTypes[jtInputColType[c]].bytes); + } + } + } + + for (int32_t c = 0; c < MAX_SLOT_NUM; ++c) { + if (jtCtrl.resColList[MAX_SLOT_NUM + c]) { + if (*(bool*)(lrow + c)) { + *(bool*)(jtCtrl.resColBuf + MAX_SLOT_NUM + c) = true; + } else { + memcpy(jtCtrl.resColBuf + jtCtrl.resColOffset[MAX_SLOT_NUM + c], rrow + jtCtrl.colRowOffset[c], tDataTypes[jtInputColType[c]].bytes); + } + } + } + + tSimpleHashPut(jtCtrl.jtResRows, jtCtrl.resColBuf + jtCtrl.keyColOffset, sizeof(int64_t), jtCtrl.resColBuf, jtCtrl.resColSize); +} + + +void leftJoinAppendEqGrpRes(int32_t leftGrpRows, int32_t rightGrpRows) { + bool rowMatch = false, filterOut = false; + bool lNullValue = false, rNullValue = false; + void* lValue = NULL, *rValue = NULL, *filterValue = NULL; + int64_t rightTbOffset = jtCtrl.blkRowSize * leftGrpRows; + + for (int32_t l = 0; l < leftGrpRows; ++l) { + void* lrow = jtCtrl.colRowDataBuf + jtCtrl.blkRowSize * l; + + rowMatch = false; + lNullValue= false; + filterOut = false; + + for (int32_t c = 0; c < MAX_SLOT_NUM; ++c) { + if (*(bool*)(lrow + c)) { + lNullValue = true; + } + + switch (jtInputColType[c]) { + case TSDB_DATA_TYPE_TIMESTAMP: + filterValue = &TIMESTAMP_FILTER_VALUE; + break; + case TSDB_DATA_TYPE_INT: + filterValue = &INT_FILTER_VALUE; + break; + case TSDB_DATA_TYPE_BIGINT: + filterValue = &BIGINT_FILTER_VALUE; + break; + default: + filterValue = NULL; + break; + } + + if (jtCtrl.leftFilterNum && jtCtrl.leftFilterColList[c] && ((*(bool*)(lrow + c)) || memcmp(lrow + jtCtrl.colRowOffset[c], filterValue, tDataTypes[jtInputColType[c]].bytes) <= 0)) { + filterOut = true; + break; + } + } + + if (filterOut) { + continue; + } + + if (lNullValue) { + putNMatchRowToRes(lrow, 0, MAX_SLOT_NUM); + continue; + } + + lValue = lrow + jtCtrl.colRowOffset[c]; + + for (int32_t r = 0; r < rightGrpRows; ++r) { + void* rrow = jtCtrl.colRowDataBuf + rightTbOffset + jtCtrl.blkRowSize * r; + filterOut = false; + + for (int32_t c = 0; c < MAX_SLOT_NUM; ++c) { + if (*(bool*)(rrow + c)) { + rNullValue = true; + } else { + rValue = rrow + jtCtrl.colRowOffset[c]; + } + + switch (jtInputColType[c]) { + case TSDB_DATA_TYPE_TIMESTAMP: + filterValue = &TIMESTAMP_FILTER_VALUE; + break; + case TSDB_DATA_TYPE_INT: + filterValue = &INT_FILTER_VALUE; + break; + case TSDB_DATA_TYPE_BIGINT: + filterValue = &BIGINT_FILTER_VALUE; + break; + default: + filterValue = NULL; + break; + } + + if (jtCtrl.colEqNum && jtCtrl.colEqList[c] && ((*(bool*)(rrow + c)) || memcmp(lValue, rValue, tDataTypes[jtInputColType[c]].bytes))) { + filterOut = true; + break; + } + + if (jtCtrl.colOnNum && jtCtrl.colOnList[c] && ((*(bool*)(rrow + c)) || memcmp(lValue, rValue, tDataTypes[jtInputColType[c]].bytes) <= 0)) { + filterOut = true; + break; + } + + if (jtCtrl.rightFilterNum && jtCtrl.rightFilterColList[c] && ((*(bool*)(rrow + c)) || memcmp(rValue, filterValue, tDataTypes[jtInputColType[c]].bytes) <= 0)) { + filterOut = true; + break; + } + } + + if (filterOut) { + continue; + } + + putMatchRowToRes(lrow, rrow); + rowMatch = true; + } + + if (!rowMatch) { + putNMatchRowToRes(lrow, 0, MAX_SLOT_NUM); + } + } + + +} + +void createTsEqGrpRows(SSDataBlock** ppLeft, SSDataBlock** ppRight, int32_t probeBlkId, int32_t leftGrpRows, int32_t rightGrpRows) { + if (leftGrpRows <= 0 && rightGrpRows <= 0) { + return; + } + + ++jtCtrl.curTs; + + if (NULL == ppLeft) { + *ppLeft = createDummyBlock(LEFT_BLK_ID); + blockDataEnsureCapacity(*ppLeft, jtCtrl.blkRows); + taosArrayPush(jtCtrl.leftBlkList, ppLeft); + } + + if (NULL == ppRight) { + *ppRight = createDummyBlock(RIGHT_BLK_ID); + blockDataEnsureCapacity(*ppRight, jtCtrl.blkRows); + taosArrayPush(jtCtrl.rightBlkList, ppRight); + } + + + makeAppendBlkData(ppLeft, ppRight, leftGrpRows, rightGrpRows); + + leftJoinAppendEqGrpRes(leftGrpRows, rightGrpRows); +} + + +void createBothBlkRowsData(void) { + SSDataBlock* pLeft = NULL; + SSDataBlock* pRight = NULL; + + bool leftEnd = taosRand() % 2 == 0; + bool rightEnd = taosRand() % 2 == 0; + + jtCtrl.leftTotalRows = taosRand() % jtCtrl.leftMaxRows; + jtCtrl.rightTotalRows = taosRand() % jtCtrl.rightMaxRows; + + int32_t minTotalRows = TMIN(jtCtrl.leftTotalRows, jtCtrl.rightTotalRows); + jtCtrl.curTs = TIMESTAMP_FILTER_VALUE - minTotalRows / 5; + + int32_t leftTotalRows = 0, rightTotalRows = 0; + int32_t leftGrpRows = 0, rightGrpRows = 0; + int32_t grpType = 0; + while (leftTotalRows < jtCtrl.leftTotalRows && rightTotalRows < jtCtrl.rightTotalRows) { + if (leftTotalRows >= jtCtrl.leftTotalRows) { + grpType = 1; + } else if (rightTotalRows >= jtCtrl.rightTotalRows) { + grpType = 0 + } else { + grpType = taosRand() % 3; + } + + leftGrpRows = taosRand() % jtCtrl.leftMaxGrpRows; + rightGrpRows = taosRand() % jtCtrl.rightMaxGrpRows; + + if ((leftTotalRows + leftGrpRows) > jtCtrl.leftTotalRows) { + leftGrpRows = jtCtrl.leftTotalRows - leftTotalRows; + } + + if ((rightTotalRows + rightGrpRows) > jtCtrl.rightTotalRows) { + rightGrpRows = jtCtrl.rightTotalRows - rightTotalRows; + } + + switch (grpType) { + case 0: + createGrpRows(&pLeft, LEFT_BLK_ID, leftGrpRows); + leftTotalRows += leftGrpRows; + break; + case 1: + createGrpRows(&pRight, RIGHT_BLK_ID, rightGrpRows); + rightTotalRows += rightGrpRows; + break; + case 2: + createTsEqGrpRows(&pLeft, &pRight, leftGrpRows, rightGrpRows); + leftTotalRows += leftGrpRows; + rightTotalRows += rightGrpRows; + break; + } + } +} + +void createDummyBlkList(int32_t leftMaxRows, int32_t leftMaxGrpRows, int32_t rightMaxRows, int32_t rightMaxGrpRows, int32_t blkRows) { + jtCtrl.leftMaxRows = leftMaxRows; + jtCtrl.leftMaxGrpRows = leftMaxGrpRows; + jtCtrl.rightMaxRows = rightMaxRows; + jtCtrl.rightMaxGrpRows = rightMaxGrpRows; + jtCtrl.blkRows = blkRows; + + createBothBlkRowsData(); +} + +void rerunBlockedHere() { + while (jtInRerun) { + taosSsleep(1); + } +} + + +SSDataBlock* getDummyInputBlock(struct SOperatorInfo* pOperator, int32_t idx) { + switch (idx) { + case LEFT_BLK_ID: + if (jtCtrl.leftBlkReadIdx >= taosArrayGetSize(jtCtrl.leftBlkList)) { + return NULL; + } + return taosArrayGet(jtCtrl.leftBlkList, jtCtrl.leftBlkReadIdx++); + break; + case RIGHT_BLK_ID: + if (jtCtrl.rightBlkReadIdx >= taosArrayGetSize(jtCtrl.rightBlkList)) { + return NULL; + } + return taosArrayGet(jtCtrl.rightBlkList, jtCtrl.rightBlkReadIdx++); + break; + default: + return NULL; + } +} + + +void joinTestReplaceRetrieveFp() { + static Stub stub; + stub.set(getNextBlockFromDownstreamRemain, getDummyInputBlock); + { +#ifdef WINDOWS + AddrAny any; + std::map result; + any.get_func_addr("rpcSendRecv", result); +#endif +#ifdef LINUX + AddrAny any("libtransport.so"); + std::map result; + any.get_global_func_addr_dynsym("^rpcSendRecv$", result); +#endif + for (const auto &f : result) { + stub.set(f.second, ctgTestRspDbVgroups); + } + } +} + +void printColList(char* title, bool left, int32_t* colList, bool filter, char* opStr) { + bool first = true; + + printf("\t%s:", title); + for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) { + if (colList[i]) { + if (!first) { + printf(" AND "); + } + first = false; + if (filter) { + printf("%sc%d%s%" PRId64 , left ? "l" : "r", i, opStr, jtFilterValue[i]); + } else { + printf("lc%d%src%d", i, opStr, i); + } + } + } + printf("\n"); +} + +void printBasicInfo(char* caseName) { + printf("\n TEST %s START\nBasic Info:\n\t asc:%d\n\t filter:%d\n\t leftMaxRows:%d\n\t leftMaxGrpRows:%d\n\t " + "rightMaxRows:%d\n\t rightMaxGrpRows:%d\n\t blkRows:%d\n\t colCond:%s\n\t \n\tjoinType:%s\n\t " + "subType:%s\n ", caseName, jtCtrl.asc, jtCtrl.filter, jtCtrl.leftMaxRows, jtCtrl.leftMaxGrpRows, + jtCtrl.rightMaxRows, jtCtrl.rightMaxGrpRows, jtCtrl.blkRows, jtColCondStr[jtCtrl.colCond], jtJoinTypeStr[jtCtrl.joinType], + jtSubTypeStr[jtCtrl.subType]); + + printf("\nInput Info:\n\t leftBlkRead:%d\n\t leftTotalBlk:%d\n\t leftTotalRows:%d\n\t rightBlkRead:%d\n\t " + "rightTotalBlk:%d\n\t rightTotalRows:%d\n\t blkRowSize:%d\n\t leftCols:%s %s %s %s\n\t rightCols:%s %s %s %s\n", + caseName, jtCtrl.leftBlkReadIdx, taosArrayGetSize(jtCtrl.leftBlkList), + jtCtrl.leftTotalRows, jtCtrl.rightBlkReadIdx, taosArrayGetSize(jtCtrl.rightBlkList), jtCtrl.rightTotalRows, + jtCtrl.blkRowSize, tDataTypes[jtInputColType[0]].name, tDataTypes[jtInputColType[1]].name, + tDataTypes[jtInputColType[2]].name, tDataTypes[jtInputColType[3]].name, tDataTypes[jtInputColType[0]].name, + tDataTypes[jtInputColType[1]].name, tDataTypes[jtInputColType[2]].name, tDataTypes[jtInputColType[3]].name, + jtCtrl.colEqNum); + + if (jtCtrl.colEqNum) { + printf("colEqNum:%d\n", jtCtrl.colEqNum); + printColList("colEqList", false, jtCtrl.colEqList, false, "="); + } + + if (jtCtrl.colOnNum) { + printf("colOnNum:%d\n", jtCtrl.colOnNum); + printColList("colOnList", false, jtCtrl.colOnList, false, ">"); + } + + if (jtCtrl.colOnNum) { + printf("colOnNum:%d\n", jtCtrl.colOnNum); + printColList("colOnList", false, jtCtrl.colOnList, false, ">"); + } + + if (jtCtrl.leftFilterNum) { + printf("leftFilterNum:%d\n", jtCtrl.leftFilterNum); + printColList("leftFilterList", true, jtCtrl.leftFilterColList, true, ">"); + } + + if (jtCtrl.rightFilterNum) { + printf("rightFilterNum:%d\n", jtCtrl.rightFilterNum); + printColList("rightFilterList", false, jtCtrl.rightFilterColList, true, ">"); + } + + printf("\tresColSize:%d\n\t resColNum:%d\n\t resColList:"); + for (int32_t i = 0; i < jtCtrl.resColNum; ++i) { + int32_t s = jtCtrl.resColInSlot[i]; + printf("%sc%d[%s]\t", s >= MAX_SLOT_NUM ? "r" : "l", s, tDataTypes[jtInputColType[s]].name); + } +} + +void printOutputInfo() { + printf("\nOutput Info:\n\t expectedRows:%d\n\t ", tSimpleHashGetSize(jtCtrl.jtResRows)); + printf("Actual Result:\n\t"); +} + +void printActualResInfo(int32_t expectedRows) { + printf("\nActual Result Summary:\n\t blkNum:%d\n\t rowNum:%d%s\n\t +rows:%d%s\n\t " + "-rows:%d%s\n\t mismatchRows:%d%s\n\t matchRows:%d%s\n", + jtRes.blkNum, jtRes.rowNum, jtRes.rowNum == expectedRows ? "" : "*", + jtRes.addRowNum, jtRes.addRowNum ? "*" : "", + jtRes.subRowNum, jtRes.subRowNum ? "*" : "", + jtRes.mismatchNum, jtRes.mismatchNum ? "*" : "", + jtRes.matchNum, jtRes.matchNum == expectedRows ? "" : "*"); +} + +void checkJoinDone(char* caseName) { + int32_t iter = 0; + void* p = NULL; + while (NULL != (p = tSimpleHashIterate(jtCtrl.jtResRows, p, &iter))) { + jtRes.succeed = false; + jtRes.subRowNum++; + printResRow(p, 0); + } + + printActualResInfo(tSimpleHashGetSize(jtCtrl.jtResRows)); + printf("\n%s Final Result: %s\n", caseName, jtRes.succeed ? "SUCCEED" : "FAILED"); + +} + +void checkJoinRes(SSDataBlock* pBlock) { + jtRes.rowNum += pBlock->info.rows; + jtRes.blkNum++; + + for (int32_t r = 0; r < pBlock->info.rows; ++r) { + for (int32_t c = 0; c < jtCtrl.resColNum; ++c) { + int32_t slot = jtCtrl.resColInSlot[c]; + SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, c); + memset(jtCtrl.resColBuf, 0, jtCtrl.resColSize); + switch (jtInputColType[slot % MAX_SLOT_NUM]) { + case TSDB_DATA_TYPE_TIMESTAMP: + case TSDB_DATA_TYPE_BIGINT: + if (colDataIsNull_s(pCol, r)) { + *(bool*)(jtCtrl.resColBuf + slot) = true; + } else { + *(int64_t*)(jtCtrl.resColBuf + jtCtrl.resColOffset[slot]) = *(int64_t*)colDataGetData(pCol, r); + } + break; + case TSDB_DATA_TYPE_INT: + if (colDataIsNull_s(pCol, r)) { + *(bool*)(jtCtrl.resColBuf + slot) = true; + } else { + *(int32_t*)(jtCtrl.resColBuf + jtCtrl.resColOffset[slot]) = *(int32_t*)colDataGetData(pCol, r); + } + break; + default: + break; + } + } + + void* value = tSimpleHashGet(jtCtrl.jtResRows, jtCtrl.resColBuf + jtCtrl.keyColOffset, sizeof(int64_t)); + if (NULL == value) { + printResRow(jtCtrl.resColBuf, 1); + jtRes.succeed = false; + jtRes.addRowNum++; + continue; + } + + if (memcmp(value, jtCtrl.resColBuf, jtCtrl.resColSize)) { + printResRow(jtCtrl.resColBuf, 1); + printResRow(value, 0); + tSimpleHashRemove(jtCtrl.jtResRows, jtCtrl.resColBuf + jtCtrl.keyColOffset, sizeof(int64_t)); + jtRes.succeed = false; + jtRes.mismatchNum++; + continue; + } + + jtRes.matchNum++; + } +} + +void resetForJoinRerun(SOperatorInfo* pDownstreams, int32_t dsNum, SSortMergeJoinPhysiNode* pNode, SExecTaskInfo* pTask) { + jtCtrl.leftBlkReadIdx = 0; + jtCtrl.rightBlkReadIdx = 0; + + jtCtrl.pJoinOp = createMergeJoinOperatorInfo(&pDownstreams, 2, pNode, pTask); + ASSERT_TRUE(NULL != jtCtrl.pJoinOp); +} + +void handleJoinError(bool* contLoop) { + if (jtRes.succeed) { + *contLoop = false; + return; + } + + if (jtErrorRerun) { + *contLoop = false; + return; + } + + jtInRerun = true; + + destroyMergeJoinOperator(jtCtrl.pJoinOp); + jtCtrl.pJoinOp = NULL; +} + + +} // namespace + +TEST(leftOuterJoin, noCondTest) { + char* caseName = "leftOuterJoin:noCondTest"; + SOperatorInfo* pDownstreams = createDummyDownstreamOperators(2); + SSortMergeJoinPhysiNode* pNode = createDummySortMergeJoinPhysiNode(JOIN_TYPE_LEFT, JOIN_STYPE_OUTER, TEST_NO_COND, false, true); + SExecTaskInfo* pTask = createDummyTaskInfo(caseName); + bool contLoop = true; + + createDummyBlkList(10, 10, 10, 10, 2); + + while (contLoop) { + rerunBlockedHere(); + resetForJoinRerun(pDownstreams, 2, pNode, pTask); + printBasicInfo(); + printOutputInfo(); + + SSDataBlock* pBlock = jtCtrl.pJoinOp->fpSet.getNextFn(jtCtrl.pJoinOp); + if (NULL == pBlock) { + checkJoinDone(caseName); + } else { + checkJoinRes(pBlock); + continue; + } + + handleJoinError(&contLoop); + } + + //ASSERT_EQ(num, ekeyNum - pos + 1); +} + + +int main(int argc, char** argv) { + taosSeedRand(taosGetTimestampSec()); + initJoinTest(); + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} + + + +#pragma GCC diagnosti diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y index d2bf92fc19..86e1da9228 100755 --- a/source/libs/parser/inc/sql.y +++ b/source/libs/parser/inc/sql.y @@ -1090,7 +1090,6 @@ join_subtype(A) ::= . join_subtype(A) ::= OUTER. { A = JOIN_STYPE_OUTER; } join_subtype(A) ::= SEMI. { A = JOIN_STYPE_SEMI; } join_subtype(A) ::= ANTI. { A = JOIN_STYPE_ANTI; } -join_subtype(A) ::= ANY. { A = JOIN_STYPE_ANY; } join_subtype(A) ::= ASOF. { A = JOIN_STYPE_ASOF; } join_subtype(A) ::= WINDOW. { A = JOIN_STYPE_WIN; } diff --git a/source/libs/parser/src/parTokenizer.c b/source/libs/parser/src/parTokenizer.c index 9f38e80945..bb09d07a77 100644 --- a/source/libs/parser/src/parTokenizer.c +++ b/source/libs/parser/src/parTokenizer.c @@ -38,7 +38,7 @@ static SKeyword keywordTable[] = { {"ANALYZE", TK_ANALYZE}, {"AND", TK_AND}, {"ANTI", TK_ANTI}, - {"ANY", TK_ANY}, +// {"ANY", TK_ANY}, {"APPS", TK_APPS}, {"AS", TK_AS}, {"ASC", TK_ASC}, diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c index ed691dfd12..1abc73595c 100644 --- a/source/libs/parser/src/sql.c +++ b/source/libs/parser/src/sql.c @@ -104,30 +104,30 @@ #endif /************* Begin control #defines *****************************************/ #define YYCODETYPE unsigned short int -#define YYNOCODE 521 +#define YYNOCODE 520 #define YYACTIONTYPE unsigned short int #define ParseTOKENTYPE SToken typedef union { int yyinit; ParseTOKENTYPE yy0; - SToken yy213; - EShowKind yy217; - STokenPair yy285; - EJoinType yy310; - int32_t yy316; - int64_t yy337; - ENullOrder yy371; - int8_t yy379; - EOperatorType yy484; - SAlterOption yy549; - SNode* yy664; - EOrder yy798; - bool yy885; - SDataType yy892; - SShowTablesOption yy943; - EJoinSubType yy972; - EFillMode yy992; - SNodeList* yy1006; + int32_t yy20; + SNodeList* yy184; + ENullOrder yy217; + EOperatorType yy220; + SToken yy369; + EFillMode yy374; + bool yy377; + SNode* yy392; + SShowTablesOption yy397; + EJoinSubType yy454; + EOrder yy578; + int8_t yy743; + SAlterOption yy845; + EShowKind yy849; + SDataType yy864; + int64_t yy909; + EJoinType yy932; + STokenPair yy937; } YYMINORTYPE; #ifndef YYSTACKDEPTH #define YYSTACKDEPTH 100 @@ -144,17 +144,17 @@ typedef union { #define ParseCTX_STORE #define YYFALLBACK 1 #define YYNSTATE 845 -#define YYNRULE 655 -#define YYNRULE_WITH_ACTION 655 -#define YYNTOKEN 356 +#define YYNRULE 654 +#define YYNRULE_WITH_ACTION 654 +#define YYNTOKEN 355 #define YY_MAX_SHIFT 844 -#define YY_MIN_SHIFTREDUCE 1260 -#define YY_MAX_SHIFTREDUCE 1914 -#define YY_ERROR_ACTION 1915 -#define YY_ACCEPT_ACTION 1916 -#define YY_NO_ACTION 1917 -#define YY_MIN_REDUCE 1918 -#define YY_MAX_REDUCE 2572 +#define YY_MIN_SHIFTREDUCE 1259 +#define YY_MAX_SHIFTREDUCE 1912 +#define YY_ERROR_ACTION 1913 +#define YY_ACCEPT_ACTION 1914 +#define YY_NO_ACTION 1915 +#define YY_MIN_REDUCE 1916 +#define YY_MAX_REDUCE 2569 /************* End control #defines *******************************************/ #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) @@ -221,933 +221,911 @@ typedef union { ** yy_default[] Default action for each state. ** *********** Begin parsing tables **********************************************/ -#define YY_ACTTAB_COUNT (3348) +#define YY_ACTTAB_COUNT (3236) static const YYACTIONTYPE yy_action[] = { - /* 0 */ 561, 2095, 423, 562, 1961, 241, 730, 2106, 697, 564, - /* 10 */ 168, 1969, 48, 46, 1838, 2543, 1941, 402, 2108, 189, - /* 20 */ 420, 1919, 1663, 41, 40, 2157, 212, 47, 45, 44, - /* 30 */ 43, 42, 173, 696, 208, 1748, 2002, 1661, 2544, 698, - /* 40 */ 2045, 388, 127, 2219, 2358, 126, 125, 124, 123, 122, - /* 50 */ 121, 120, 119, 118, 41, 40, 1405, 712, 47, 45, - /* 60 */ 44, 43, 42, 1918, 1743, 1689, 1692, 41, 40, 2324, - /* 70 */ 19, 47, 45, 44, 43, 42, 425, 1669, 1688, 2152, - /* 80 */ 2154, 709, 146, 639, 1689, 2376, 2239, 136, 135, 134, - /* 90 */ 133, 132, 131, 130, 129, 128, 1407, 2324, 637, 746, - /* 100 */ 635, 273, 272, 841, 2237, 717, 15, 566, 816, 815, - /* 110 */ 814, 813, 432, 563, 812, 811, 151, 806, 805, 804, + /* 0 */ 561, 2093, 423, 562, 1959, 241, 730, 2104, 697, 564, + /* 10 */ 168, 1967, 48, 46, 1836, 2540, 1939, 402, 2106, 189, + /* 20 */ 420, 1917, 1662, 41, 40, 2155, 212, 47, 45, 44, + /* 30 */ 43, 42, 173, 696, 208, 1747, 2000, 1660, 2541, 698, + /* 40 */ 2043, 388, 127, 2217, 2356, 126, 125, 124, 123, 122, + /* 50 */ 121, 120, 119, 118, 41, 40, 1404, 712, 47, 45, + /* 60 */ 44, 43, 42, 1916, 1742, 1688, 1691, 41, 40, 2322, + /* 70 */ 19, 47, 45, 44, 43, 42, 425, 1668, 1687, 2150, + /* 80 */ 2152, 709, 146, 639, 1688, 2374, 2237, 136, 135, 134, + /* 90 */ 133, 132, 131, 130, 129, 128, 1406, 2322, 637, 746, + /* 100 */ 635, 273, 272, 841, 2235, 717, 15, 581, 816, 815, + /* 110 */ 814, 813, 432, 729, 812, 811, 151, 806, 805, 804, /* 120 */ 803, 802, 801, 800, 150, 794, 793, 792, 431, 430, - /* 130 */ 789, 788, 787, 188, 187, 786, 1300, 729, 2357, 730, - /* 140 */ 2106, 2395, 1750, 1751, 114, 2359, 750, 2361, 2362, 745, - /* 150 */ 2159, 740, 9, 709, 146, 1307, 191, 569, 2448, 56, - /* 160 */ 562, 1961, 416, 2444, 127, 716, 1880, 126, 125, 124, - /* 170 */ 123, 122, 121, 120, 119, 118, 1723, 1733, 1302, 1305, - /* 180 */ 1306, 209, 2548, 1749, 1752, 259, 1989, 1583, 1584, 2494, - /* 190 */ 729, 184, 2456, 708, 1307, 138, 707, 106, 1664, 1691, - /* 200 */ 1662, 182, 2543, 2334, 2317, 1911, 1497, 1498, 624, 598, - /* 210 */ 594, 590, 586, 799, 258, 2005, 2067, 2342, 1305, 1306, - /* 220 */ 696, 208, 2099, 277, 204, 2544, 698, 2338, 1582, 1585, - /* 230 */ 1667, 1668, 1720, 650, 1722, 1725, 1726, 1727, 1728, 1729, - /* 240 */ 1730, 1731, 1732, 742, 738, 1741, 1742, 1744, 1745, 1746, - /* 250 */ 1747, 2, 48, 46, 667, 96, 578, 368, 256, 1686, - /* 260 */ 420, 2543, 1663, 181, 2456, 2457, 512, 144, 2461, 531, - /* 270 */ 201, 2340, 417, 2082, 530, 1748, 51, 1661, 1693, 2549, - /* 280 */ 208, 740, 2146, 729, 2544, 698, 1904, 623, 622, 621, - /* 290 */ 494, 63, 532, 2463, 613, 143, 617, 496, 1632, 1633, - /* 300 */ 616, 1326, 474, 1325, 1743, 615, 620, 396, 395, 2548, - /* 310 */ 19, 614, 579, 2232, 610, 1692, 2543, 1669, 142, 2460, - /* 320 */ 1910, 558, 246, 1816, 1817, 1818, 1819, 1820, 1821, 556, - /* 330 */ 255, 248, 552, 548, 2159, 2547, 1327, 253, 575, 2544, - /* 340 */ 2546, 401, 785, 841, 389, 1462, 15, 528, 526, 2157, - /* 350 */ 369, 709, 146, 686, 221, 482, 245, 307, 2463, 1453, - /* 360 */ 775, 774, 773, 1457, 772, 1459, 1460, 771, 768, 51, - /* 370 */ 1468, 765, 1470, 1471, 762, 759, 756, 1811, 1812, 1813, - /* 380 */ 1814, 2376, 1750, 1751, 2459, 2226, 2205, 1688, 519, 518, + /* 130 */ 789, 788, 787, 188, 187, 786, 1299, 63, 2355, 730, + /* 140 */ 2104, 2393, 1749, 1750, 114, 2357, 750, 2359, 2360, 745, + /* 150 */ 174, 740, 1928, 709, 146, 1306, 191, 569, 2446, 56, + /* 160 */ 562, 1959, 416, 2442, 127, 112, 1878, 126, 125, 124, + /* 170 */ 123, 122, 121, 120, 119, 118, 1722, 1732, 1301, 1304, + /* 180 */ 1305, 209, 147, 1748, 1751, 259, 1671, 1582, 1583, 2491, + /* 190 */ 2096, 184, 2454, 708, 9, 138, 707, 729, 1663, 51, + /* 200 */ 1661, 182, 2540, 2332, 2315, 1909, 1496, 1497, 651, 598, + /* 210 */ 594, 590, 586, 566, 258, 2003, 1840, 2340, 1859, 563, + /* 220 */ 696, 208, 1687, 277, 204, 2541, 698, 2336, 1581, 1584, + /* 230 */ 1666, 1667, 1719, 1860, 1721, 1724, 1725, 1726, 1727, 1728, + /* 240 */ 1729, 1730, 1731, 742, 738, 1740, 1741, 1743, 1744, 1745, + /* 250 */ 1746, 2, 48, 46, 667, 96, 522, 368, 256, 1685, + /* 260 */ 420, 2540, 1662, 180, 2454, 2455, 512, 144, 2459, 531, + /* 270 */ 1938, 2338, 417, 1858, 530, 1747, 2157, 1660, 1692, 2546, + /* 280 */ 208, 740, 571, 2276, 2541, 698, 95, 623, 622, 621, + /* 290 */ 494, 716, 532, 1687, 613, 143, 617, 496, 1631, 1632, + /* 300 */ 616, 2332, 474, 390, 1742, 615, 620, 396, 395, 309, + /* 310 */ 19, 614, 2099, 687, 610, 2095, 2461, 1668, 231, 1908, + /* 320 */ 243, 650, 246, 2322, 564, 2336, 1967, 1937, 41, 40, + /* 330 */ 255, 248, 47, 45, 44, 43, 42, 253, 575, 682, + /* 340 */ 521, 520, 2458, 841, 389, 1461, 15, 528, 526, 1674, + /* 350 */ 369, 651, 1936, 30, 221, 482, 245, 730, 2104, 1452, + /* 360 */ 775, 774, 773, 1456, 772, 1458, 1459, 771, 768, 2338, + /* 370 */ 1467, 765, 1469, 1470, 762, 759, 756, 137, 1723, 740, + /* 380 */ 2322, 1308, 1749, 1750, 604, 2224, 2203, 1686, 519, 518, /* 390 */ 517, 516, 511, 510, 509, 508, 507, 502, 501, 500, - /* 400 */ 499, 372, 491, 490, 489, 577, 484, 483, 387, 172, - /* 410 */ 730, 2106, 1551, 1552, 346, 34, 1723, 1733, 1570, 730, - /* 420 */ 2106, 41, 40, 1749, 1752, 47, 45, 44, 43, 42, - /* 430 */ 137, 343, 74, 171, 1326, 73, 1325, 604, 1664, 137, - /* 440 */ 1662, 2109, 685, 682, 189, 370, 609, 41, 40, 2318, - /* 450 */ 1692, 47, 45, 44, 43, 42, 239, 543, 541, 538, - /* 460 */ 711, 175, 2456, 2457, 309, 144, 2461, 227, 2220, 1327, - /* 470 */ 1667, 1668, 1720, 199, 1722, 1725, 1726, 1727, 1728, 1729, - /* 480 */ 1730, 1731, 1732, 742, 738, 1741, 1742, 1744, 1745, 1746, - /* 490 */ 1747, 2, 12, 48, 46, 522, 52, 63, 796, 667, - /* 500 */ 276, 420, 95, 1663, 275, 649, 2543, 581, 90, 380, - /* 510 */ 174, 89, 1930, 623, 622, 621, 1748, 646, 1661, 390, - /* 520 */ 613, 143, 617, 844, 2549, 208, 616, 1693, 2101, 2544, - /* 530 */ 698, 615, 620, 396, 395, 64, 2358, 614, 1972, 332, - /* 540 */ 610, 1869, 309, 1563, 1564, 1743, 688, 683, 676, 747, - /* 550 */ 243, 19, 785, 1777, 564, 198, 1969, 231, 1669, 2463, - /* 560 */ 394, 393, 798, 832, 828, 824, 820, 667, 329, 95, - /* 570 */ 98, 112, 648, 375, 2543, 88, 400, 2376, 641, 521, - /* 580 */ 520, 84, 83, 470, 841, 2458, 220, 15, 147, 2324, - /* 590 */ 834, 746, 2549, 208, 1688, 2102, 2098, 2544, 698, 462, - /* 600 */ 460, 679, 678, 1867, 1868, 1870, 1871, 1872, 203, 113, - /* 610 */ 371, 159, 323, 451, 1778, 36, 448, 444, 440, 437, - /* 620 */ 463, 41, 40, 1750, 1751, 47, 45, 44, 43, 42, - /* 630 */ 2357, 392, 391, 2395, 606, 611, 114, 2359, 750, 2361, - /* 640 */ 2362, 745, 666, 740, 726, 687, 149, 2547, 156, 2419, - /* 650 */ 2448, 2159, 429, 428, 416, 2444, 608, 1723, 1733, 1402, - /* 660 */ 607, 1940, 1693, 1692, 1749, 1752, 725, 41, 40, 309, - /* 670 */ 309, 47, 45, 44, 43, 42, 12, 1670, 10, 1664, - /* 680 */ 63, 1662, 41, 40, 312, 55, 47, 45, 44, 43, - /* 690 */ 42, 311, 30, 651, 37, 418, 1772, 1773, 1774, 1775, - /* 700 */ 1776, 1780, 1781, 1782, 1783, 47, 45, 44, 43, 42, - /* 710 */ 281, 1667, 1668, 1720, 2324, 1722, 1725, 1726, 1727, 1728, - /* 720 */ 1729, 1730, 1731, 1732, 742, 738, 1741, 1742, 1744, 1745, - /* 730 */ 1746, 1747, 2, 48, 46, 1753, 68, 730, 2106, 63, - /* 740 */ 12, 420, 2358, 1663, 2468, 1811, 1812, 1813, 1814, 2468, - /* 750 */ 2468, 2468, 2468, 2468, 2468, 712, 1748, 471, 1661, 783, - /* 760 */ 161, 160, 780, 779, 778, 158, 1881, 571, 2278, 2239, - /* 770 */ 61, 1916, 1811, 1812, 1813, 1814, 2358, 99, 664, 1779, - /* 780 */ 2334, 628, 455, 2376, 413, 1743, 2159, 2236, 717, 747, - /* 790 */ 1417, 1971, 414, 410, 2097, 2324, 640, 746, 1669, 2159, - /* 800 */ 171, 2157, 480, 2215, 2338, 1416, 386, 1611, 2108, 457, - /* 810 */ 453, 732, 274, 2420, 2157, 41, 40, 2376, 1421, 47, - /* 820 */ 45, 44, 43, 42, 841, 486, 2215, 49, 631, 2324, - /* 830 */ 465, 746, 464, 1420, 1669, 625, 2357, 1663, 63, 2395, - /* 840 */ 1673, 271, 114, 2359, 750, 2361, 2362, 745, 2340, 740, - /* 850 */ 435, 223, 1661, 309, 191, 434, 2448, 1720, 740, 35, - /* 860 */ 416, 2444, 463, 1750, 1751, 2083, 651, 467, 776, 1784, - /* 870 */ 2357, 533, 466, 2395, 225, 1693, 114, 2359, 750, 2361, - /* 880 */ 2362, 745, 72, 740, 697, 71, 2159, 2495, 2563, 202, - /* 890 */ 2448, 2543, 1669, 415, 416, 2444, 1842, 1723, 1733, 535, - /* 900 */ 667, 2157, 1688, 1835, 1749, 1752, 734, 2543, 2420, 696, - /* 910 */ 208, 111, 309, 1688, 2544, 698, 2081, 667, 841, 1664, - /* 920 */ 108, 1662, 316, 317, 2543, 2549, 208, 315, 41, 40, - /* 930 */ 2544, 698, 47, 45, 44, 43, 42, 514, 2215, 1758, - /* 940 */ 653, 2278, 2549, 208, 700, 1688, 1939, 2544, 698, 38, - /* 950 */ 325, 1667, 1668, 1720, 2091, 1722, 1725, 1726, 1727, 1728, - /* 960 */ 1729, 1730, 1731, 1732, 742, 738, 1741, 1742, 1744, 1745, - /* 970 */ 1746, 1747, 2, 48, 46, 2159, 2358, 730, 2106, 2190, - /* 980 */ 608, 420, 424, 1663, 607, 170, 230, 730, 2106, 747, - /* 990 */ 2157, 2502, 730, 2106, 730, 2106, 1748, 472, 1661, 2324, - /* 1000 */ 783, 161, 160, 780, 779, 778, 158, 488, 2358, 2548, - /* 1010 */ 691, 309, 503, 1664, 504, 1662, 2543, 2376, 709, 146, - /* 1020 */ 423, 747, 1938, 2515, 330, 1743, 426, 1854, 171, 2324, - /* 1030 */ 148, 746, 1861, 2419, 171, 2547, 2108, 2093, 1669, 2544, - /* 1040 */ 2545, 777, 2108, 652, 2150, 1667, 1668, 1862, 1688, 2376, - /* 1050 */ 3, 783, 161, 160, 780, 779, 778, 158, 1724, 14, - /* 1060 */ 13, 2324, 54, 746, 841, 730, 2106, 49, 2334, 1724, - /* 1070 */ 2357, 2153, 2154, 2395, 1824, 2324, 114, 2359, 750, 2361, - /* 1080 */ 2362, 745, 2343, 740, 2305, 580, 1937, 1860, 2563, 1936, - /* 1090 */ 2448, 713, 2338, 667, 416, 2444, 730, 2106, 600, 599, - /* 1100 */ 2543, 1724, 2357, 1750, 1751, 2395, 1691, 1935, 114, 2359, - /* 1110 */ 750, 2361, 2362, 745, 1721, 740, 505, 1934, 2549, 208, - /* 1120 */ 2563, 1933, 2448, 2544, 698, 1721, 416, 2444, 176, 2456, - /* 1130 */ 2457, 1932, 144, 2461, 730, 2106, 2340, 1723, 1733, 2324, - /* 1140 */ 498, 667, 2324, 2159, 1749, 1752, 740, 1309, 2543, 497, - /* 1150 */ 44, 43, 42, 1687, 2103, 730, 2106, 1721, 2158, 1664, - /* 1160 */ 2324, 1662, 1929, 730, 2106, 1791, 2549, 208, 730, 2106, - /* 1170 */ 2324, 2544, 698, 781, 2324, 279, 2150, 1928, 1329, 1330, - /* 1180 */ 1834, 1927, 1926, 287, 2324, 602, 601, 1925, 715, 1924, - /* 1190 */ 1923, 1667, 1668, 1720, 737, 1722, 1725, 1726, 1727, 1728, - /* 1200 */ 1729, 1730, 1731, 1732, 742, 738, 1741, 1742, 1744, 1745, - /* 1210 */ 1746, 1747, 2, 48, 46, 2324, 2358, 730, 2106, 730, - /* 1220 */ 2106, 420, 1922, 1663, 730, 2106, 730, 2106, 2287, 747, - /* 1230 */ 2324, 674, 730, 2106, 2324, 2324, 1748, 320, 1661, 727, - /* 1240 */ 2324, 2308, 2324, 2324, 728, 1921, 326, 76, 2358, 619, - /* 1250 */ 618, 2200, 427, 810, 808, 339, 782, 2376, 2136, 2150, - /* 1260 */ 1721, 747, 139, 2536, 307, 1743, 2084, 1946, 836, 2324, - /* 1270 */ 264, 746, 612, 262, 86, 2324, 266, 268, 1669, 265, - /* 1280 */ 267, 270, 278, 1980, 269, 643, 701, 642, 288, 2376, - /* 1290 */ 1978, 159, 442, 478, 1672, 159, 1400, 87, 2324, 152, - /* 1300 */ 50, 2324, 50, 746, 841, 626, 192, 15, 214, 704, - /* 1310 */ 2357, 1671, 629, 2395, 2345, 159, 114, 2359, 750, 2361, - /* 1320 */ 2362, 745, 50, 740, 1913, 1914, 314, 2089, 2563, 75, - /* 1330 */ 2448, 157, 100, 159, 416, 2444, 14, 13, 66, 50, - /* 1340 */ 50, 2110, 2357, 1750, 1751, 2395, 754, 284, 114, 2359, - /* 1350 */ 750, 2361, 2362, 745, 1769, 740, 157, 1360, 741, 2046, - /* 1360 */ 2563, 1931, 2448, 429, 428, 1627, 416, 2444, 2358, 1630, - /* 1370 */ 790, 2347, 180, 1677, 1866, 2508, 1865, 1723, 1733, 159, - /* 1380 */ 293, 747, 140, 302, 1749, 1752, 1748, 157, 1670, 714, - /* 1390 */ 303, 680, 791, 141, 1379, 710, 1580, 1361, 295, 1664, - /* 1400 */ 318, 1662, 2377, 722, 2043, 322, 2224, 1447, 2042, 2376, - /* 1410 */ 1962, 2498, 1785, 1734, 338, 1743, 1377, 677, 406, 684, - /* 1420 */ 1475, 2324, 403, 746, 719, 433, 1968, 660, 1669, 2225, - /* 1430 */ 1479, 1667, 1668, 1720, 2147, 1722, 1725, 1726, 1727, 1728, - /* 1440 */ 1729, 1730, 1731, 1732, 742, 738, 1741, 1742, 1744, 1745, - /* 1450 */ 1746, 1747, 2, 1486, 736, 2499, 1484, 1675, 2509, 692, - /* 1460 */ 693, 162, 2357, 305, 2068, 2395, 300, 308, 114, 2359, - /* 1470 */ 750, 2361, 2362, 745, 1674, 740, 5, 436, 441, 384, - /* 1480 */ 2563, 449, 2448, 450, 1696, 459, 416, 2444, 458, 215, - /* 1490 */ 216, 461, 218, 1604, 333, 1686, 475, 1687, 479, 229, - /* 1500 */ 481, 485, 487, 524, 513, 492, 506, 523, 2217, 515, - /* 1510 */ 525, 536, 537, 534, 234, 539, 236, 233, 542, 2358, - /* 1520 */ 540, 544, 1694, 559, 4, 560, 567, 570, 244, 92, - /* 1530 */ 1689, 568, 747, 572, 247, 1695, 1697, 573, 574, 576, - /* 1540 */ 1698, 2233, 582, 603, 605, 250, 2096, 645, 647, 1678, - /* 1550 */ 252, 1673, 2358, 93, 94, 702, 257, 632, 261, 116, - /* 1560 */ 2376, 633, 365, 2296, 2293, 747, 97, 2292, 280, 2092, - /* 1570 */ 153, 1690, 2324, 2279, 746, 263, 655, 164, 165, 654, - /* 1580 */ 705, 1681, 1683, 2094, 2090, 166, 167, 334, 285, 2358, - /* 1590 */ 662, 2514, 661, 2376, 659, 738, 1741, 1742, 1744, 1745, - /* 1600 */ 1746, 1747, 747, 671, 681, 2324, 720, 746, 2513, 8, - /* 1610 */ 2486, 690, 670, 2357, 183, 672, 2395, 290, 294, 114, - /* 1620 */ 2359, 750, 2361, 2362, 745, 656, 740, 292, 299, 296, - /* 1630 */ 2376, 2423, 283, 2448, 695, 669, 298, 416, 2444, 297, - /* 1640 */ 694, 706, 2324, 2467, 746, 407, 2357, 1691, 703, 2395, - /* 1650 */ 145, 1832, 114, 2359, 750, 2361, 2362, 745, 1830, 740, - /* 1660 */ 2464, 2358, 2566, 310, 2421, 195, 2448, 335, 718, 154, - /* 1670 */ 416, 2444, 2247, 2246, 747, 2245, 336, 723, 724, 155, - /* 1680 */ 412, 105, 337, 2357, 62, 301, 2395, 2429, 752, 114, - /* 1690 */ 2359, 750, 2361, 2362, 745, 107, 740, 2107, 1, 210, - /* 1700 */ 2151, 733, 2376, 2448, 2358, 340, 1284, 416, 2444, 328, - /* 1710 */ 835, 838, 840, 304, 2324, 349, 746, 747, 2542, 53, - /* 1720 */ 163, 363, 342, 353, 344, 364, 376, 2316, 2315, 2314, - /* 1730 */ 377, 81, 2309, 2358, 438, 439, 1654, 1655, 213, 2307, - /* 1740 */ 443, 445, 447, 446, 1653, 2376, 747, 2306, 385, 2304, - /* 1750 */ 452, 2303, 454, 2302, 456, 2357, 1643, 2324, 2395, 746, - /* 1760 */ 2283, 115, 2359, 750, 2361, 2362, 745, 217, 740, 2282, - /* 1770 */ 219, 1607, 82, 1606, 2376, 2448, 2260, 2259, 2258, 2447, - /* 1780 */ 2444, 468, 2257, 469, 2256, 2207, 2324, 473, 746, 1550, - /* 1790 */ 2199, 476, 477, 2196, 222, 2195, 2194, 85, 2357, 2193, - /* 1800 */ 2358, 2395, 2198, 2197, 115, 2359, 750, 2361, 2362, 745, - /* 1810 */ 224, 740, 2192, 744, 2191, 2189, 2188, 2187, 2448, 226, - /* 1820 */ 493, 2186, 735, 2444, 495, 2202, 2185, 748, 2184, 2358, - /* 1830 */ 2395, 2183, 2182, 115, 2359, 750, 2361, 2362, 745, 2181, - /* 1840 */ 740, 2376, 747, 2204, 2180, 2179, 2178, 2448, 527, 228, - /* 1850 */ 2170, 379, 2444, 2324, 2177, 746, 2176, 2175, 2174, 2173, - /* 1860 */ 2172, 2171, 2169, 91, 2168, 2167, 2203, 2201, 2166, 2165, - /* 1870 */ 2376, 2164, 232, 1556, 2163, 2162, 529, 2161, 2160, 373, - /* 1880 */ 2008, 2007, 2324, 374, 746, 1418, 235, 237, 2006, 1414, - /* 1890 */ 2004, 238, 1422, 2001, 2357, 547, 2000, 2395, 546, 1993, - /* 1900 */ 361, 2359, 750, 2361, 2362, 745, 743, 740, 731, 2413, - /* 1910 */ 545, 2358, 1982, 549, 551, 1957, 553, 1308, 1956, 557, - /* 1920 */ 190, 2281, 2277, 2357, 747, 555, 2395, 78, 2267, 177, - /* 1930 */ 2359, 750, 2361, 2362, 745, 550, 740, 554, 2344, 240, - /* 1940 */ 200, 2358, 2255, 242, 565, 251, 79, 249, 2254, 2231, - /* 1950 */ 254, 2085, 2376, 2003, 747, 1999, 583, 584, 585, 1997, - /* 1960 */ 587, 588, 589, 1353, 2324, 1995, 746, 591, 592, 593, - /* 1970 */ 1992, 595, 1977, 597, 1975, 668, 2505, 596, 1976, 2358, - /* 1980 */ 1974, 1953, 2376, 2087, 1491, 1490, 2086, 1404, 1990, 1403, - /* 1990 */ 807, 1401, 747, 1399, 2324, 1398, 746, 1397, 1396, 1395, - /* 2000 */ 809, 1392, 1981, 1391, 1390, 2357, 2358, 397, 2395, 260, - /* 2010 */ 1389, 178, 2359, 750, 2361, 2362, 745, 398, 740, 747, - /* 2020 */ 2376, 65, 627, 1979, 630, 399, 1952, 1951, 1950, 634, - /* 2030 */ 1949, 636, 2324, 1948, 746, 2357, 638, 117, 2395, 1641, - /* 2040 */ 2280, 115, 2359, 750, 2361, 2362, 745, 2376, 740, 2358, - /* 2050 */ 1637, 29, 404, 1639, 1617, 2448, 1636, 282, 2276, 2324, - /* 2060 */ 2445, 746, 747, 1615, 2358, 2266, 1613, 657, 2253, 699, - /* 2070 */ 2564, 2252, 2548, 2357, 69, 20, 2395, 747, 17, 177, - /* 2080 */ 2359, 750, 2361, 2362, 745, 31, 740, 57, 6, 58, - /* 2090 */ 2376, 658, 1592, 663, 673, 405, 1883, 289, 7, 169, - /* 2100 */ 2357, 675, 2324, 2395, 746, 2376, 362, 2359, 750, 2361, - /* 2110 */ 2362, 745, 291, 740, 286, 1591, 21, 2324, 22, 746, - /* 2120 */ 665, 2358, 1864, 194, 179, 205, 2506, 193, 32, 2345, - /* 2130 */ 33, 1853, 1825, 206, 747, 1827, 67, 80, 207, 23, - /* 2140 */ 24, 1823, 1903, 2357, 1904, 1898, 2395, 1897, 408, 362, - /* 2150 */ 2359, 750, 2361, 2362, 745, 1902, 740, 1901, 2357, 409, - /* 2160 */ 1808, 2395, 2376, 1807, 355, 2359, 750, 2361, 2362, 745, - /* 2170 */ 306, 740, 60, 185, 2324, 2251, 746, 2230, 101, 102, - /* 2180 */ 25, 2229, 313, 721, 1859, 196, 18, 319, 70, 2358, - /* 2190 */ 59, 103, 321, 104, 324, 26, 1760, 11, 1759, 108, - /* 2200 */ 13, 1679, 747, 1738, 186, 1770, 1736, 2358, 2398, 739, - /* 2210 */ 39, 1713, 1735, 197, 689, 2357, 1705, 749, 2395, 16, - /* 2220 */ 744, 178, 2359, 750, 2361, 2362, 745, 753, 740, 27, - /* 2230 */ 2376, 28, 751, 1476, 422, 411, 755, 757, 1473, 1472, - /* 2240 */ 758, 760, 2324, 1469, 746, 763, 761, 764, 2376, 1463, - /* 2250 */ 766, 1461, 767, 769, 770, 1467, 1466, 109, 327, 110, - /* 2260 */ 2324, 1485, 746, 77, 1481, 1465, 1351, 1386, 1412, 784, - /* 2270 */ 1464, 1383, 1382, 1381, 1380, 1378, 1376, 1375, 1374, 1411, - /* 2280 */ 2565, 211, 795, 2357, 2358, 797, 2395, 1372, 1371, 362, - /* 2290 */ 2359, 750, 2361, 2362, 745, 1370, 740, 747, 1369, 1368, - /* 2300 */ 1367, 2357, 1366, 1408, 2395, 1406, 1363, 361, 2359, 750, - /* 2310 */ 2361, 2362, 745, 1357, 740, 1362, 2414, 1359, 1358, 1356, - /* 2320 */ 1998, 817, 818, 1996, 821, 2376, 822, 819, 823, 1994, - /* 2330 */ 419, 825, 827, 1991, 826, 829, 1973, 2324, 831, 746, - /* 2340 */ 830, 833, 1297, 1947, 1285, 837, 331, 1665, 839, 1917, - /* 2350 */ 341, 842, 2358, 1917, 843, 1917, 1917, 1917, 1917, 1917, - /* 2360 */ 1917, 1917, 1917, 1917, 1917, 747, 1917, 1917, 1917, 1917, - /* 2370 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 2357, 2358, - /* 2380 */ 1917, 2395, 1917, 1917, 362, 2359, 750, 2361, 2362, 745, - /* 2390 */ 1917, 740, 747, 2376, 1917, 2358, 1917, 1917, 421, 1917, - /* 2400 */ 1917, 1917, 1917, 1917, 1917, 2324, 1917, 746, 747, 1917, - /* 2410 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, - /* 2420 */ 2376, 1917, 2358, 1917, 1917, 1917, 1917, 1917, 1917, 1917, - /* 2430 */ 1917, 1917, 2324, 1917, 746, 747, 2376, 1917, 1917, 1917, - /* 2440 */ 1917, 1917, 1917, 1917, 1917, 1917, 2357, 1917, 2324, 2395, - /* 2450 */ 746, 1917, 362, 2359, 750, 2361, 2362, 745, 1917, 740, - /* 2460 */ 1917, 1917, 1917, 2376, 1917, 2358, 1917, 1917, 1917, 1917, - /* 2470 */ 1917, 1917, 1917, 644, 1917, 2324, 2395, 746, 747, 357, - /* 2480 */ 2359, 750, 2361, 2362, 745, 1917, 740, 1917, 1917, 2357, - /* 2490 */ 1917, 1917, 2395, 1917, 2358, 347, 2359, 750, 2361, 2362, - /* 2500 */ 745, 1917, 740, 1917, 1917, 1917, 2376, 747, 1917, 1917, - /* 2510 */ 1917, 1917, 1917, 1917, 1917, 1917, 2357, 1917, 2324, 2395, - /* 2520 */ 746, 1917, 345, 2359, 750, 2361, 2362, 745, 1917, 740, - /* 2530 */ 1917, 1917, 1917, 1917, 1917, 2376, 1917, 1917, 1917, 1917, - /* 2540 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 2324, 1917, 746, - /* 2550 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 2357, - /* 2560 */ 1917, 1917, 2395, 1917, 1917, 348, 2359, 750, 2361, 2362, - /* 2570 */ 745, 1917, 740, 1917, 2358, 1917, 1917, 1917, 1917, 1917, - /* 2580 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 747, 2357, 1917, - /* 2590 */ 2358, 2395, 1917, 1917, 354, 2359, 750, 2361, 2362, 745, - /* 2600 */ 1917, 740, 1917, 747, 1917, 1917, 1917, 1917, 2358, 1917, - /* 2610 */ 1917, 1917, 1917, 1917, 1917, 2376, 1917, 1917, 1917, 1917, - /* 2620 */ 1917, 747, 1917, 1917, 1917, 1917, 1917, 2324, 1917, 746, - /* 2630 */ 1917, 2376, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, - /* 2640 */ 1917, 1917, 1917, 2324, 1917, 746, 1917, 1917, 1917, 2376, - /* 2650 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, - /* 2660 */ 1917, 2324, 1917, 746, 1917, 1917, 1917, 1917, 2357, 1917, - /* 2670 */ 1917, 2395, 1917, 1917, 358, 2359, 750, 2361, 2362, 745, - /* 2680 */ 1917, 740, 1917, 1917, 2357, 2358, 1917, 2395, 1917, 1917, - /* 2690 */ 350, 2359, 750, 2361, 2362, 745, 1917, 740, 747, 1917, - /* 2700 */ 1917, 1917, 2357, 1917, 1917, 2395, 1917, 1917, 359, 2359, - /* 2710 */ 750, 2361, 2362, 745, 1917, 740, 1917, 1917, 1917, 1917, - /* 2720 */ 1917, 1917, 1917, 1917, 1917, 1917, 2376, 1917, 1917, 1917, - /* 2730 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 2324, 1917, - /* 2740 */ 746, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, - /* 2750 */ 1917, 1917, 2358, 1917, 1917, 1917, 1917, 1917, 1917, 1917, - /* 2760 */ 1917, 1917, 1917, 1917, 1917, 747, 1917, 2358, 1917, 1917, - /* 2770 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 2357, - /* 2780 */ 747, 1917, 2395, 1917, 1917, 351, 2359, 750, 2361, 2362, - /* 2790 */ 745, 1917, 740, 2376, 1917, 1917, 1917, 1917, 1917, 1917, - /* 2800 */ 1917, 1917, 1917, 1917, 1917, 2324, 1917, 746, 2376, 1917, - /* 2810 */ 2358, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, - /* 2820 */ 2324, 1917, 746, 747, 1917, 2358, 1917, 1917, 1917, 1917, - /* 2830 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 747, 1917, - /* 2840 */ 1917, 1917, 1917, 1917, 1917, 1917, 2357, 1917, 1917, 2395, - /* 2850 */ 1917, 2376, 360, 2359, 750, 2361, 2362, 745, 1917, 740, - /* 2860 */ 1917, 2357, 1917, 2324, 2395, 746, 2376, 352, 2359, 750, - /* 2870 */ 2361, 2362, 745, 1917, 740, 1917, 1917, 1917, 2324, 1917, - /* 2880 */ 746, 1917, 2358, 1917, 1917, 1917, 1917, 1917, 1917, 1917, - /* 2890 */ 1917, 1917, 1917, 1917, 1917, 747, 1917, 1917, 1917, 1917, - /* 2900 */ 1917, 1917, 1917, 1917, 2357, 1917, 1917, 2395, 1917, 1917, - /* 2910 */ 366, 2359, 750, 2361, 2362, 745, 1917, 740, 1917, 2357, - /* 2920 */ 1917, 1917, 2395, 2376, 1917, 367, 2359, 750, 2361, 2362, - /* 2930 */ 745, 1917, 740, 1917, 1917, 2324, 1917, 746, 1917, 1917, - /* 2940 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 2358, 1917, 1917, - /* 2950 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, - /* 2960 */ 747, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 2358, 1917, - /* 2970 */ 1917, 1917, 1917, 1917, 1917, 1917, 2357, 1917, 1917, 2395, - /* 2980 */ 1917, 747, 2370, 2359, 750, 2361, 2362, 745, 2376, 740, - /* 2990 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, - /* 3000 */ 2324, 1917, 746, 1917, 1917, 2358, 1917, 1917, 1917, 2376, - /* 3010 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 747, 1917, - /* 3020 */ 1917, 2324, 1917, 746, 1917, 1917, 1917, 1917, 1917, 1917, - /* 3030 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, - /* 3040 */ 1917, 2357, 1917, 1917, 2395, 1917, 2376, 2369, 2359, 750, - /* 3050 */ 2361, 2362, 745, 1917, 740, 1917, 1917, 1917, 2324, 1917, - /* 3060 */ 746, 1917, 2357, 1917, 1917, 2395, 1917, 1917, 2368, 2359, - /* 3070 */ 750, 2361, 2362, 745, 1917, 740, 1917, 1917, 1917, 1917, - /* 3080 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, - /* 3090 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 2358, 2357, - /* 3100 */ 1917, 1917, 2395, 1917, 1917, 381, 2359, 750, 2361, 2362, - /* 3110 */ 745, 747, 740, 1917, 1917, 1917, 1917, 1917, 1917, 1917, - /* 3120 */ 1917, 1917, 1917, 1917, 1917, 2358, 1917, 1917, 1917, 1917, - /* 3130 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 747, 2376, - /* 3140 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, - /* 3150 */ 1917, 2324, 1917, 746, 1917, 1917, 1917, 1917, 1917, 1917, - /* 3160 */ 1917, 1917, 1917, 1917, 1917, 1917, 2376, 1917, 2358, 1917, - /* 3170 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 2324, 1917, - /* 3180 */ 746, 747, 1917, 2358, 1917, 1917, 1917, 1917, 1917, 1917, - /* 3190 */ 1917, 1917, 2357, 1917, 1917, 2395, 747, 1917, 382, 2359, - /* 3200 */ 750, 2361, 2362, 745, 1917, 740, 1917, 1917, 1917, 2376, - /* 3210 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 2357, - /* 3220 */ 1917, 2324, 2395, 746, 2376, 378, 2359, 750, 2361, 2362, - /* 3230 */ 745, 1917, 740, 1917, 1917, 1917, 2324, 1917, 746, 1917, - /* 3240 */ 2358, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, - /* 3250 */ 1917, 1917, 1917, 747, 1917, 1917, 1917, 1917, 1917, 1917, - /* 3260 */ 1917, 1917, 2357, 1917, 1917, 2395, 1917, 1917, 383, 2359, - /* 3270 */ 750, 2361, 2362, 745, 1917, 740, 1917, 748, 1917, 1917, - /* 3280 */ 2395, 2376, 1917, 357, 2359, 750, 2361, 2362, 745, 1917, - /* 3290 */ 740, 1917, 1917, 2324, 1917, 746, 1917, 1917, 1917, 1917, - /* 3300 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, - /* 3310 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, - /* 3320 */ 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, - /* 3330 */ 1917, 1917, 1917, 1917, 2357, 1917, 1917, 2395, 1917, 1917, - /* 3340 */ 356, 2359, 750, 2361, 2362, 745, 1917, 740, + /* 400 */ 499, 372, 491, 490, 489, 2322, 484, 483, 387, 172, + /* 410 */ 730, 2104, 1550, 1551, 346, 1690, 1722, 1732, 1569, 1810, + /* 420 */ 1811, 1812, 1813, 1748, 1751, 653, 2276, 1879, 394, 393, + /* 430 */ 137, 343, 74, 799, 1720, 73, 2065, 609, 1663, 578, + /* 440 */ 1661, 688, 683, 676, 12, 370, 10, 41, 40, 1562, + /* 450 */ 1563, 47, 45, 44, 43, 42, 239, 543, 541, 538, + /* 460 */ 2466, 1810, 1811, 1812, 1813, 2466, 2466, 2466, 2466, 2466, + /* 470 */ 1666, 1667, 1719, 106, 1721, 1724, 1725, 1726, 1727, 1728, + /* 480 */ 1729, 1730, 1731, 742, 738, 1740, 1741, 1743, 1744, 1745, + /* 490 */ 1746, 2, 12, 48, 46, 579, 2230, 63, 2097, 392, + /* 500 */ 391, 420, 606, 1662, 52, 649, 2080, 730, 2104, 380, + /* 510 */ 730, 2104, 2545, 623, 622, 621, 1747, 2316, 1660, 2540, + /* 520 */ 613, 143, 617, 844, 608, 1719, 616, 471, 607, 2237, + /* 530 */ 472, 615, 620, 396, 395, 64, 2356, 614, 2544, 332, + /* 540 */ 610, 628, 2541, 2543, 413, 1742, 414, 2234, 717, 747, + /* 550 */ 1325, 19, 1324, 1776, 171, 198, 640, 2285, 1668, 1325, + /* 560 */ 99, 1324, 2106, 832, 828, 824, 820, 667, 329, 44, + /* 570 */ 43, 42, 274, 307, 2540, 785, 142, 2374, 38, 325, + /* 580 */ 729, 84, 83, 470, 841, 1326, 220, 15, 631, 2322, + /* 590 */ 1610, 746, 2546, 208, 1326, 625, 2306, 2541, 698, 462, + /* 600 */ 460, 271, 467, 1810, 1811, 1812, 1813, 466, 1914, 113, + /* 610 */ 371, 278, 323, 451, 1777, 34, 448, 444, 440, 437, + /* 620 */ 463, 41, 40, 1749, 1750, 47, 45, 44, 43, 42, + /* 630 */ 2355, 429, 428, 2393, 785, 455, 114, 2357, 750, 2359, + /* 640 */ 2360, 745, 72, 740, 726, 71, 149, 442, 156, 2417, + /* 650 */ 2446, 2081, 667, 2157, 416, 2442, 1669, 1722, 1732, 2540, + /* 660 */ 2157, 686, 457, 453, 1748, 1751, 51, 386, 725, 309, + /* 670 */ 1815, 1816, 1817, 1818, 1819, 2155, 309, 2546, 208, 1663, + /* 680 */ 68, 1661, 2541, 698, 312, 316, 317, 435, 76, 2374, + /* 690 */ 315, 311, 434, 2079, 37, 418, 1771, 1772, 1773, 1774, + /* 700 */ 1775, 1779, 1780, 1781, 1782, 480, 2213, 227, 486, 2213, + /* 710 */ 281, 1666, 1667, 1719, 63, 1721, 1724, 1725, 1726, 1727, + /* 720 */ 1728, 1729, 1730, 1731, 742, 738, 1740, 1741, 1743, 1744, + /* 730 */ 1745, 1746, 2, 48, 46, 1752, 1687, 667, 87, 730, + /* 740 */ 2104, 420, 2356, 1662, 2540, 697, 2157, 2545, 90, 1867, + /* 750 */ 685, 89, 2540, 401, 223, 712, 1747, 225, 1660, 488, + /* 760 */ 577, 2155, 2546, 208, 1690, 2356, 648, 2541, 698, 1416, + /* 770 */ 696, 208, 666, 730, 2104, 2541, 698, 189, 747, 732, + /* 780 */ 1969, 2418, 63, 2374, 1415, 1742, 783, 161, 160, 780, + /* 790 */ 779, 778, 158, 503, 1687, 2322, 171, 746, 1668, 2151, + /* 800 */ 2152, 2218, 709, 146, 2107, 465, 2374, 464, 679, 678, + /* 810 */ 1865, 1866, 1868, 1869, 1870, 88, 709, 146, 2322, 1672, + /* 820 */ 746, 1935, 63, 701, 841, 1662, 95, 49, 783, 161, + /* 830 */ 160, 780, 779, 778, 158, 2356, 2355, 463, 309, 2393, + /* 840 */ 1660, 201, 114, 2357, 750, 2359, 2360, 745, 744, 740, + /* 850 */ 533, 1902, 2100, 2144, 191, 12, 2446, 1328, 1329, 2355, + /* 860 */ 416, 2442, 2393, 1749, 1750, 114, 2357, 750, 2359, 2360, + /* 870 */ 745, 734, 740, 2418, 2322, 777, 2374, 2560, 2148, 2446, + /* 880 */ 1668, 558, 148, 416, 2442, 2417, 309, 2492, 2322, 556, + /* 890 */ 746, 423, 552, 548, 2545, 730, 2104, 1722, 1732, 171, + /* 900 */ 61, 2540, 426, 1668, 1748, 1751, 841, 2106, 664, 2332, + /* 910 */ 171, 711, 176, 2454, 2455, 504, 144, 2459, 2106, 1663, + /* 920 */ 2544, 1661, 307, 2341, 2541, 2542, 177, 2454, 2455, 2355, + /* 930 */ 144, 2459, 2393, 2336, 1691, 361, 2357, 750, 2359, 2360, + /* 940 */ 745, 743, 740, 731, 2411, 47, 45, 44, 43, 42, + /* 950 */ 1723, 1666, 1667, 1719, 309, 1721, 1724, 1725, 1726, 1727, + /* 960 */ 1728, 1729, 1730, 1731, 742, 738, 1740, 1741, 1743, 1744, + /* 970 */ 1745, 1746, 2, 48, 46, 2356, 2544, 2338, 1691, 730, + /* 980 */ 2104, 420, 2157, 1662, 730, 2104, 1934, 740, 747, 410, + /* 990 */ 2499, 514, 2213, 2461, 309, 796, 1747, 2155, 1660, 505, + /* 1000 */ 1833, 1663, 2188, 1661, 580, 2356, 1720, 41, 40, 730, + /* 1010 */ 2104, 47, 45, 44, 43, 42, 2374, 2157, 747, 2457, + /* 1020 */ 2512, 1933, 730, 2104, 415, 1742, 14, 13, 2322, 2101, + /* 1030 */ 746, 1932, 2155, 1666, 1667, 730, 2104, 1306, 1668, 2322, + /* 1040 */ 230, 608, 279, 41, 40, 607, 2374, 47, 45, 44, + /* 1050 */ 43, 42, 776, 730, 2104, 287, 2157, 1691, 2322, 798, + /* 1060 */ 746, 1304, 1305, 424, 841, 730, 2104, 49, 1778, 2355, + /* 1070 */ 2303, 2155, 2393, 715, 2322, 114, 2357, 750, 2359, 2360, + /* 1080 */ 745, 2089, 740, 1420, 2322, 320, 1931, 2560, 1930, 2446, + /* 1090 */ 646, 702, 199, 416, 2442, 1757, 730, 2104, 1419, 2355, + /* 1100 */ 652, 1687, 2393, 1749, 1750, 114, 2357, 750, 2359, 2360, + /* 1110 */ 745, 704, 740, 730, 2104, 36, 727, 2560, 1687, 2446, + /* 1120 */ 1927, 41, 40, 416, 2442, 47, 45, 44, 43, 42, + /* 1130 */ 600, 599, 1790, 728, 730, 2104, 203, 1722, 1732, 2322, + /* 1140 */ 667, 2322, 1852, 2461, 1748, 1751, 1692, 2540, 35, 276, + /* 1150 */ 667, 602, 601, 275, 326, 619, 618, 2540, 1783, 1663, + /* 1160 */ 643, 1661, 642, 498, 535, 2546, 208, 713, 330, 2456, + /* 1170 */ 2541, 698, 497, 2322, 2157, 2546, 208, 170, 1926, 1925, + /* 1180 */ 2541, 698, 783, 161, 160, 780, 779, 778, 158, 2156, + /* 1190 */ 1692, 1666, 1667, 1719, 2091, 1721, 1724, 1725, 1726, 1727, + /* 1200 */ 1728, 1729, 1730, 1731, 742, 738, 1740, 1741, 1743, 1744, + /* 1210 */ 1745, 1746, 2, 48, 46, 2356, 691, 667, 1924, 98, + /* 1220 */ 1923, 420, 375, 1662, 2540, 400, 1922, 641, 747, 1921, + /* 1230 */ 674, 2322, 2322, 1920, 730, 2104, 1747, 781, 1660, 1919, + /* 1240 */ 2148, 782, 2546, 208, 2148, 41, 40, 2541, 698, 47, + /* 1250 */ 45, 44, 43, 42, 427, 2198, 2374, 1723, 810, 808, + /* 1260 */ 737, 339, 1944, 836, 2134, 1742, 159, 2082, 2322, 1692, + /* 1270 */ 746, 2322, 700, 2322, 202, 3, 1832, 139, 1668, 2322, + /* 1280 */ 1822, 611, 2322, 429, 428, 264, 2322, 54, 262, 86, + /* 1290 */ 159, 2087, 2322, 1676, 214, 266, 268, 478, 265, 267, + /* 1300 */ 152, 2343, 612, 288, 841, 1401, 1747, 15, 1669, 2355, + /* 1310 */ 2356, 270, 2393, 1720, 269, 114, 2357, 750, 2359, 2360, + /* 1320 */ 745, 159, 740, 747, 1987, 2533, 1399, 2560, 1978, 2446, + /* 1330 */ 1720, 1976, 50, 416, 2442, 1742, 1911, 1912, 14, 13, + /* 1340 */ 55, 1670, 50, 1749, 1750, 192, 624, 100, 1668, 159, + /* 1350 */ 626, 2374, 50, 629, 1359, 790, 314, 111, 2345, 2108, + /* 1360 */ 75, 2505, 284, 2322, 1626, 746, 108, 741, 2044, 791, + /* 1370 */ 1929, 181, 303, 680, 736, 1970, 710, 1722, 1732, 1378, + /* 1380 */ 157, 705, 159, 66, 1748, 1751, 50, 50, 295, 141, + /* 1390 */ 754, 2375, 2041, 1376, 1360, 1629, 2040, 1960, 157, 1663, + /* 1400 */ 2222, 1661, 2495, 677, 2355, 406, 1864, 2393, 684, 719, + /* 1410 */ 114, 2357, 750, 2359, 2360, 745, 1863, 740, 159, 293, + /* 1420 */ 1768, 403, 2560, 714, 2446, 433, 1579, 834, 416, 2442, + /* 1430 */ 318, 1666, 1667, 1719, 722, 1721, 1724, 1725, 1726, 1727, + /* 1440 */ 1728, 1729, 1730, 1731, 742, 738, 1740, 1741, 1743, 1744, + /* 1450 */ 1745, 1746, 2, 2356, 322, 2223, 1446, 1784, 140, 1966, + /* 1460 */ 1733, 338, 157, 2145, 1474, 660, 747, 2496, 302, 1677, + /* 1470 */ 2506, 1672, 1478, 692, 693, 305, 300, 5, 308, 2066, + /* 1480 */ 436, 441, 2356, 384, 449, 450, 1695, 459, 458, 215, + /* 1490 */ 216, 218, 1485, 1603, 2374, 747, 461, 333, 1685, 475, + /* 1500 */ 1686, 1680, 1682, 479, 1673, 229, 2322, 481, 746, 485, + /* 1510 */ 492, 487, 506, 524, 513, 738, 1740, 1741, 1743, 1744, + /* 1520 */ 1745, 1746, 2215, 2374, 515, 523, 525, 536, 537, 534, + /* 1530 */ 233, 234, 1483, 539, 540, 2322, 162, 746, 236, 542, + /* 1540 */ 544, 1693, 559, 4, 560, 567, 570, 2355, 568, 1688, + /* 1550 */ 2393, 2356, 244, 114, 2357, 750, 2359, 2360, 745, 92, + /* 1560 */ 740, 1694, 572, 247, 747, 2560, 1696, 2446, 250, 573, + /* 1570 */ 576, 416, 2442, 574, 252, 1697, 2355, 2231, 93, 2393, + /* 1580 */ 2356, 582, 114, 2357, 750, 2359, 2360, 745, 94, 740, + /* 1590 */ 603, 257, 2374, 747, 2421, 116, 2446, 632, 365, 605, + /* 1600 */ 416, 2442, 633, 2094, 2322, 261, 746, 2090, 645, 263, + /* 1610 */ 647, 97, 164, 165, 2092, 2088, 166, 167, 2294, 153, + /* 1620 */ 334, 2374, 280, 1689, 655, 654, 285, 283, 2277, 662, + /* 1630 */ 2291, 2290, 671, 2322, 656, 746, 659, 8, 2511, 681, + /* 1640 */ 661, 690, 720, 2510, 672, 2355, 695, 294, 2393, 2483, + /* 1650 */ 183, 114, 2357, 750, 2359, 2360, 745, 290, 740, 292, + /* 1660 */ 296, 670, 297, 2419, 669, 2446, 2356, 299, 298, 416, + /* 1670 */ 2442, 694, 407, 2563, 2355, 706, 301, 2393, 703, 747, + /* 1680 */ 114, 2357, 750, 2359, 2360, 745, 145, 740, 2539, 1690, + /* 1690 */ 304, 2462, 733, 2356, 2446, 1830, 1828, 195, 416, 2442, + /* 1700 */ 723, 335, 718, 310, 2245, 2244, 747, 2374, 336, 154, + /* 1710 */ 724, 2243, 412, 2465, 2105, 337, 155, 105, 62, 2322, + /* 1720 */ 1, 746, 2427, 210, 2356, 107, 1283, 835, 340, 2149, + /* 1730 */ 838, 840, 752, 53, 2374, 163, 328, 747, 349, 364, + /* 1740 */ 376, 377, 344, 2314, 2313, 363, 2322, 81, 746, 2312, + /* 1750 */ 342, 2307, 438, 353, 439, 1653, 1654, 213, 443, 2305, + /* 1760 */ 2355, 445, 447, 2393, 446, 2374, 115, 2357, 750, 2359, + /* 1770 */ 2360, 745, 1652, 740, 2304, 385, 2302, 2322, 452, 746, + /* 1780 */ 2446, 2301, 454, 2300, 2445, 2442, 1642, 2355, 2281, 456, + /* 1790 */ 2393, 2356, 217, 115, 2357, 750, 2359, 2360, 745, 2280, + /* 1800 */ 740, 219, 1606, 82, 747, 1605, 2356, 2446, 2258, 2257, + /* 1810 */ 2256, 735, 2442, 2255, 468, 469, 2254, 2205, 748, 747, + /* 1820 */ 473, 2393, 1549, 2197, 115, 2357, 750, 2359, 2360, 745, + /* 1830 */ 476, 740, 2374, 477, 2194, 222, 2193, 85, 2446, 2192, + /* 1840 */ 2191, 2196, 379, 2442, 2322, 224, 746, 2374, 2195, 2190, + /* 1850 */ 2189, 2187, 2186, 2185, 226, 493, 2184, 495, 2200, 2322, + /* 1860 */ 2183, 746, 2182, 2181, 2180, 2179, 2202, 2178, 2177, 2176, + /* 1870 */ 2175, 2174, 2173, 2172, 2356, 228, 2168, 91, 2167, 2166, + /* 1880 */ 2165, 2201, 2199, 2164, 2163, 2355, 2171, 747, 2393, 2170, + /* 1890 */ 2169, 175, 2357, 750, 2359, 2360, 745, 2162, 740, 1555, + /* 1900 */ 2355, 232, 2161, 2393, 527, 2160, 178, 2357, 750, 2359, + /* 1910 */ 2360, 745, 529, 740, 2159, 2374, 2158, 2356, 1417, 2006, + /* 1920 */ 1421, 235, 2005, 237, 373, 1413, 2004, 2322, 2002, 746, + /* 1930 */ 747, 1999, 545, 1998, 547, 374, 549, 668, 2502, 2356, + /* 1940 */ 553, 1980, 546, 551, 550, 1991, 557, 1955, 190, 555, + /* 1950 */ 1307, 238, 747, 240, 78, 1954, 2279, 554, 2374, 2342, + /* 1960 */ 200, 242, 565, 79, 699, 2561, 2275, 2265, 2355, 2253, + /* 1970 */ 2322, 2393, 746, 251, 115, 2357, 750, 2359, 2360, 745, + /* 1980 */ 2374, 740, 2252, 254, 249, 404, 2229, 2083, 2446, 2001, + /* 1990 */ 1997, 1352, 2322, 2443, 746, 583, 585, 584, 1995, 587, + /* 2000 */ 588, 589, 1993, 592, 1990, 591, 593, 595, 596, 1975, + /* 2010 */ 2356, 2355, 1973, 1974, 2393, 597, 1972, 175, 2357, 750, + /* 2020 */ 2359, 2360, 745, 747, 740, 2356, 1951, 2085, 1490, 1489, + /* 2030 */ 2084, 65, 1403, 2355, 1402, 260, 2393, 1400, 747, 362, + /* 2040 */ 2357, 750, 2359, 2360, 745, 1398, 740, 1397, 1396, 1988, + /* 2050 */ 1389, 2374, 1395, 807, 1394, 809, 405, 397, 1391, 1979, + /* 2060 */ 1390, 1388, 398, 2322, 2503, 746, 2374, 627, 1977, 399, + /* 2070 */ 630, 1950, 1949, 1948, 634, 1947, 1946, 638, 2322, 636, + /* 2080 */ 746, 117, 1636, 2356, 1640, 1638, 29, 1635, 2278, 69, + /* 2090 */ 282, 2274, 1614, 1612, 2264, 2251, 747, 2250, 20, 1616, + /* 2100 */ 657, 169, 57, 58, 2355, 2356, 2545, 2393, 658, 31, + /* 2110 */ 362, 2357, 750, 2359, 2360, 745, 286, 740, 747, 2355, + /* 2120 */ 17, 1591, 2393, 663, 2374, 355, 2357, 750, 2359, 2360, + /* 2130 */ 745, 1590, 740, 665, 6, 289, 2322, 7, 746, 1881, + /* 2140 */ 673, 291, 21, 22, 179, 675, 2374, 205, 194, 2343, + /* 2150 */ 193, 411, 33, 1862, 1823, 206, 67, 32, 2322, 1851, + /* 2160 */ 746, 1821, 1825, 2356, 80, 24, 207, 1896, 1895, 1901, + /* 2170 */ 1902, 408, 1900, 1899, 1807, 689, 744, 2355, 409, 60, + /* 2180 */ 2393, 1806, 306, 178, 2357, 750, 2359, 2360, 745, 185, + /* 2190 */ 740, 2249, 2228, 59, 2227, 101, 102, 313, 25, 2355, + /* 2200 */ 1857, 721, 2393, 103, 2374, 362, 2357, 750, 2359, 2360, + /* 2210 */ 745, 196, 740, 319, 70, 23, 2322, 104, 746, 108, + /* 2220 */ 18, 324, 26, 13, 1759, 11, 1678, 1758, 1737, 1769, + /* 2230 */ 2396, 186, 739, 2356, 1735, 39, 197, 1712, 749, 753, + /* 2240 */ 422, 327, 2562, 757, 321, 1734, 747, 760, 16, 27, + /* 2250 */ 763, 1704, 1475, 28, 755, 751, 1472, 2355, 1471, 766, + /* 2260 */ 2393, 758, 2356, 361, 2357, 750, 2359, 2360, 745, 761, + /* 2270 */ 740, 1468, 2412, 764, 2374, 747, 1462, 767, 769, 419, + /* 2280 */ 1460, 770, 109, 1466, 1465, 1464, 2322, 1463, 746, 110, + /* 2290 */ 1484, 77, 1480, 1385, 1350, 784, 1382, 1381, 2356, 1380, + /* 2300 */ 1379, 1377, 1375, 2374, 1374, 1373, 1411, 795, 421, 1410, + /* 2310 */ 211, 747, 797, 1371, 1368, 2322, 1370, 746, 1369, 1367, + /* 2320 */ 1366, 1365, 1407, 1405, 1362, 1361, 1358, 2355, 1357, 2356, + /* 2330 */ 2393, 1356, 1355, 362, 2357, 750, 2359, 2360, 745, 2374, + /* 2340 */ 740, 1996, 747, 817, 818, 819, 1994, 821, 822, 823, + /* 2350 */ 1992, 2322, 825, 746, 827, 1989, 2355, 829, 831, 2393, + /* 2360 */ 1971, 833, 362, 2357, 750, 2359, 2360, 745, 826, 740, + /* 2370 */ 2374, 1296, 830, 1945, 1284, 837, 331, 839, 1915, 1664, + /* 2380 */ 341, 843, 2322, 842, 746, 1915, 1915, 1915, 1915, 1915, + /* 2390 */ 1915, 1915, 644, 1915, 1915, 2393, 1915, 2356, 357, 2357, + /* 2400 */ 750, 2359, 2360, 745, 1915, 740, 1915, 1915, 1915, 1915, + /* 2410 */ 747, 1915, 1915, 1915, 1915, 2356, 1915, 1915, 1915, 1915, + /* 2420 */ 1915, 1915, 1915, 2355, 1915, 1915, 2393, 1915, 747, 347, + /* 2430 */ 2357, 750, 2359, 2360, 745, 1915, 740, 1915, 2374, 1915, + /* 2440 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, + /* 2450 */ 2322, 1915, 746, 1915, 1915, 1915, 2374, 1915, 1915, 1915, + /* 2460 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 2322, 1915, + /* 2470 */ 746, 1915, 2356, 1915, 1915, 1915, 1915, 1915, 1915, 1915, + /* 2480 */ 1915, 1915, 1915, 1915, 1915, 747, 1915, 1915, 1915, 1915, + /* 2490 */ 1915, 2355, 1915, 1915, 2393, 2356, 1915, 345, 2357, 750, + /* 2500 */ 2359, 2360, 745, 1915, 740, 1915, 1915, 1915, 747, 2355, + /* 2510 */ 2356, 1915, 2393, 2374, 1915, 348, 2357, 750, 2359, 2360, + /* 2520 */ 745, 1915, 740, 747, 1915, 2322, 1915, 746, 1915, 1915, + /* 2530 */ 1915, 1915, 1915, 1915, 1915, 1915, 2374, 1915, 1915, 1915, + /* 2540 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 2322, 1915, + /* 2550 */ 746, 2374, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, + /* 2560 */ 1915, 1915, 1915, 2322, 1915, 746, 2355, 2356, 1915, 2393, + /* 2570 */ 1915, 1915, 354, 2357, 750, 2359, 2360, 745, 1915, 740, + /* 2580 */ 747, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 2355, + /* 2590 */ 1915, 1915, 2393, 1915, 1915, 358, 2357, 750, 2359, 2360, + /* 2600 */ 745, 1915, 740, 1915, 2355, 2356, 1915, 2393, 2374, 1915, + /* 2610 */ 350, 2357, 750, 2359, 2360, 745, 1915, 740, 747, 1915, + /* 2620 */ 2322, 1915, 746, 1915, 2356, 1915, 1915, 1915, 1915, 1915, + /* 2630 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 747, 1915, 1915, + /* 2640 */ 1915, 1915, 1915, 1915, 1915, 1915, 2374, 1915, 1915, 1915, + /* 2650 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 2322, 1915, + /* 2660 */ 746, 2355, 2356, 1915, 2393, 2374, 1915, 359, 2357, 750, + /* 2670 */ 2359, 2360, 745, 1915, 740, 747, 1915, 2322, 1915, 746, + /* 2680 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, + /* 2690 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 2356, 2355, + /* 2700 */ 1915, 1915, 2393, 2374, 1915, 351, 2357, 750, 2359, 2360, + /* 2710 */ 745, 747, 740, 1915, 1915, 2322, 1915, 746, 2355, 1915, + /* 2720 */ 1915, 2393, 1915, 1915, 360, 2357, 750, 2359, 2360, 745, + /* 2730 */ 1915, 740, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 2374, + /* 2740 */ 1915, 2356, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, + /* 2750 */ 1915, 2322, 1915, 746, 747, 1915, 2355, 1915, 1915, 2393, + /* 2760 */ 1915, 1915, 352, 2357, 750, 2359, 2360, 745, 1915, 740, + /* 2770 */ 1915, 1915, 1915, 1915, 2356, 1915, 1915, 1915, 1915, 1915, + /* 2780 */ 1915, 1915, 2374, 1915, 1915, 1915, 1915, 747, 1915, 1915, + /* 2790 */ 1915, 1915, 2355, 1915, 2322, 2393, 746, 1915, 366, 2357, + /* 2800 */ 750, 2359, 2360, 745, 1915, 740, 1915, 1915, 1915, 2356, + /* 2810 */ 1915, 1915, 1915, 1915, 1915, 2374, 1915, 1915, 1915, 1915, + /* 2820 */ 1915, 1915, 747, 1915, 1915, 1915, 1915, 2322, 1915, 746, + /* 2830 */ 1915, 1915, 1915, 1915, 1915, 2355, 1915, 1915, 2393, 1915, + /* 2840 */ 1915, 367, 2357, 750, 2359, 2360, 745, 1915, 740, 1915, + /* 2850 */ 2374, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, + /* 2860 */ 1915, 1915, 2322, 1915, 746, 1915, 1915, 2356, 2355, 1915, + /* 2870 */ 1915, 2393, 1915, 1915, 2368, 2357, 750, 2359, 2360, 745, + /* 2880 */ 747, 740, 2356, 1915, 1915, 1915, 1915, 1915, 1915, 1915, + /* 2890 */ 1915, 1915, 1915, 1915, 1915, 747, 1915, 1915, 1915, 1915, + /* 2900 */ 1915, 1915, 1915, 2355, 1915, 1915, 2393, 1915, 2374, 2367, + /* 2910 */ 2357, 750, 2359, 2360, 745, 1915, 740, 1915, 1915, 1915, + /* 2920 */ 2322, 1915, 746, 2374, 1915, 2356, 1915, 1915, 1915, 1915, + /* 2930 */ 1915, 1915, 1915, 1915, 1915, 2322, 1915, 746, 747, 1915, + /* 2940 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, + /* 2950 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, + /* 2960 */ 1915, 2355, 1915, 1915, 2393, 1915, 2374, 2366, 2357, 750, + /* 2970 */ 2359, 2360, 745, 1915, 740, 1915, 2355, 1915, 2322, 2393, + /* 2980 */ 746, 1915, 381, 2357, 750, 2359, 2360, 745, 1915, 740, + /* 2990 */ 1915, 1915, 1915, 1915, 1915, 1915, 2356, 1915, 1915, 1915, + /* 3000 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 747, + /* 3010 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 2355, + /* 3020 */ 2356, 1915, 2393, 1915, 1915, 382, 2357, 750, 2359, 2360, + /* 3030 */ 745, 1915, 740, 747, 1915, 1915, 1915, 2374, 1915, 1915, + /* 3040 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 2322, + /* 3050 */ 1915, 746, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, + /* 3060 */ 1915, 2374, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, + /* 3070 */ 1915, 1915, 1915, 2322, 1915, 746, 1915, 1915, 1915, 1915, + /* 3080 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, + /* 3090 */ 2355, 1915, 1915, 2393, 1915, 1915, 378, 2357, 750, 2359, + /* 3100 */ 2360, 745, 1915, 740, 1915, 1915, 1915, 1915, 1915, 1915, + /* 3110 */ 1915, 1915, 1915, 2356, 2355, 1915, 1915, 2393, 1915, 1915, + /* 3120 */ 383, 2357, 750, 2359, 2360, 745, 747, 740, 2356, 1915, + /* 3130 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, + /* 3140 */ 1915, 747, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, + /* 3150 */ 1915, 1915, 1915, 1915, 2374, 1915, 1915, 1915, 1915, 1915, + /* 3160 */ 1915, 1915, 1915, 1915, 1915, 1915, 2322, 1915, 746, 2374, + /* 3170 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, + /* 3180 */ 1915, 2322, 1915, 746, 1915, 1915, 1915, 1915, 1915, 1915, + /* 3190 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, + /* 3200 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 748, 1915, 1915, + /* 3210 */ 2393, 1915, 1915, 357, 2357, 750, 2359, 2360, 745, 1915, + /* 3220 */ 740, 1915, 2355, 1915, 1915, 2393, 1915, 1915, 356, 2357, + /* 3230 */ 750, 2359, 2360, 745, 1915, 740, }; static const YYCODETYPE yy_lookahead[] = { - /* 0 */ 366, 401, 392, 369, 370, 367, 371, 372, 485, 371, - /* 10 */ 400, 373, 12, 13, 14, 492, 359, 407, 408, 400, - /* 20 */ 20, 0, 22, 8, 9, 415, 391, 12, 13, 14, - /* 30 */ 15, 16, 381, 510, 511, 35, 0, 37, 515, 516, - /* 40 */ 389, 422, 21, 424, 359, 24, 25, 26, 27, 28, - /* 50 */ 29, 30, 31, 32, 8, 9, 37, 372, 12, 13, - /* 60 */ 14, 15, 16, 0, 64, 20, 20, 8, 9, 412, - /* 70 */ 70, 12, 13, 14, 15, 16, 410, 77, 20, 413, - /* 80 */ 414, 371, 372, 21, 20, 400, 414, 24, 25, 26, - /* 90 */ 27, 28, 29, 30, 31, 32, 77, 412, 36, 414, - /* 100 */ 38, 39, 40, 103, 432, 433, 106, 14, 72, 73, + /* 0 */ 365, 400, 391, 368, 369, 366, 370, 371, 484, 370, + /* 10 */ 399, 372, 12, 13, 14, 491, 358, 406, 407, 399, + /* 20 */ 20, 0, 22, 8, 9, 414, 390, 12, 13, 14, + /* 30 */ 15, 16, 380, 509, 510, 35, 0, 37, 514, 515, + /* 40 */ 388, 421, 21, 423, 358, 24, 25, 26, 27, 28, + /* 50 */ 29, 30, 31, 32, 8, 9, 37, 371, 12, 13, + /* 60 */ 14, 15, 16, 0, 64, 20, 20, 8, 9, 411, + /* 70 */ 70, 12, 13, 14, 15, 16, 409, 77, 20, 412, + /* 80 */ 413, 370, 371, 21, 20, 399, 413, 24, 25, 26, + /* 90 */ 27, 28, 29, 30, 31, 32, 77, 411, 36, 413, + /* 100 */ 38, 39, 40, 103, 431, 432, 106, 69, 72, 73, /* 110 */ 74, 75, 76, 20, 78, 79, 80, 81, 82, 83, /* 120 */ 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - /* 130 */ 94, 95, 96, 97, 98, 99, 4, 20, 453, 371, - /* 140 */ 372, 456, 142, 143, 459, 460, 461, 462, 463, 464, - /* 150 */ 400, 466, 42, 371, 372, 23, 471, 366, 473, 391, - /* 160 */ 369, 370, 477, 478, 21, 415, 107, 24, 25, 26, + /* 130 */ 94, 95, 96, 97, 98, 99, 4, 106, 452, 370, + /* 140 */ 371, 455, 142, 143, 458, 459, 460, 461, 462, 463, + /* 150 */ 357, 465, 359, 370, 371, 23, 470, 365, 472, 390, + /* 160 */ 368, 369, 476, 477, 21, 377, 107, 24, 25, 26, /* 170 */ 27, 28, 29, 30, 31, 32, 176, 177, 46, 47, - /* 180 */ 48, 496, 3, 183, 184, 35, 0, 142, 143, 504, - /* 190 */ 20, 481, 482, 483, 23, 485, 486, 378, 198, 20, - /* 200 */ 200, 51, 492, 388, 435, 190, 142, 143, 22, 59, - /* 210 */ 60, 61, 62, 387, 64, 0, 390, 402, 47, 48, - /* 220 */ 510, 511, 403, 136, 178, 515, 516, 412, 183, 184, - /* 230 */ 230, 231, 232, 20, 234, 235, 236, 237, 238, 239, + /* 180 */ 48, 495, 394, 183, 184, 35, 37, 142, 143, 503, + /* 190 */ 402, 480, 481, 482, 42, 484, 485, 20, 198, 106, + /* 200 */ 200, 51, 491, 387, 434, 190, 142, 143, 370, 59, + /* 210 */ 60, 61, 62, 14, 64, 0, 14, 401, 22, 20, + /* 220 */ 509, 510, 20, 136, 178, 514, 515, 411, 183, 184, + /* 230 */ 230, 231, 232, 37, 234, 235, 236, 237, 238, 239, /* 240 */ 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - /* 250 */ 250, 251, 12, 13, 485, 105, 371, 18, 108, 20, - /* 260 */ 20, 492, 22, 481, 482, 483, 27, 485, 486, 30, - /* 270 */ 399, 456, 457, 0, 35, 35, 106, 37, 232, 510, - /* 280 */ 511, 466, 411, 20, 515, 516, 107, 72, 73, 74, - /* 290 */ 51, 106, 53, 458, 79, 80, 81, 58, 211, 212, - /* 300 */ 85, 20, 371, 22, 64, 90, 91, 92, 93, 485, - /* 310 */ 70, 96, 427, 428, 99, 20, 492, 77, 37, 484, - /* 320 */ 305, 51, 172, 271, 272, 273, 274, 275, 276, 59, - /* 330 */ 180, 181, 62, 63, 400, 511, 55, 187, 188, 515, - /* 340 */ 516, 407, 69, 103, 105, 103, 106, 416, 417, 415, - /* 350 */ 419, 371, 372, 372, 423, 116, 206, 178, 458, 117, - /* 360 */ 118, 119, 120, 121, 122, 123, 124, 125, 126, 106, - /* 370 */ 128, 129, 130, 131, 132, 133, 134, 267, 268, 269, - /* 380 */ 270, 400, 142, 143, 484, 146, 147, 20, 149, 150, + /* 250 */ 250, 251, 12, 13, 484, 105, 86, 18, 108, 20, + /* 260 */ 20, 491, 22, 480, 481, 482, 27, 484, 485, 30, + /* 270 */ 358, 455, 456, 77, 35, 35, 399, 37, 232, 509, + /* 280 */ 510, 465, 444, 445, 514, 515, 379, 72, 73, 74, + /* 290 */ 51, 414, 53, 20, 79, 80, 81, 58, 211, 212, + /* 300 */ 85, 387, 370, 396, 64, 90, 91, 92, 93, 278, + /* 310 */ 70, 96, 405, 20, 99, 401, 457, 77, 148, 304, + /* 320 */ 366, 20, 172, 411, 370, 411, 372, 358, 8, 9, + /* 330 */ 180, 181, 12, 13, 14, 15, 16, 187, 188, 182, + /* 340 */ 170, 171, 483, 103, 105, 103, 106, 415, 416, 200, + /* 350 */ 418, 370, 358, 33, 422, 116, 206, 370, 371, 117, + /* 360 */ 118, 119, 120, 121, 122, 123, 124, 125, 126, 455, + /* 370 */ 128, 129, 130, 131, 132, 133, 134, 390, 176, 465, + /* 380 */ 411, 14, 142, 143, 397, 146, 147, 20, 149, 150, /* 390 */ 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - /* 400 */ 161, 162, 163, 164, 165, 20, 167, 168, 169, 18, - /* 410 */ 371, 372, 173, 174, 23, 2, 176, 177, 179, 371, - /* 420 */ 372, 8, 9, 183, 184, 12, 13, 14, 15, 16, - /* 430 */ 391, 40, 41, 400, 20, 44, 22, 398, 198, 391, - /* 440 */ 200, 408, 461, 182, 400, 54, 398, 8, 9, 435, - /* 450 */ 20, 12, 13, 14, 15, 16, 65, 66, 67, 68, - /* 460 */ 480, 481, 482, 483, 279, 485, 486, 64, 424, 55, - /* 470 */ 230, 231, 232, 178, 234, 235, 236, 237, 238, 239, + /* 400 */ 161, 162, 163, 164, 165, 411, 167, 168, 169, 18, + /* 410 */ 370, 371, 173, 174, 23, 20, 176, 177, 179, 267, + /* 420 */ 268, 269, 270, 183, 184, 444, 445, 107, 39, 40, + /* 430 */ 390, 40, 41, 386, 232, 44, 389, 397, 198, 370, + /* 440 */ 200, 284, 285, 286, 252, 54, 254, 8, 9, 176, + /* 450 */ 177, 12, 13, 14, 15, 16, 65, 66, 67, 68, + /* 460 */ 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + /* 470 */ 230, 231, 232, 377, 234, 235, 236, 237, 238, 239, /* 480 */ 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - /* 490 */ 250, 251, 252, 12, 13, 86, 106, 106, 13, 485, - /* 500 */ 137, 20, 380, 22, 141, 1, 492, 69, 105, 70, - /* 510 */ 358, 108, 360, 72, 73, 74, 35, 435, 37, 397, - /* 520 */ 79, 80, 81, 19, 510, 511, 85, 232, 406, 515, - /* 530 */ 516, 90, 91, 92, 93, 144, 359, 96, 0, 35, - /* 540 */ 99, 230, 279, 176, 177, 64, 285, 286, 287, 372, - /* 550 */ 367, 70, 69, 114, 371, 51, 373, 148, 77, 458, - /* 560 */ 39, 40, 77, 59, 60, 61, 62, 485, 64, 380, - /* 570 */ 207, 378, 116, 210, 492, 172, 213, 400, 215, 170, - /* 580 */ 171, 190, 191, 192, 103, 484, 195, 106, 395, 412, - /* 590 */ 52, 414, 510, 511, 20, 406, 403, 515, 516, 208, - /* 600 */ 209, 290, 291, 292, 293, 294, 295, 296, 178, 105, - /* 610 */ 219, 33, 108, 222, 175, 2, 225, 226, 227, 228, + /* 490 */ 250, 251, 252, 12, 13, 426, 427, 106, 402, 110, + /* 500 */ 111, 20, 113, 22, 106, 1, 0, 370, 371, 70, + /* 510 */ 370, 371, 484, 72, 73, 74, 35, 434, 37, 491, + /* 520 */ 79, 80, 81, 19, 135, 232, 85, 390, 139, 413, + /* 530 */ 390, 90, 91, 92, 93, 144, 358, 96, 510, 35, + /* 540 */ 99, 4, 514, 515, 428, 64, 391, 431, 432, 371, + /* 550 */ 20, 70, 22, 114, 399, 51, 19, 395, 77, 20, + /* 560 */ 172, 22, 407, 59, 60, 61, 62, 484, 64, 14, + /* 570 */ 15, 16, 35, 178, 491, 69, 37, 399, 473, 474, + /* 580 */ 20, 190, 191, 192, 103, 55, 195, 106, 51, 411, + /* 590 */ 202, 413, 509, 510, 55, 58, 0, 514, 515, 208, + /* 600 */ 209, 64, 434, 267, 268, 269, 270, 439, 355, 105, + /* 610 */ 219, 449, 108, 222, 175, 2, 225, 226, 227, 228, /* 620 */ 229, 8, 9, 142, 143, 12, 13, 14, 15, 16, - /* 630 */ 453, 110, 111, 456, 113, 13, 459, 460, 461, 462, - /* 640 */ 463, 464, 50, 466, 140, 20, 469, 3, 471, 472, - /* 650 */ 473, 400, 12, 13, 477, 478, 135, 176, 177, 37, - /* 660 */ 139, 359, 232, 20, 183, 184, 415, 8, 9, 279, - /* 670 */ 279, 12, 13, 14, 15, 16, 252, 37, 254, 198, - /* 680 */ 106, 200, 8, 9, 180, 107, 12, 13, 14, 15, - /* 690 */ 16, 187, 33, 371, 255, 256, 257, 258, 259, 260, - /* 700 */ 261, 262, 263, 264, 265, 12, 13, 14, 15, 16, - /* 710 */ 206, 230, 231, 232, 412, 234, 235, 236, 237, 238, + /* 630 */ 452, 12, 13, 455, 69, 193, 458, 459, 460, 461, + /* 640 */ 462, 463, 105, 465, 140, 108, 468, 51, 470, 471, + /* 650 */ 472, 0, 484, 399, 476, 477, 37, 176, 177, 491, + /* 660 */ 399, 371, 220, 221, 183, 184, 106, 406, 414, 278, + /* 670 */ 271, 272, 273, 274, 275, 414, 278, 509, 510, 198, + /* 680 */ 4, 200, 514, 515, 180, 136, 137, 434, 116, 399, + /* 690 */ 141, 187, 439, 0, 255, 256, 257, 258, 259, 260, + /* 700 */ 261, 262, 263, 264, 265, 370, 371, 64, 370, 371, + /* 710 */ 206, 230, 231, 232, 106, 234, 235, 236, 237, 238, /* 720 */ 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - /* 730 */ 249, 250, 251, 12, 13, 14, 4, 371, 372, 106, - /* 740 */ 252, 20, 359, 22, 266, 267, 268, 269, 270, 271, - /* 750 */ 272, 273, 274, 275, 276, 372, 35, 391, 37, 135, - /* 760 */ 136, 137, 138, 139, 140, 141, 107, 445, 446, 414, - /* 770 */ 178, 356, 267, 268, 269, 270, 359, 172, 186, 175, - /* 780 */ 388, 4, 193, 400, 429, 64, 400, 432, 433, 372, - /* 790 */ 22, 374, 392, 407, 402, 412, 19, 414, 77, 400, - /* 800 */ 400, 415, 371, 372, 412, 37, 407, 202, 408, 220, - /* 810 */ 221, 470, 35, 472, 415, 8, 9, 400, 22, 12, - /* 820 */ 13, 14, 15, 16, 103, 371, 372, 106, 51, 412, - /* 830 */ 197, 414, 199, 37, 77, 58, 453, 22, 106, 456, - /* 840 */ 200, 64, 459, 460, 461, 462, 463, 464, 456, 466, - /* 850 */ 435, 420, 37, 279, 471, 440, 473, 232, 466, 255, - /* 860 */ 477, 478, 229, 142, 143, 0, 371, 435, 116, 265, - /* 870 */ 453, 103, 440, 456, 420, 232, 459, 460, 461, 462, - /* 880 */ 463, 464, 105, 466, 485, 108, 400, 504, 471, 441, - /* 890 */ 473, 492, 77, 407, 477, 478, 14, 176, 177, 103, - /* 900 */ 485, 415, 20, 4, 183, 184, 470, 492, 472, 510, - /* 910 */ 511, 106, 279, 20, 515, 516, 0, 485, 103, 198, - /* 920 */ 115, 200, 136, 137, 492, 510, 511, 141, 8, 9, - /* 930 */ 515, 516, 12, 13, 14, 15, 16, 371, 372, 14, - /* 940 */ 445, 446, 510, 511, 300, 20, 359, 515, 516, 474, - /* 950 */ 475, 230, 231, 232, 401, 234, 235, 236, 237, 238, + /* 730 */ 249, 250, 251, 12, 13, 14, 20, 484, 166, 370, + /* 740 */ 371, 20, 358, 22, 491, 484, 399, 3, 105, 230, + /* 750 */ 460, 108, 491, 406, 419, 371, 35, 419, 37, 390, + /* 760 */ 20, 414, 509, 510, 20, 358, 116, 514, 515, 22, + /* 770 */ 509, 510, 50, 370, 371, 514, 515, 399, 371, 469, + /* 780 */ 373, 471, 106, 399, 37, 64, 135, 136, 137, 138, + /* 790 */ 139, 140, 141, 390, 20, 411, 399, 413, 77, 412, + /* 800 */ 413, 423, 370, 371, 407, 197, 399, 199, 289, 290, + /* 810 */ 291, 292, 293, 294, 295, 172, 370, 371, 411, 200, + /* 820 */ 413, 358, 106, 33, 103, 22, 379, 106, 135, 136, + /* 830 */ 137, 138, 139, 140, 141, 358, 452, 229, 278, 455, + /* 840 */ 37, 398, 458, 459, 460, 461, 462, 463, 371, 465, + /* 850 */ 103, 107, 405, 410, 470, 252, 472, 56, 57, 452, + /* 860 */ 476, 477, 455, 142, 143, 458, 459, 460, 461, 462, + /* 870 */ 463, 469, 465, 471, 411, 408, 399, 470, 411, 472, + /* 880 */ 77, 51, 468, 476, 477, 471, 278, 503, 411, 59, + /* 890 */ 413, 391, 62, 63, 484, 370, 371, 176, 177, 399, + /* 900 */ 178, 491, 391, 77, 183, 184, 103, 407, 186, 387, + /* 910 */ 399, 479, 480, 481, 482, 390, 484, 485, 407, 198, + /* 920 */ 510, 200, 178, 401, 514, 515, 480, 481, 482, 452, + /* 930 */ 484, 485, 455, 411, 20, 458, 459, 460, 461, 462, + /* 940 */ 463, 464, 465, 466, 467, 12, 13, 14, 15, 16, + /* 950 */ 176, 230, 231, 232, 278, 234, 235, 236, 237, 238, /* 960 */ 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - /* 970 */ 249, 250, 251, 12, 13, 400, 359, 371, 372, 0, - /* 980 */ 135, 20, 407, 22, 139, 178, 420, 371, 372, 372, - /* 990 */ 415, 374, 371, 372, 371, 372, 35, 391, 37, 412, - /* 1000 */ 135, 136, 137, 138, 139, 140, 141, 391, 359, 485, - /* 1010 */ 13, 279, 391, 198, 391, 200, 492, 400, 371, 372, - /* 1020 */ 392, 372, 359, 374, 34, 64, 392, 107, 400, 412, - /* 1030 */ 469, 414, 22, 472, 400, 511, 408, 401, 77, 515, - /* 1040 */ 516, 409, 408, 435, 412, 230, 231, 37, 20, 400, - /* 1050 */ 33, 135, 136, 137, 138, 139, 140, 141, 176, 1, - /* 1060 */ 2, 412, 45, 414, 103, 371, 372, 106, 388, 176, - /* 1070 */ 453, 413, 414, 456, 77, 412, 459, 460, 461, 462, - /* 1080 */ 463, 464, 402, 466, 0, 391, 359, 77, 471, 359, - /* 1090 */ 473, 435, 412, 485, 477, 478, 371, 372, 376, 377, - /* 1100 */ 492, 176, 453, 142, 143, 456, 20, 359, 459, 460, - /* 1110 */ 461, 462, 463, 464, 232, 466, 391, 359, 510, 511, - /* 1120 */ 471, 359, 473, 515, 516, 232, 477, 478, 481, 482, - /* 1130 */ 483, 359, 485, 486, 371, 372, 456, 176, 177, 412, - /* 1140 */ 161, 485, 412, 400, 183, 184, 466, 14, 492, 170, - /* 1150 */ 14, 15, 16, 20, 391, 371, 372, 232, 415, 198, - /* 1160 */ 412, 200, 359, 371, 372, 107, 510, 511, 371, 372, - /* 1170 */ 412, 515, 516, 409, 412, 391, 412, 359, 56, 57, - /* 1180 */ 281, 359, 359, 391, 412, 376, 377, 359, 391, 359, - /* 1190 */ 359, 230, 231, 232, 70, 234, 235, 236, 237, 238, + /* 970 */ 249, 250, 251, 12, 13, 358, 3, 455, 20, 370, + /* 980 */ 371, 20, 399, 22, 370, 371, 358, 465, 371, 406, + /* 990 */ 373, 370, 371, 457, 278, 13, 35, 414, 37, 390, + /* 1000 */ 4, 198, 0, 200, 390, 358, 232, 8, 9, 370, + /* 1010 */ 371, 12, 13, 14, 15, 16, 399, 399, 371, 483, + /* 1020 */ 373, 358, 370, 371, 406, 64, 1, 2, 411, 390, + /* 1030 */ 413, 358, 414, 230, 231, 370, 371, 23, 77, 411, + /* 1040 */ 419, 135, 390, 8, 9, 139, 399, 12, 13, 14, + /* 1050 */ 15, 16, 116, 370, 371, 390, 399, 20, 411, 77, + /* 1060 */ 413, 47, 48, 406, 103, 370, 371, 106, 175, 452, + /* 1070 */ 0, 414, 455, 390, 411, 458, 459, 460, 461, 462, + /* 1080 */ 463, 400, 465, 22, 411, 390, 358, 470, 358, 472, + /* 1090 */ 434, 301, 178, 476, 477, 14, 370, 371, 37, 452, + /* 1100 */ 434, 20, 455, 142, 143, 458, 459, 460, 461, 462, + /* 1110 */ 463, 33, 465, 370, 371, 2, 390, 470, 20, 472, + /* 1120 */ 358, 8, 9, 476, 477, 12, 13, 14, 15, 16, + /* 1130 */ 375, 376, 107, 390, 370, 371, 178, 176, 177, 411, + /* 1140 */ 484, 411, 107, 457, 183, 184, 232, 491, 255, 137, + /* 1150 */ 484, 375, 376, 141, 390, 384, 385, 491, 265, 198, + /* 1160 */ 214, 200, 216, 161, 103, 509, 510, 434, 34, 483, + /* 1170 */ 514, 515, 170, 411, 399, 509, 510, 178, 358, 358, + /* 1180 */ 514, 515, 135, 136, 137, 138, 139, 140, 141, 414, + /* 1190 */ 232, 230, 231, 232, 400, 234, 235, 236, 237, 238, /* 1200 */ 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - /* 1210 */ 249, 250, 251, 12, 13, 412, 359, 371, 372, 371, - /* 1220 */ 372, 20, 359, 22, 371, 372, 371, 372, 396, 372, - /* 1230 */ 412, 374, 371, 372, 412, 412, 35, 391, 37, 391, - /* 1240 */ 412, 0, 412, 412, 391, 359, 391, 116, 359, 385, - /* 1250 */ 386, 0, 391, 385, 386, 393, 409, 400, 396, 412, - /* 1260 */ 232, 372, 33, 374, 178, 64, 0, 362, 363, 412, - /* 1270 */ 109, 414, 13, 112, 45, 412, 109, 109, 77, 112, - /* 1280 */ 112, 109, 450, 0, 112, 214, 33, 216, 64, 400, - /* 1290 */ 0, 33, 51, 42, 37, 33, 37, 166, 412, 33, - /* 1300 */ 33, 412, 33, 414, 103, 22, 33, 106, 224, 33, - /* 1310 */ 453, 37, 22, 456, 49, 33, 459, 460, 461, 462, - /* 1320 */ 463, 464, 33, 466, 142, 143, 33, 401, 471, 33, - /* 1330 */ 473, 33, 108, 33, 477, 478, 1, 2, 33, 33, - /* 1340 */ 33, 401, 453, 142, 143, 456, 33, 401, 459, 460, - /* 1350 */ 461, 462, 463, 464, 230, 466, 33, 37, 401, 389, - /* 1360 */ 471, 360, 473, 12, 13, 107, 477, 478, 359, 107, - /* 1370 */ 13, 106, 487, 22, 107, 425, 107, 176, 177, 33, - /* 1380 */ 107, 372, 33, 374, 183, 184, 35, 33, 37, 107, - /* 1390 */ 519, 508, 13, 375, 37, 488, 107, 77, 501, 198, - /* 1400 */ 107, 200, 400, 107, 388, 107, 425, 107, 388, 400, - /* 1410 */ 370, 425, 107, 107, 107, 64, 37, 507, 507, 507, - /* 1420 */ 107, 412, 434, 414, 507, 375, 372, 442, 77, 425, - /* 1430 */ 107, 230, 231, 232, 411, 234, 235, 236, 237, 238, + /* 1210 */ 249, 250, 251, 12, 13, 358, 13, 484, 358, 207, + /* 1220 */ 358, 20, 210, 22, 491, 213, 358, 215, 371, 358, + /* 1230 */ 373, 411, 411, 358, 370, 371, 35, 408, 37, 358, + /* 1240 */ 411, 408, 509, 510, 411, 8, 9, 514, 515, 12, + /* 1250 */ 13, 14, 15, 16, 390, 0, 399, 176, 384, 385, + /* 1260 */ 70, 392, 361, 362, 395, 64, 33, 0, 411, 232, + /* 1270 */ 413, 411, 299, 411, 440, 33, 280, 33, 77, 411, + /* 1280 */ 77, 13, 411, 12, 13, 109, 411, 45, 112, 45, + /* 1290 */ 33, 400, 411, 22, 224, 109, 109, 42, 112, 112, + /* 1300 */ 33, 49, 13, 64, 103, 37, 35, 106, 37, 452, + /* 1310 */ 358, 109, 455, 232, 112, 458, 459, 460, 461, 462, + /* 1320 */ 463, 33, 465, 371, 0, 373, 37, 470, 0, 472, + /* 1330 */ 232, 0, 33, 476, 477, 64, 142, 143, 1, 2, + /* 1340 */ 107, 37, 33, 142, 143, 33, 22, 108, 77, 33, + /* 1350 */ 22, 399, 33, 22, 37, 13, 33, 106, 106, 400, + /* 1360 */ 33, 424, 400, 411, 107, 413, 115, 400, 388, 13, + /* 1370 */ 359, 486, 518, 507, 103, 0, 487, 176, 177, 37, + /* 1380 */ 33, 303, 33, 33, 183, 184, 33, 33, 500, 374, + /* 1390 */ 33, 399, 387, 37, 77, 107, 387, 369, 33, 198, + /* 1400 */ 424, 200, 424, 506, 452, 506, 107, 455, 506, 506, + /* 1410 */ 458, 459, 460, 461, 462, 463, 107, 465, 33, 107, + /* 1420 */ 230, 433, 470, 107, 472, 374, 107, 52, 476, 477, + /* 1430 */ 107, 230, 231, 232, 107, 234, 235, 236, 237, 238, /* 1440 */ 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - /* 1450 */ 249, 250, 251, 107, 103, 425, 107, 200, 425, 491, - /* 1460 */ 491, 107, 453, 512, 390, 456, 479, 494, 459, 460, - /* 1470 */ 461, 462, 463, 464, 200, 466, 282, 436, 51, 455, - /* 1480 */ 471, 42, 473, 454, 20, 447, 477, 478, 213, 452, - /* 1490 */ 380, 447, 380, 196, 438, 20, 371, 20, 372, 45, - /* 1500 */ 421, 372, 421, 175, 372, 418, 371, 418, 371, 421, - /* 1510 */ 418, 104, 384, 102, 371, 101, 371, 383, 371, 359, - /* 1520 */ 382, 371, 20, 364, 50, 368, 364, 447, 380, 380, - /* 1530 */ 20, 368, 372, 414, 380, 20, 20, 373, 437, 373, - /* 1540 */ 20, 428, 371, 364, 400, 380, 400, 217, 451, 198, - /* 1550 */ 380, 200, 359, 380, 380, 302, 380, 362, 400, 371, - /* 1560 */ 400, 362, 364, 412, 412, 372, 106, 412, 378, 400, - /* 1570 */ 449, 20, 412, 446, 414, 400, 204, 400, 400, 203, - /* 1580 */ 304, 230, 231, 400, 400, 400, 400, 447, 378, 359, - /* 1590 */ 371, 500, 436, 400, 414, 244, 245, 246, 247, 248, - /* 1600 */ 249, 250, 372, 412, 289, 412, 288, 414, 500, 297, - /* 1610 */ 503, 189, 298, 453, 500, 299, 456, 430, 502, 459, - /* 1620 */ 460, 461, 462, 463, 464, 444, 466, 430, 436, 499, - /* 1630 */ 400, 471, 443, 473, 278, 283, 497, 477, 478, 498, - /* 1640 */ 277, 303, 412, 490, 414, 306, 453, 20, 301, 456, - /* 1650 */ 372, 116, 459, 460, 461, 462, 463, 464, 280, 466, - /* 1660 */ 458, 359, 520, 378, 471, 373, 473, 430, 412, 378, - /* 1670 */ 477, 478, 412, 412, 372, 412, 430, 181, 426, 378, - /* 1680 */ 412, 378, 396, 453, 106, 489, 456, 476, 404, 459, - /* 1690 */ 460, 461, 462, 463, 464, 106, 466, 372, 495, 493, - /* 1700 */ 412, 471, 400, 473, 359, 371, 22, 477, 478, 378, - /* 1710 */ 38, 361, 364, 513, 412, 394, 414, 372, 514, 439, - /* 1720 */ 365, 394, 379, 394, 357, 448, 431, 0, 0, 0, - /* 1730 */ 431, 45, 0, 359, 37, 223, 37, 37, 37, 0, - /* 1740 */ 223, 37, 223, 37, 37, 400, 372, 0, 223, 0, - /* 1750 */ 37, 0, 22, 0, 37, 453, 218, 412, 456, 414, - /* 1760 */ 0, 459, 460, 461, 462, 463, 464, 206, 466, 0, - /* 1770 */ 206, 200, 207, 198, 400, 473, 0, 0, 0, 477, - /* 1780 */ 478, 194, 0, 193, 0, 147, 412, 49, 414, 49, - /* 1790 */ 0, 37, 51, 0, 49, 0, 0, 45, 453, 0, - /* 1800 */ 359, 456, 0, 0, 459, 460, 461, 462, 463, 464, - /* 1810 */ 49, 466, 0, 372, 0, 0, 0, 0, 473, 161, - /* 1820 */ 37, 0, 477, 478, 161, 0, 0, 453, 0, 359, - /* 1830 */ 456, 0, 0, 459, 460, 461, 462, 463, 464, 0, - /* 1840 */ 466, 400, 372, 0, 0, 0, 0, 473, 146, 49, - /* 1850 */ 0, 477, 478, 412, 0, 414, 0, 0, 0, 0, - /* 1860 */ 0, 0, 0, 45, 0, 0, 0, 0, 0, 0, - /* 1870 */ 400, 0, 147, 22, 0, 0, 145, 0, 0, 50, - /* 1880 */ 0, 0, 412, 50, 414, 22, 64, 64, 0, 37, - /* 1890 */ 0, 64, 22, 0, 453, 42, 0, 456, 51, 0, - /* 1900 */ 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, - /* 1910 */ 37, 359, 0, 37, 42, 0, 37, 14, 0, 37, - /* 1920 */ 33, 0, 0, 453, 372, 42, 456, 42, 0, 459, - /* 1930 */ 460, 461, 462, 463, 464, 51, 466, 51, 49, 45, - /* 1940 */ 49, 359, 0, 43, 49, 189, 42, 42, 0, 0, - /* 1950 */ 49, 0, 400, 0, 372, 0, 37, 51, 42, 0, - /* 1960 */ 37, 51, 42, 71, 412, 0, 414, 37, 51, 42, - /* 1970 */ 0, 37, 0, 42, 0, 505, 506, 51, 0, 359, - /* 1980 */ 0, 0, 400, 0, 37, 22, 0, 37, 0, 37, - /* 1990 */ 33, 37, 372, 37, 412, 37, 414, 37, 37, 37, - /* 2000 */ 33, 37, 0, 37, 22, 453, 359, 22, 456, 112, - /* 2010 */ 37, 459, 460, 461, 462, 463, 464, 22, 466, 372, - /* 2020 */ 400, 114, 53, 0, 37, 22, 0, 0, 0, 37, - /* 2030 */ 0, 37, 412, 0, 414, 453, 22, 20, 456, 107, - /* 2040 */ 0, 459, 460, 461, 462, 463, 464, 400, 466, 359, - /* 2050 */ 37, 106, 405, 37, 205, 473, 37, 49, 0, 412, - /* 2060 */ 478, 414, 372, 22, 359, 0, 37, 22, 0, 517, - /* 2070 */ 518, 0, 3, 453, 106, 33, 456, 372, 284, 459, - /* 2080 */ 460, 461, 462, 463, 464, 106, 466, 178, 50, 178, - /* 2090 */ 400, 178, 178, 185, 104, 405, 107, 106, 50, 201, - /* 2100 */ 453, 102, 412, 456, 414, 400, 459, 460, 461, 462, - /* 2110 */ 463, 464, 107, 466, 181, 178, 33, 412, 33, 414, - /* 2120 */ 185, 359, 107, 33, 106, 49, 506, 106, 106, 49, - /* 2130 */ 33, 107, 77, 33, 372, 37, 3, 106, 106, 284, - /* 2140 */ 33, 107, 107, 453, 107, 37, 456, 37, 37, 459, - /* 2150 */ 460, 461, 462, 463, 464, 37, 466, 37, 453, 37, - /* 2160 */ 107, 456, 400, 107, 459, 460, 461, 462, 463, 464, - /* 2170 */ 49, 466, 33, 49, 412, 0, 414, 0, 106, 42, - /* 2180 */ 106, 0, 107, 182, 107, 106, 284, 106, 106, 359, - /* 2190 */ 266, 42, 180, 106, 49, 33, 104, 253, 104, 115, - /* 2200 */ 2, 22, 372, 107, 49, 230, 107, 359, 106, 106, - /* 2210 */ 106, 22, 107, 49, 509, 453, 107, 233, 456, 106, - /* 2220 */ 372, 459, 460, 461, 462, 463, 464, 37, 466, 106, - /* 2230 */ 400, 106, 116, 107, 37, 405, 106, 37, 107, 107, - /* 2240 */ 106, 37, 412, 107, 414, 37, 106, 106, 400, 107, - /* 2250 */ 37, 107, 106, 37, 106, 127, 127, 106, 33, 106, - /* 2260 */ 412, 37, 414, 106, 22, 127, 71, 37, 77, 70, - /* 2270 */ 127, 37, 37, 37, 37, 37, 37, 37, 37, 77, - /* 2280 */ 518, 33, 100, 453, 359, 100, 456, 37, 37, 459, - /* 2290 */ 460, 461, 462, 463, 464, 37, 466, 372, 22, 37, - /* 2300 */ 37, 453, 37, 77, 456, 37, 37, 459, 460, 461, - /* 2310 */ 462, 463, 464, 22, 466, 37, 468, 37, 37, 37, - /* 2320 */ 0, 37, 51, 0, 37, 400, 51, 42, 42, 0, - /* 2330 */ 405, 37, 42, 0, 51, 37, 0, 412, 42, 414, - /* 2340 */ 51, 37, 37, 0, 22, 33, 22, 22, 21, 521, - /* 2350 */ 22, 21, 359, 521, 20, 521, 521, 521, 521, 521, - /* 2360 */ 521, 521, 521, 521, 521, 372, 521, 521, 521, 521, - /* 2370 */ 521, 521, 521, 521, 521, 521, 521, 521, 453, 359, - /* 2380 */ 521, 456, 521, 521, 459, 460, 461, 462, 463, 464, - /* 2390 */ 521, 466, 372, 400, 521, 359, 521, 521, 405, 521, - /* 2400 */ 521, 521, 521, 521, 521, 412, 521, 414, 372, 521, - /* 2410 */ 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, - /* 2420 */ 400, 521, 359, 521, 521, 521, 521, 521, 521, 521, - /* 2430 */ 521, 521, 412, 521, 414, 372, 400, 521, 521, 521, - /* 2440 */ 521, 521, 521, 521, 521, 521, 453, 521, 412, 456, - /* 2450 */ 414, 521, 459, 460, 461, 462, 463, 464, 521, 466, - /* 2460 */ 521, 521, 521, 400, 521, 359, 521, 521, 521, 521, - /* 2470 */ 521, 521, 521, 453, 521, 412, 456, 414, 372, 459, - /* 2480 */ 460, 461, 462, 463, 464, 521, 466, 521, 521, 453, - /* 2490 */ 521, 521, 456, 521, 359, 459, 460, 461, 462, 463, - /* 2500 */ 464, 521, 466, 521, 521, 521, 400, 372, 521, 521, - /* 2510 */ 521, 521, 521, 521, 521, 521, 453, 521, 412, 456, - /* 2520 */ 414, 521, 459, 460, 461, 462, 463, 464, 521, 466, - /* 2530 */ 521, 521, 521, 521, 521, 400, 521, 521, 521, 521, - /* 2540 */ 521, 521, 521, 521, 521, 521, 521, 412, 521, 414, - /* 2550 */ 521, 521, 521, 521, 521, 521, 521, 521, 521, 453, - /* 2560 */ 521, 521, 456, 521, 521, 459, 460, 461, 462, 463, - /* 2570 */ 464, 521, 466, 521, 359, 521, 521, 521, 521, 521, - /* 2580 */ 521, 521, 521, 521, 521, 521, 521, 372, 453, 521, - /* 2590 */ 359, 456, 521, 521, 459, 460, 461, 462, 463, 464, - /* 2600 */ 521, 466, 521, 372, 521, 521, 521, 521, 359, 521, - /* 2610 */ 521, 521, 521, 521, 521, 400, 521, 521, 521, 521, - /* 2620 */ 521, 372, 521, 521, 521, 521, 521, 412, 521, 414, - /* 2630 */ 521, 400, 521, 521, 521, 521, 521, 521, 521, 521, - /* 2640 */ 521, 521, 521, 412, 521, 414, 521, 521, 521, 400, - /* 2650 */ 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, - /* 2660 */ 521, 412, 521, 414, 521, 521, 521, 521, 453, 521, - /* 2670 */ 521, 456, 521, 521, 459, 460, 461, 462, 463, 464, - /* 2680 */ 521, 466, 521, 521, 453, 359, 521, 456, 521, 521, - /* 2690 */ 459, 460, 461, 462, 463, 464, 521, 466, 372, 521, - /* 2700 */ 521, 521, 453, 521, 521, 456, 521, 521, 459, 460, - /* 2710 */ 461, 462, 463, 464, 521, 466, 521, 521, 521, 521, - /* 2720 */ 521, 521, 521, 521, 521, 521, 400, 521, 521, 521, - /* 2730 */ 521, 521, 521, 521, 521, 521, 521, 521, 412, 521, - /* 2740 */ 414, 521, 521, 521, 521, 521, 521, 521, 521, 521, - /* 2750 */ 521, 521, 359, 521, 521, 521, 521, 521, 521, 521, - /* 2760 */ 521, 521, 521, 521, 521, 372, 521, 359, 521, 521, - /* 2770 */ 521, 521, 521, 521, 521, 521, 521, 521, 521, 453, - /* 2780 */ 372, 521, 456, 521, 521, 459, 460, 461, 462, 463, - /* 2790 */ 464, 521, 466, 400, 521, 521, 521, 521, 521, 521, - /* 2800 */ 521, 521, 521, 521, 521, 412, 521, 414, 400, 521, - /* 2810 */ 359, 521, 521, 521, 521, 521, 521, 521, 521, 521, - /* 2820 */ 412, 521, 414, 372, 521, 359, 521, 521, 521, 521, - /* 2830 */ 521, 521, 521, 521, 521, 521, 521, 521, 372, 521, - /* 2840 */ 521, 521, 521, 521, 521, 521, 453, 521, 521, 456, - /* 2850 */ 521, 400, 459, 460, 461, 462, 463, 464, 521, 466, - /* 2860 */ 521, 453, 521, 412, 456, 414, 400, 459, 460, 461, - /* 2870 */ 462, 463, 464, 521, 466, 521, 521, 521, 412, 521, - /* 2880 */ 414, 521, 359, 521, 521, 521, 521, 521, 521, 521, - /* 2890 */ 521, 521, 521, 521, 521, 372, 521, 521, 521, 521, - /* 2900 */ 521, 521, 521, 521, 453, 521, 521, 456, 521, 521, - /* 2910 */ 459, 460, 461, 462, 463, 464, 521, 466, 521, 453, - /* 2920 */ 521, 521, 456, 400, 521, 459, 460, 461, 462, 463, - /* 2930 */ 464, 521, 466, 521, 521, 412, 521, 414, 521, 521, - /* 2940 */ 521, 521, 521, 521, 521, 521, 521, 359, 521, 521, - /* 2950 */ 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, - /* 2960 */ 372, 521, 521, 521, 521, 521, 521, 521, 359, 521, - /* 2970 */ 521, 521, 521, 521, 521, 521, 453, 521, 521, 456, - /* 2980 */ 521, 372, 459, 460, 461, 462, 463, 464, 400, 466, - /* 2990 */ 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, - /* 3000 */ 412, 521, 414, 521, 521, 359, 521, 521, 521, 400, - /* 3010 */ 521, 521, 521, 521, 521, 521, 521, 521, 372, 521, - /* 3020 */ 521, 412, 521, 414, 521, 521, 521, 521, 521, 521, - /* 3030 */ 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, - /* 3040 */ 521, 453, 521, 521, 456, 521, 400, 459, 460, 461, - /* 3050 */ 462, 463, 464, 521, 466, 521, 521, 521, 412, 521, - /* 3060 */ 414, 521, 453, 521, 521, 456, 521, 521, 459, 460, - /* 3070 */ 461, 462, 463, 464, 521, 466, 521, 521, 521, 521, - /* 3080 */ 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, - /* 3090 */ 521, 521, 521, 521, 521, 521, 521, 521, 359, 453, - /* 3100 */ 521, 521, 456, 521, 521, 459, 460, 461, 462, 463, - /* 3110 */ 464, 372, 466, 521, 521, 521, 521, 521, 521, 521, - /* 3120 */ 521, 521, 521, 521, 521, 359, 521, 521, 521, 521, - /* 3130 */ 521, 521, 521, 521, 521, 521, 521, 521, 372, 400, - /* 3140 */ 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, - /* 3150 */ 521, 412, 521, 414, 521, 521, 521, 521, 521, 521, - /* 3160 */ 521, 521, 521, 521, 521, 521, 400, 521, 359, 521, - /* 3170 */ 521, 521, 521, 521, 521, 521, 521, 521, 412, 521, - /* 3180 */ 414, 372, 521, 359, 521, 521, 521, 521, 521, 521, - /* 3190 */ 521, 521, 453, 521, 521, 456, 372, 521, 459, 460, - /* 3200 */ 461, 462, 463, 464, 521, 466, 521, 521, 521, 400, - /* 3210 */ 521, 521, 521, 521, 521, 521, 521, 521, 521, 453, - /* 3220 */ 521, 412, 456, 414, 400, 459, 460, 461, 462, 463, - /* 3230 */ 464, 521, 466, 521, 521, 521, 412, 521, 414, 521, - /* 3240 */ 359, 521, 521, 521, 521, 521, 521, 521, 521, 521, - /* 3250 */ 521, 521, 521, 372, 521, 521, 521, 521, 521, 521, - /* 3260 */ 521, 521, 453, 521, 521, 456, 521, 521, 459, 460, - /* 3270 */ 461, 462, 463, 464, 521, 466, 521, 453, 521, 521, - /* 3280 */ 456, 400, 521, 459, 460, 461, 462, 463, 464, 521, - /* 3290 */ 466, 521, 521, 412, 521, 414, 521, 521, 521, 521, - /* 3300 */ 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, - /* 3310 */ 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, - /* 3320 */ 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, - /* 3330 */ 521, 521, 521, 521, 453, 521, 521, 456, 521, 521, - /* 3340 */ 459, 460, 461, 462, 463, 464, 521, 466, 356, 356, - /* 3350 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3360 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3370 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3380 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3390 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3400 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3410 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3420 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3430 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3440 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3450 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3460 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3470 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3480 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3490 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3500 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3510 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3520 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3530 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3540 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3550 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3560 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3570 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3580 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3590 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3600 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3610 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3620 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3630 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3640 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3650 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3660 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3670 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3680 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3690 */ 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - /* 3700 */ 356, 356, 356, 356, + /* 1450 */ 249, 250, 251, 358, 107, 424, 107, 107, 33, 371, + /* 1460 */ 107, 107, 33, 410, 107, 441, 371, 424, 373, 198, + /* 1470 */ 424, 200, 107, 490, 490, 511, 478, 281, 493, 389, + /* 1480 */ 435, 51, 358, 454, 42, 453, 20, 446, 213, 451, + /* 1490 */ 379, 379, 107, 196, 399, 371, 446, 437, 20, 370, + /* 1500 */ 20, 230, 231, 371, 200, 45, 411, 420, 413, 371, + /* 1510 */ 417, 420, 370, 175, 371, 244, 245, 246, 247, 248, + /* 1520 */ 249, 250, 370, 399, 420, 417, 417, 104, 383, 102, + /* 1530 */ 382, 370, 107, 101, 381, 411, 107, 413, 370, 370, + /* 1540 */ 370, 20, 363, 50, 367, 363, 446, 452, 367, 20, + /* 1550 */ 455, 358, 379, 458, 459, 460, 461, 462, 463, 379, + /* 1560 */ 465, 20, 413, 379, 371, 470, 20, 472, 379, 372, + /* 1570 */ 372, 476, 477, 436, 379, 20, 452, 427, 379, 455, + /* 1580 */ 358, 370, 458, 459, 460, 461, 462, 463, 379, 465, + /* 1590 */ 363, 379, 399, 371, 470, 370, 472, 361, 363, 399, + /* 1600 */ 476, 477, 361, 399, 411, 399, 413, 399, 217, 399, + /* 1610 */ 450, 106, 399, 399, 399, 399, 399, 399, 411, 448, + /* 1620 */ 446, 399, 377, 20, 204, 203, 377, 442, 445, 370, + /* 1630 */ 411, 411, 411, 411, 443, 413, 413, 296, 499, 288, + /* 1640 */ 435, 189, 287, 499, 298, 452, 277, 501, 455, 502, + /* 1650 */ 499, 458, 459, 460, 461, 462, 463, 429, 465, 429, + /* 1660 */ 498, 297, 497, 470, 282, 472, 358, 435, 496, 476, + /* 1670 */ 477, 276, 305, 519, 452, 302, 488, 455, 300, 371, + /* 1680 */ 458, 459, 460, 461, 462, 463, 371, 465, 513, 20, + /* 1690 */ 512, 457, 470, 358, 472, 116, 279, 372, 476, 477, + /* 1700 */ 181, 429, 411, 377, 411, 411, 371, 399, 429, 377, + /* 1710 */ 425, 411, 411, 489, 371, 395, 377, 377, 106, 411, + /* 1720 */ 494, 413, 475, 492, 358, 106, 22, 38, 370, 411, + /* 1730 */ 360, 363, 403, 438, 399, 364, 377, 371, 393, 447, + /* 1740 */ 430, 430, 356, 0, 0, 393, 411, 45, 413, 0, + /* 1750 */ 378, 0, 37, 393, 223, 37, 37, 37, 223, 0, + /* 1760 */ 452, 37, 223, 455, 37, 399, 458, 459, 460, 461, + /* 1770 */ 462, 463, 37, 465, 0, 223, 0, 411, 37, 413, + /* 1780 */ 472, 0, 22, 0, 476, 477, 218, 452, 0, 37, + /* 1790 */ 455, 358, 206, 458, 459, 460, 461, 462, 463, 0, + /* 1800 */ 465, 206, 200, 207, 371, 198, 358, 472, 0, 0, + /* 1810 */ 0, 476, 477, 0, 194, 193, 0, 147, 452, 371, + /* 1820 */ 49, 455, 49, 0, 458, 459, 460, 461, 462, 463, + /* 1830 */ 37, 465, 399, 51, 0, 49, 0, 45, 472, 0, + /* 1840 */ 0, 0, 476, 477, 411, 49, 413, 399, 0, 0, + /* 1850 */ 0, 0, 0, 0, 161, 37, 0, 161, 0, 411, + /* 1860 */ 0, 413, 0, 0, 0, 0, 0, 0, 0, 0, + /* 1870 */ 0, 0, 0, 0, 358, 49, 0, 45, 0, 0, + /* 1880 */ 0, 0, 0, 0, 0, 452, 0, 371, 455, 0, + /* 1890 */ 0, 458, 459, 460, 461, 462, 463, 0, 465, 22, + /* 1900 */ 452, 147, 0, 455, 146, 0, 458, 459, 460, 461, + /* 1910 */ 462, 463, 145, 465, 0, 399, 0, 358, 22, 0, + /* 1920 */ 22, 64, 0, 64, 50, 37, 0, 411, 0, 413, + /* 1930 */ 371, 0, 37, 0, 42, 50, 37, 504, 505, 358, + /* 1940 */ 37, 0, 51, 42, 51, 0, 37, 0, 33, 42, + /* 1950 */ 14, 64, 371, 45, 42, 0, 0, 51, 399, 49, + /* 1960 */ 49, 43, 49, 42, 516, 517, 0, 0, 452, 0, + /* 1970 */ 411, 455, 413, 189, 458, 459, 460, 461, 462, 463, + /* 1980 */ 399, 465, 0, 49, 42, 404, 0, 0, 472, 0, + /* 1990 */ 0, 71, 411, 477, 413, 37, 42, 51, 0, 37, + /* 2000 */ 51, 42, 0, 51, 0, 37, 42, 37, 51, 0, + /* 2010 */ 358, 452, 0, 0, 455, 42, 0, 458, 459, 460, + /* 2020 */ 461, 462, 463, 371, 465, 358, 0, 0, 37, 22, + /* 2030 */ 0, 114, 37, 452, 37, 112, 455, 37, 371, 458, + /* 2040 */ 459, 460, 461, 462, 463, 37, 465, 37, 37, 0, + /* 2050 */ 22, 399, 37, 33, 37, 33, 404, 22, 37, 0, + /* 2060 */ 37, 37, 22, 411, 505, 413, 399, 53, 0, 22, + /* 2070 */ 37, 0, 0, 0, 37, 0, 0, 22, 411, 37, + /* 2080 */ 413, 20, 37, 358, 107, 37, 106, 37, 0, 106, + /* 2090 */ 49, 0, 22, 37, 0, 0, 371, 0, 33, 205, + /* 2100 */ 22, 201, 178, 178, 452, 358, 3, 455, 178, 106, + /* 2110 */ 458, 459, 460, 461, 462, 463, 181, 465, 371, 452, + /* 2120 */ 283, 178, 455, 185, 399, 458, 459, 460, 461, 462, + /* 2130 */ 463, 178, 465, 185, 50, 106, 411, 50, 413, 107, + /* 2140 */ 104, 107, 33, 33, 106, 102, 399, 49, 33, 49, + /* 2150 */ 106, 404, 33, 107, 77, 33, 3, 106, 411, 107, + /* 2160 */ 413, 107, 37, 358, 106, 33, 106, 37, 37, 107, + /* 2170 */ 107, 37, 37, 37, 107, 508, 371, 452, 37, 33, + /* 2180 */ 455, 107, 49, 458, 459, 460, 461, 462, 463, 49, + /* 2190 */ 465, 0, 0, 266, 0, 106, 42, 107, 106, 452, + /* 2200 */ 107, 182, 455, 42, 399, 458, 459, 460, 461, 462, + /* 2210 */ 463, 106, 465, 106, 106, 283, 411, 106, 413, 115, + /* 2220 */ 283, 49, 33, 2, 104, 253, 22, 104, 107, 230, + /* 2230 */ 106, 49, 106, 358, 107, 106, 49, 22, 233, 37, + /* 2240 */ 37, 33, 517, 37, 180, 107, 371, 37, 106, 106, + /* 2250 */ 37, 107, 107, 106, 106, 116, 107, 452, 107, 37, + /* 2260 */ 455, 106, 358, 458, 459, 460, 461, 462, 463, 106, + /* 2270 */ 465, 107, 467, 106, 399, 371, 107, 106, 37, 404, + /* 2280 */ 107, 106, 106, 127, 127, 127, 411, 127, 413, 106, + /* 2290 */ 37, 106, 22, 37, 71, 70, 37, 37, 358, 37, + /* 2300 */ 37, 37, 37, 399, 37, 37, 77, 100, 404, 77, + /* 2310 */ 33, 371, 100, 37, 22, 411, 37, 413, 37, 37, + /* 2320 */ 37, 37, 77, 37, 37, 37, 37, 452, 37, 358, + /* 2330 */ 455, 22, 37, 458, 459, 460, 461, 462, 463, 399, + /* 2340 */ 465, 0, 371, 37, 51, 42, 0, 37, 51, 42, + /* 2350 */ 0, 411, 37, 413, 42, 0, 452, 37, 42, 455, + /* 2360 */ 0, 37, 458, 459, 460, 461, 462, 463, 51, 465, + /* 2370 */ 399, 37, 51, 0, 22, 33, 22, 21, 520, 22, + /* 2380 */ 22, 20, 411, 21, 413, 520, 520, 520, 520, 520, + /* 2390 */ 520, 520, 452, 520, 520, 455, 520, 358, 458, 459, + /* 2400 */ 460, 461, 462, 463, 520, 465, 520, 520, 520, 520, + /* 2410 */ 371, 520, 520, 520, 520, 358, 520, 520, 520, 520, + /* 2420 */ 520, 520, 520, 452, 520, 520, 455, 520, 371, 458, + /* 2430 */ 459, 460, 461, 462, 463, 520, 465, 520, 399, 520, + /* 2440 */ 520, 520, 520, 520, 520, 520, 520, 520, 520, 520, + /* 2450 */ 411, 520, 413, 520, 520, 520, 399, 520, 520, 520, + /* 2460 */ 520, 520, 520, 520, 520, 520, 520, 520, 411, 520, + /* 2470 */ 413, 520, 358, 520, 520, 520, 520, 520, 520, 520, + /* 2480 */ 520, 520, 520, 520, 520, 371, 520, 520, 520, 520, + /* 2490 */ 520, 452, 520, 520, 455, 358, 520, 458, 459, 460, + /* 2500 */ 461, 462, 463, 520, 465, 520, 520, 520, 371, 452, + /* 2510 */ 358, 520, 455, 399, 520, 458, 459, 460, 461, 462, + /* 2520 */ 463, 520, 465, 371, 520, 411, 520, 413, 520, 520, + /* 2530 */ 520, 520, 520, 520, 520, 520, 399, 520, 520, 520, + /* 2540 */ 520, 520, 520, 520, 520, 520, 520, 520, 411, 520, + /* 2550 */ 413, 399, 520, 520, 520, 520, 520, 520, 520, 520, + /* 2560 */ 520, 520, 520, 411, 520, 413, 452, 358, 520, 455, + /* 2570 */ 520, 520, 458, 459, 460, 461, 462, 463, 520, 465, + /* 2580 */ 371, 520, 520, 520, 520, 520, 520, 520, 520, 452, + /* 2590 */ 520, 520, 455, 520, 520, 458, 459, 460, 461, 462, + /* 2600 */ 463, 520, 465, 520, 452, 358, 520, 455, 399, 520, + /* 2610 */ 458, 459, 460, 461, 462, 463, 520, 465, 371, 520, + /* 2620 */ 411, 520, 413, 520, 358, 520, 520, 520, 520, 520, + /* 2630 */ 520, 520, 520, 520, 520, 520, 520, 371, 520, 520, + /* 2640 */ 520, 520, 520, 520, 520, 520, 399, 520, 520, 520, + /* 2650 */ 520, 520, 520, 520, 520, 520, 520, 520, 411, 520, + /* 2660 */ 413, 452, 358, 520, 455, 399, 520, 458, 459, 460, + /* 2670 */ 461, 462, 463, 520, 465, 371, 520, 411, 520, 413, + /* 2680 */ 520, 520, 520, 520, 520, 520, 520, 520, 520, 520, + /* 2690 */ 520, 520, 520, 520, 520, 520, 520, 520, 358, 452, + /* 2700 */ 520, 520, 455, 399, 520, 458, 459, 460, 461, 462, + /* 2710 */ 463, 371, 465, 520, 520, 411, 520, 413, 452, 520, + /* 2720 */ 520, 455, 520, 520, 458, 459, 460, 461, 462, 463, + /* 2730 */ 520, 465, 520, 520, 520, 520, 520, 520, 520, 399, + /* 2740 */ 520, 358, 520, 520, 520, 520, 520, 520, 520, 520, + /* 2750 */ 520, 411, 520, 413, 371, 520, 452, 520, 520, 455, + /* 2760 */ 520, 520, 458, 459, 460, 461, 462, 463, 520, 465, + /* 2770 */ 520, 520, 520, 520, 358, 520, 520, 520, 520, 520, + /* 2780 */ 520, 520, 399, 520, 520, 520, 520, 371, 520, 520, + /* 2790 */ 520, 520, 452, 520, 411, 455, 413, 520, 458, 459, + /* 2800 */ 460, 461, 462, 463, 520, 465, 520, 520, 520, 358, + /* 2810 */ 520, 520, 520, 520, 520, 399, 520, 520, 520, 520, + /* 2820 */ 520, 520, 371, 520, 520, 520, 520, 411, 520, 413, + /* 2830 */ 520, 520, 520, 520, 520, 452, 520, 520, 455, 520, + /* 2840 */ 520, 458, 459, 460, 461, 462, 463, 520, 465, 520, + /* 2850 */ 399, 520, 520, 520, 520, 520, 520, 520, 520, 520, + /* 2860 */ 520, 520, 411, 520, 413, 520, 520, 358, 452, 520, + /* 2870 */ 520, 455, 520, 520, 458, 459, 460, 461, 462, 463, + /* 2880 */ 371, 465, 358, 520, 520, 520, 520, 520, 520, 520, + /* 2890 */ 520, 520, 520, 520, 520, 371, 520, 520, 520, 520, + /* 2900 */ 520, 520, 520, 452, 520, 520, 455, 520, 399, 458, + /* 2910 */ 459, 460, 461, 462, 463, 520, 465, 520, 520, 520, + /* 2920 */ 411, 520, 413, 399, 520, 358, 520, 520, 520, 520, + /* 2930 */ 520, 520, 520, 520, 520, 411, 520, 413, 371, 520, + /* 2940 */ 520, 520, 520, 520, 520, 520, 520, 520, 520, 520, + /* 2950 */ 520, 520, 520, 520, 520, 520, 520, 520, 520, 520, + /* 2960 */ 520, 452, 520, 520, 455, 520, 399, 458, 459, 460, + /* 2970 */ 461, 462, 463, 520, 465, 520, 452, 520, 411, 455, + /* 2980 */ 413, 520, 458, 459, 460, 461, 462, 463, 520, 465, + /* 2990 */ 520, 520, 520, 520, 520, 520, 358, 520, 520, 520, + /* 3000 */ 520, 520, 520, 520, 520, 520, 520, 520, 520, 371, + /* 3010 */ 520, 520, 520, 520, 520, 520, 520, 520, 520, 452, + /* 3020 */ 358, 520, 455, 520, 520, 458, 459, 460, 461, 462, + /* 3030 */ 463, 520, 465, 371, 520, 520, 520, 399, 520, 520, + /* 3040 */ 520, 520, 520, 520, 520, 520, 520, 520, 520, 411, + /* 3050 */ 520, 413, 520, 520, 520, 520, 520, 520, 520, 520, + /* 3060 */ 520, 399, 520, 520, 520, 520, 520, 520, 520, 520, + /* 3070 */ 520, 520, 520, 411, 520, 413, 520, 520, 520, 520, + /* 3080 */ 520, 520, 520, 520, 520, 520, 520, 520, 520, 520, + /* 3090 */ 452, 520, 520, 455, 520, 520, 458, 459, 460, 461, + /* 3100 */ 462, 463, 520, 465, 520, 520, 520, 520, 520, 520, + /* 3110 */ 520, 520, 520, 358, 452, 520, 520, 455, 520, 520, + /* 3120 */ 458, 459, 460, 461, 462, 463, 371, 465, 358, 520, + /* 3130 */ 520, 520, 520, 520, 520, 520, 520, 520, 520, 520, + /* 3140 */ 520, 371, 520, 520, 520, 520, 520, 520, 520, 520, + /* 3150 */ 520, 520, 520, 520, 399, 520, 520, 520, 520, 520, + /* 3160 */ 520, 520, 520, 520, 520, 520, 411, 520, 413, 399, + /* 3170 */ 520, 520, 520, 520, 520, 520, 520, 520, 520, 520, + /* 3180 */ 520, 411, 520, 413, 520, 520, 520, 520, 520, 520, + /* 3190 */ 520, 520, 520, 520, 520, 520, 520, 520, 520, 520, + /* 3200 */ 520, 520, 520, 520, 520, 520, 520, 452, 520, 520, + /* 3210 */ 455, 520, 520, 458, 459, 460, 461, 462, 463, 520, + /* 3220 */ 465, 520, 452, 520, 520, 455, 520, 520, 458, 459, + /* 3230 */ 460, 461, 462, 463, 520, 465, 355, 355, 355, 355, + /* 3240 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3250 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3260 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3270 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3280 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3290 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3300 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3310 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3320 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3330 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3340 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3350 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3360 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3370 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3380 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3390 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3400 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3410 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3420 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3430 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3440 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3450 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3460 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3470 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3480 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3490 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3500 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3510 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3520 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3530 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3540 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3550 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3560 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3570 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3580 */ 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + /* 3590 */ 355, }; #define YY_SHIFT_COUNT (844) #define YY_SHIFT_MIN (0) -#define YY_SHIFT_MAX (2343) +#define YY_SHIFT_MAX (2373) static const unsigned short int yy_shift_ofst[] = { /* 0 */ 391, 0, 240, 0, 481, 481, 481, 481, 481, 481, /* 10 */ 481, 481, 481, 481, 481, 481, 721, 961, 961, 1201, /* 20 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961, /* 30 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961, /* 40 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961, - /* 50 */ 961, 263, 574, 633, 170, 185, 390, 185, 185, 170, - /* 60 */ 170, 185, 1351, 185, 239, 1351, 1351, 732, 185, 58, - /* 70 */ 45, 117, 117, 132, 132, 45, 367, 64, 93, 93, - /* 80 */ 625, 117, 117, 117, 117, 117, 117, 117, 117, 117, - /* 90 */ 117, 117, 213, 385, 117, 117, 438, 58, 117, 213, - /* 100 */ 117, 58, 117, 117, 58, 117, 117, 58, 117, 58, - /* 110 */ 58, 58, 117, 483, 439, 439, 441, 143, 815, 815, - /* 120 */ 815, 815, 815, 815, 815, 815, 815, 815, 815, 815, - /* 130 */ 815, 815, 815, 815, 815, 815, 815, 521, 179, 367, - /* 140 */ 64, 1122, 1122, 19, 1086, 1086, 1086, 273, 424, 424, - /* 150 */ 485, 19, 438, 456, 58, 58, 488, 58, 757, 58, - /* 160 */ 757, 757, 752, 990, 242, 242, 242, 242, 242, 242, - /* 170 */ 242, 242, 504, 215, 21, 478, 478, 46, 15, 311, - /* 180 */ 52, 110, 281, 261, 505, 882, 925, 640, 640, 295, - /* 190 */ 171, 430, 1010, 1010, 1010, 592, 1010, 893, 414, 643, - /* 200 */ 1133, 845, 605, 643, 643, 1028, 997, 997, 644, 1017, - /* 210 */ 899, 485, 1194, 1427, 1439, 1464, 1275, 438, 1464, 438, - /* 220 */ 1297, 1475, 1477, 1454, 1477, 1454, 1328, 1475, 1477, 1475, - /* 230 */ 1454, 1328, 1328, 1407, 1411, 1475, 1414, 1475, 1475, 1475, - /* 240 */ 1502, 1474, 1502, 1474, 1464, 438, 438, 1510, 438, 1515, - /* 250 */ 1516, 438, 1515, 438, 1520, 438, 438, 1475, 438, 1502, + /* 50 */ 961, 560, 716, 608, 93, 31, 398, 31, 31, 93, + /* 60 */ 93, 31, 1271, 31, 239, 1271, 1271, 676, 31, 58, + /* 70 */ 45, 177, 177, 132, 132, 45, 273, 64, 199, 199, + /* 80 */ 293, 177, 177, 177, 177, 177, 177, 177, 177, 177, + /* 90 */ 177, 177, 301, 740, 177, 177, 38, 58, 177, 301, + /* 100 */ 177, 58, 177, 177, 58, 177, 177, 58, 177, 58, + /* 110 */ 58, 58, 177, 565, 439, 439, 441, 143, 803, 803, + /* 120 */ 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, + /* 130 */ 803, 803, 803, 803, 803, 803, 803, 389, 744, 273, + /* 140 */ 64, 801, 801, 19, 395, 395, 395, 506, 192, 192, + /* 150 */ 982, 19, 38, 650, 58, 58, 603, 58, 826, 58, + /* 160 */ 826, 826, 936, 1134, 242, 242, 242, 242, 242, 242, + /* 170 */ 242, 242, 504, 215, 21, 46, 194, 194, 15, 519, + /* 180 */ 152, 399, 539, 157, 336, 202, 1081, 619, 619, 914, + /* 190 */ 1014, 958, 196, 196, 196, 722, 196, 774, 530, 1037, + /* 200 */ 367, 906, 388, 1037, 1037, 1098, 1203, 1203, 973, 1242, + /* 210 */ 996, 982, 1196, 1430, 1442, 1466, 1275, 38, 1466, 38, + /* 220 */ 1297, 1478, 1480, 1460, 1480, 1460, 1338, 1478, 1480, 1478, + /* 230 */ 1460, 1338, 1338, 1423, 1427, 1478, 1432, 1478, 1478, 1478, + /* 240 */ 1521, 1493, 1521, 1493, 1466, 38, 38, 1529, 38, 1541, + /* 250 */ 1546, 38, 1541, 38, 1555, 38, 38, 1478, 38, 1521, /* 260 */ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, - /* 270 */ 58, 1475, 990, 990, 1502, 757, 757, 757, 1330, 1460, - /* 280 */ 1464, 483, 1551, 1372, 1376, 1510, 483, 1194, 1475, 757, - /* 290 */ 1315, 1318, 1315, 1318, 1312, 1422, 1315, 1316, 1314, 1352, - /* 300 */ 1194, 1356, 1363, 1339, 1338, 1347, 1477, 1627, 1535, 1378, - /* 310 */ 1515, 483, 483, 1318, 757, 757, 757, 757, 1318, 757, - /* 320 */ 1496, 483, 752, 483, 1477, 1578, 1589, 757, 1475, 483, - /* 330 */ 1684, 1672, 1502, 3348, 3348, 3348, 3348, 3348, 3348, 3348, - /* 340 */ 3348, 3348, 36, 150, 63, 659, 777, 59, 920, 865, - /* 350 */ 413, 613, 807, 916, 674, 674, 674, 674, 674, 674, - /* 360 */ 674, 674, 674, 624, 363, 62, 693, 693, 403, 409, - /* 370 */ 270, 589, 979, 768, 796, 87, 786, 786, 1136, 1058, - /* 380 */ 604, 1136, 1136, 1136, 1241, 1084, 578, 1251, 1229, 1131, - /* 390 */ 1266, 1161, 1167, 1168, 1172, 622, 1259, 186, 1283, 1290, - /* 400 */ 1071, 1258, 1262, 1224, 1267, 1269, 1273, 1182, 1253, 1276, - /* 410 */ 1282, 1289, 1293, 1296, 1298, 1300, 1335, 1305, 1124, 1306, - /* 420 */ 1265, 1307, 1313, 1323, 1346, 1349, 1354, 805, 1257, 1274, - /* 430 */ 1357, 1379, 1320, 538, 1727, 1728, 1729, 1686, 1732, 1697, - /* 440 */ 1512, 1699, 1700, 1701, 1517, 1739, 1704, 1706, 1519, 1707, - /* 450 */ 1747, 1525, 1749, 1713, 1751, 1730, 1753, 1717, 1538, 1760, - /* 460 */ 1561, 1769, 1564, 1565, 1571, 1575, 1776, 1777, 1778, 1587, - /* 470 */ 1590, 1782, 1784, 1638, 1738, 1740, 1790, 1754, 1741, 1793, - /* 480 */ 1745, 1795, 1752, 1796, 1799, 1802, 1761, 1803, 1812, 1814, - /* 490 */ 1815, 1816, 1817, 1658, 1783, 1821, 1663, 1825, 1826, 1828, - /* 500 */ 1831, 1832, 1839, 1843, 1844, 1845, 1846, 1854, 1856, 1857, - /* 510 */ 1858, 1859, 1860, 1861, 1800, 1850, 1818, 1862, 1864, 1865, - /* 520 */ 1866, 1867, 1868, 1869, 1851, 1871, 1725, 1874, 1702, 1875, - /* 530 */ 1731, 1877, 1878, 1863, 1829, 1870, 1833, 1880, 1822, 1852, - /* 540 */ 1881, 1823, 1888, 1827, 1890, 1893, 1873, 1847, 1853, 1896, - /* 550 */ 1876, 1884, 1872, 1899, 1879, 1886, 1883, 1912, 1882, 1915, - /* 560 */ 1894, 1885, 1887, 1889, 1891, 1903, 1895, 1918, 1900, 1904, - /* 570 */ 1921, 1922, 1928, 1942, 1905, 1756, 1948, 1889, 1901, 1949, - /* 580 */ 1951, 1892, 1953, 1955, 1919, 1906, 1916, 1959, 1923, 1910, - /* 590 */ 1920, 1965, 1930, 1917, 1927, 1970, 1934, 1926, 1931, 1972, - /* 600 */ 1974, 1978, 1980, 1981, 1983, 1907, 1897, 1947, 1963, 1986, - /* 610 */ 1950, 1952, 1954, 1956, 1958, 1960, 1961, 1962, 1957, 1967, - /* 620 */ 1964, 1966, 1982, 1973, 1988, 1985, 2002, 1995, 1969, 2023, - /* 630 */ 2003, 1987, 2026, 2027, 2028, 1992, 2030, 1994, 2033, 2014, - /* 640 */ 2017, 2013, 2016, 2019, 1932, 1945, 2040, 1909, 1968, 1849, - /* 650 */ 1889, 2008, 2058, 1911, 2029, 2041, 2065, 1898, 2045, 1913, - /* 660 */ 1933, 2068, 2071, 1914, 1908, 1937, 1935, 2069, 2042, 1794, - /* 670 */ 1979, 1989, 1991, 2038, 1990, 2048, 1999, 2005, 2083, 2085, - /* 680 */ 2015, 2018, 2021, 2022, 2024, 2090, 2076, 2080, 2031, 2097, - /* 690 */ 1855, 2055, 2034, 2100, 2032, 2098, 2035, 2037, 2133, 2107, - /* 700 */ 1902, 2108, 2110, 2111, 2118, 2120, 2122, 2053, 2056, 2121, - /* 710 */ 1924, 2139, 2124, 2175, 2177, 2072, 2137, 2074, 2075, 2077, - /* 720 */ 2079, 2081, 2001, 2082, 2181, 2149, 2012, 2087, 2084, 1889, - /* 730 */ 2145, 2162, 2092, 1944, 2094, 2198, 2179, 1975, 2102, 2096, - /* 740 */ 2103, 2099, 2104, 2105, 2155, 2113, 2123, 2164, 2109, 2189, - /* 750 */ 1984, 2125, 2116, 2126, 2190, 2197, 2130, 2131, 2200, 2134, - /* 760 */ 2132, 2204, 2140, 2136, 2208, 2141, 2142, 2213, 2146, 2144, - /* 770 */ 2216, 2148, 2128, 2129, 2138, 2143, 2151, 2225, 2153, 2224, - /* 780 */ 2157, 2225, 2225, 2242, 2195, 2199, 2230, 2234, 2235, 2236, - /* 790 */ 2237, 2238, 2239, 2240, 2241, 2191, 2182, 2202, 2185, 2248, - /* 800 */ 2250, 2251, 2258, 2276, 2262, 2263, 2265, 2226, 1957, 2268, - /* 810 */ 1967, 2269, 2278, 2280, 2281, 2291, 2282, 2320, 2284, 2271, - /* 820 */ 2285, 2323, 2287, 2275, 2286, 2329, 2294, 2283, 2290, 2333, - /* 830 */ 2298, 2289, 2296, 2336, 2304, 2305, 2343, 2322, 2312, 2324, - /* 840 */ 2327, 2325, 2328, 2330, 2334, + /* 270 */ 58, 1478, 1134, 1134, 1521, 826, 826, 826, 1391, 1505, + /* 280 */ 1466, 565, 1603, 1420, 1422, 1529, 565, 1196, 1478, 826, + /* 290 */ 1351, 1355, 1351, 1355, 1341, 1452, 1351, 1346, 1364, 1382, + /* 300 */ 1196, 1369, 1395, 1367, 1373, 1378, 1480, 1669, 1579, 1417, + /* 310 */ 1541, 565, 565, 1355, 826, 826, 826, 826, 1355, 826, + /* 320 */ 1519, 565, 936, 565, 1480, 1612, 1619, 826, 1478, 565, + /* 330 */ 1704, 1689, 1521, 3236, 3236, 3236, 3236, 3236, 3236, 3236, + /* 340 */ 3236, 3236, 36, 150, 63, 320, 537, 59, 1035, 651, + /* 350 */ 613, 1113, 999, 693, 1237, 1237, 1237, 1237, 1237, 1237, + /* 360 */ 1237, 1237, 1237, 1047, 1012, 62, 933, 933, 643, 170, + /* 370 */ 830, 442, 1002, 747, 1061, 87, 549, 549, 555, 1025, + /* 380 */ 893, 555, 555, 555, 596, 1070, 1233, 1255, 1244, 572, + /* 390 */ 1267, 1176, 1186, 1187, 1202, 1268, 1289, 1324, 1328, 1331, + /* 400 */ 946, 1257, 1288, 1239, 1299, 1309, 1312, 1194, 790, 1078, + /* 410 */ 1316, 1319, 1323, 1327, 1347, 1349, 1337, 1350, 1190, 1353, + /* 420 */ 1252, 1354, 1357, 1365, 1385, 1425, 1429, 1251, 149, 1304, + /* 430 */ 1342, 1356, 1317, 1375, 1743, 1744, 1749, 1702, 1751, 1715, + /* 440 */ 1531, 1718, 1719, 1720, 1535, 1759, 1724, 1727, 1539, 1735, + /* 450 */ 1774, 1552, 1776, 1741, 1781, 1760, 1783, 1752, 1568, 1788, + /* 460 */ 1586, 1799, 1595, 1596, 1602, 1607, 1808, 1809, 1810, 1620, + /* 470 */ 1622, 1813, 1816, 1670, 1771, 1773, 1823, 1793, 1782, 1834, + /* 480 */ 1786, 1836, 1792, 1839, 1840, 1841, 1796, 1848, 1849, 1850, + /* 490 */ 1851, 1852, 1853, 1693, 1818, 1856, 1696, 1858, 1860, 1862, + /* 500 */ 1863, 1864, 1865, 1866, 1867, 1868, 1869, 1870, 1871, 1872, + /* 510 */ 1873, 1886, 1889, 1890, 1826, 1876, 1832, 1878, 1879, 1880, + /* 520 */ 1881, 1882, 1883, 1884, 1877, 1897, 1754, 1902, 1758, 1905, + /* 530 */ 1767, 1914, 1916, 1896, 1874, 1898, 1885, 1919, 1857, 1888, + /* 540 */ 1922, 1859, 1926, 1887, 1928, 1931, 1895, 1891, 1892, 1933, + /* 550 */ 1899, 1893, 1901, 1945, 1903, 1906, 1907, 1941, 1909, 1947, + /* 560 */ 1908, 1912, 1915, 1910, 1911, 1936, 1913, 1955, 1918, 1921, + /* 570 */ 1956, 1966, 1967, 1969, 1942, 1784, 1982, 1910, 1934, 1986, + /* 580 */ 1987, 1920, 1989, 1990, 1958, 1946, 1954, 1998, 1962, 1949, + /* 590 */ 1959, 2002, 1968, 1952, 1964, 2004, 1970, 1957, 1973, 2009, + /* 600 */ 2012, 2013, 2016, 2026, 2027, 1917, 1923, 1991, 2007, 2030, + /* 610 */ 1995, 1997, 2000, 2008, 2010, 2011, 2015, 2017, 2020, 2022, + /* 620 */ 2021, 2023, 2028, 2024, 2049, 2035, 2059, 2040, 2014, 2068, + /* 630 */ 2047, 2033, 2071, 2072, 2073, 2037, 2075, 2042, 2076, 2055, + /* 640 */ 2061, 2045, 2048, 2050, 1977, 1980, 2088, 1924, 1983, 1894, + /* 650 */ 1910, 2041, 2091, 1925, 2056, 2070, 2094, 1900, 2078, 1930, + /* 660 */ 1935, 2095, 2097, 1943, 1938, 1953, 1948, 2103, 2065, 1837, + /* 670 */ 2003, 2032, 2029, 2084, 2036, 2087, 2043, 2034, 2109, 2110, + /* 680 */ 2046, 2038, 2044, 2051, 2052, 2115, 2098, 2100, 2058, 2119, + /* 690 */ 1932, 2077, 2054, 2122, 2060, 2125, 2062, 2063, 2153, 2132, + /* 700 */ 1937, 2130, 2131, 2134, 2135, 2136, 2141, 2067, 2074, 2133, + /* 710 */ 1927, 2146, 2140, 2191, 2192, 2089, 2154, 2092, 2090, 2093, + /* 720 */ 2105, 2107, 2019, 2108, 2194, 2161, 2064, 2111, 2104, 1910, + /* 730 */ 2172, 2189, 2120, 1972, 2123, 2221, 2204, 1999, 2124, 2121, + /* 740 */ 2126, 2127, 2129, 2138, 2182, 2142, 2143, 2187, 2144, 2215, + /* 750 */ 2005, 2147, 2139, 2145, 2202, 2203, 2148, 2149, 2206, 2155, + /* 760 */ 2151, 2210, 2163, 2164, 2213, 2167, 2169, 2222, 2171, 2173, + /* 770 */ 2241, 2175, 2156, 2157, 2158, 2160, 2176, 2208, 2183, 2253, + /* 780 */ 2185, 2208, 2208, 2270, 2223, 2225, 2256, 2259, 2260, 2262, + /* 790 */ 2263, 2264, 2265, 2267, 2268, 2229, 2207, 2232, 2212, 2277, + /* 800 */ 2276, 2279, 2281, 2292, 2282, 2283, 2284, 2245, 2020, 2286, + /* 810 */ 2022, 2287, 2288, 2289, 2291, 2309, 2295, 2341, 2306, 2293, + /* 820 */ 2303, 2346, 2310, 2297, 2307, 2350, 2315, 2317, 2312, 2355, + /* 830 */ 2320, 2321, 2316, 2360, 2324, 2334, 2373, 2352, 2342, 2354, + /* 840 */ 2356, 2357, 2358, 2362, 2361, }; #define YY_REDUCE_COUNT (341) -#define YY_REDUCE_MIN (-477) -#define YY_REDUCE_MAX (2881) +#define YY_REDUCE_MIN (-476) +#define YY_REDUCE_MAX (2770) static const short yy_reduce_ofst[] = { - /* 0 */ 415, -315, 177, 383, 417, 617, 649, 857, 889, 1009, - /* 10 */ 1160, 1193, 1230, 1302, 1345, 1374, 1441, 1470, 1552, 1582, - /* 20 */ 1620, 1647, 1690, 1705, 1762, 1830, 1848, 1925, 1993, 2020, - /* 30 */ 2036, 2063, 2106, 2135, 2215, 2231, 2249, 2326, 2393, 2408, - /* 40 */ 2451, 2466, 2523, 2588, 2609, 2646, 2739, 2766, 2809, 2824, - /* 50 */ 2881, -290, 399, 432, -20, -231, 14, 82, 608, -218, - /* 60 */ 647, 656, -185, -477, -69, 392, 680, -176, 524, -390, - /* 70 */ 355, 39, 48, -366, -209, -328, -381, -334, -362, 183, - /* 80 */ -19, -365, -232, 366, 606, 431, 454, 616, 621, 623, - /* 90 */ 725, 566, 322, -115, 694, 763, 122, -66, 784, 495, - /* 100 */ 792, 386, 797, 846, 400, 848, 853, 486, 855, 628, - /* 110 */ 575, 634, 861, 193, 475, 475, -349, 152, -343, 302, - /* 120 */ 587, 663, 727, 730, 748, 758, 762, 772, 803, 818, - /* 130 */ 822, 823, 828, 830, 831, 863, 886, -129, -165, 44, - /* 140 */ 658, 722, 809, 864, -165, -100, 101, -181, 341, 436, - /* 150 */ -174, 868, 189, 832, -250, 251, 561, 33, 632, 743, - /* 160 */ 764, 847, 862, 905, -400, 553, 636, 926, 940, 946, - /* 170 */ 957, 940, 448, 970, 1001, 885, 885, 950, 871, 883, - /* 180 */ 907, 885, 1018, 897, 885, 1002, 1002, 1016, 1020, 981, - /* 190 */ 1040, 986, 910, 911, 912, 988, 917, 1002, 1050, 1004, - /* 200 */ 1054, 1023, 985, 1030, 1033, 1002, 968, 969, 951, 987, - /* 210 */ 973, 1074, 1041, 1024, 1029, 1038, 1037, 1110, 1044, 1112, - /* 220 */ 1056, 1125, 1126, 1079, 1129, 1081, 1087, 1135, 1132, 1137, - /* 230 */ 1088, 1089, 1092, 1128, 1134, 1143, 1138, 1145, 1147, 1150, - /* 240 */ 1159, 1157, 1162, 1163, 1080, 1148, 1149, 1119, 1154, 1164, - /* 250 */ 1101, 1165, 1166, 1170, 1113, 1173, 1174, 1171, 1176, 1179, - /* 260 */ 1144, 1146, 1158, 1169, 1175, 1177, 1178, 1183, 1184, 1185, - /* 270 */ 1186, 1188, 1195, 1199, 1198, 1151, 1152, 1155, 1097, 1121, - /* 280 */ 1140, 1190, 1127, 1181, 1189, 1180, 1210, 1156, 1219, 1191, - /* 290 */ 1091, 1187, 1108, 1197, 1107, 1116, 1114, 1130, 1141, 1139, - /* 300 */ 1192, 1153, 1196, 1142, 1204, 1200, 1278, 1202, 1203, 1206, - /* 310 */ 1292, 1285, 1291, 1237, 1256, 1260, 1261, 1263, 1246, 1268, - /* 320 */ 1252, 1301, 1286, 1303, 1325, 1211, 1284, 1288, 1334, 1331, - /* 330 */ 1350, 1355, 1348, 1280, 1277, 1295, 1299, 1321, 1327, 1329, - /* 340 */ 1343, 1367, + /* 0 */ 253, -314, 178, 384, 407, 617, 647, 857, 952, 1095, + /* 10 */ 1124, 1193, 1222, 1308, 1335, 1366, 477, 1433, 1448, 1516, + /* 20 */ 1559, 1581, 1652, 1667, 1725, 1747, 1805, 1875, 1904, 1940, + /* 30 */ 1971, 2039, 2057, 2114, 2137, 2152, 2209, 2247, 2266, 2304, + /* 40 */ 2340, 2383, 2416, 2451, 2509, 2524, 2567, 2638, 2662, 2755, + /* 50 */ 2770, -289, 261, 168, 432, -230, 83, 656, 666, -217, + /* 60 */ 446, 733, -184, -476, -68, -86, 522, 28, 410, -389, + /* 70 */ 116, -13, 40, -365, -208, -327, -380, -333, -361, -46, + /* 80 */ 290, -364, -231, 137, 140, 335, 338, 369, 403, 525, + /* 90 */ 609, 621, -162, 69, 614, 639, -93, 347, 652, -19, + /* 100 */ 665, 583, 683, 695, 155, 726, 743, 618, 764, 500, + /* 110 */ 657, 511, 864, -212, 105, 105, -348, -207, -342, -88, + /* 120 */ -31, -6, 463, 628, 663, 673, 728, 730, 762, 820, + /* 130 */ 821, 860, 862, 868, 871, 875, 881, 443, -141, 378, + /* 140 */ 387, 755, 776, 771, -141, 536, 686, 96, 310, 402, + /* 150 */ 47, 874, 447, 162, -123, 254, 414, 397, 467, 775, + /* 160 */ 829, 833, 869, 901, -399, 681, 794, 891, 959, 962, + /* 170 */ 967, 959, 834, 980, 1011, 937, 885, 885, 854, 866, + /* 180 */ 885, 889, 1015, 888, 885, 992, 992, 1005, 1009, 976, + /* 190 */ 1028, 978, 897, 899, 902, 988, 903, 992, 1051, 1031, + /* 200 */ 1088, 1053, 1024, 1043, 1046, 992, 983, 984, 964, 998, + /* 210 */ 985, 1090, 1045, 1029, 1032, 1041, 1038, 1111, 1050, 1112, + /* 220 */ 1060, 1129, 1132, 1087, 1138, 1091, 1093, 1142, 1143, 1152, + /* 230 */ 1104, 1108, 1109, 1145, 1148, 1161, 1153, 1168, 1169, 1170, + /* 240 */ 1179, 1177, 1182, 1181, 1100, 1173, 1180, 1149, 1184, 1197, + /* 250 */ 1137, 1189, 1198, 1195, 1150, 1199, 1209, 1211, 1212, 1227, + /* 260 */ 1200, 1204, 1206, 1208, 1210, 1213, 1214, 1215, 1216, 1217, + /* 270 */ 1218, 1225, 1236, 1241, 1235, 1207, 1219, 1220, 1160, 1171, + /* 280 */ 1174, 1245, 1183, 1191, 1185, 1223, 1249, 1205, 1259, 1221, + /* 290 */ 1139, 1228, 1144, 1230, 1147, 1146, 1151, 1162, 1165, 1172, + /* 300 */ 1232, 1224, 1188, 1154, 1175, 1178, 1315, 1234, 1226, 1231, + /* 310 */ 1325, 1326, 1332, 1272, 1291, 1293, 1294, 1300, 1279, 1301, + /* 320 */ 1285, 1339, 1320, 1340, 1343, 1247, 1329, 1318, 1358, 1359, + /* 330 */ 1370, 1371, 1368, 1295, 1292, 1310, 1311, 1345, 1352, 1360, + /* 340 */ 1372, 1386, }; static const YYACTIONTYPE yy_default[] = { - /* 0 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 10 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 20 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 30 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 40 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 50 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 60 */ 1915, 2248, 1915, 1915, 2211, 1915, 1915, 1915, 1915, 1915, - /* 70 */ 1915, 1915, 1915, 1915, 1915, 1915, 2218, 1915, 1915, 1915, - /* 80 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 90 */ 1915, 1915, 1915, 1915, 1915, 1915, 2012, 1915, 1915, 1915, - /* 100 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 110 */ 1915, 1915, 1915, 2010, 2450, 1915, 1915, 1915, 1915, 1915, - /* 120 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 130 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 2462, 1915, - /* 140 */ 1915, 1986, 1986, 1915, 2462, 2462, 2462, 2010, 2422, 2422, - /* 150 */ 1915, 1915, 2012, 2286, 1915, 1915, 1915, 1915, 1915, 1915, - /* 160 */ 1915, 1915, 2135, 1945, 1915, 1915, 1915, 1915, 2159, 1915, - /* 170 */ 1915, 1915, 2274, 1915, 1915, 2454, 2455, 2507, 2567, 1915, - /* 180 */ 2473, 2468, 1915, 2510, 2468, 1915, 1915, 1915, 1915, 2223, - /* 190 */ 1915, 2497, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 200 */ 1915, 2088, 2268, 1915, 1915, 1915, 1915, 1915, 2551, 2452, - /* 210 */ 2491, 1915, 2501, 1915, 2310, 1915, 2300, 2012, 1915, 2012, - /* 220 */ 2261, 2206, 1915, 2216, 1915, 2216, 2213, 1915, 1915, 1915, - /* 230 */ 2216, 2213, 2213, 2077, 2073, 1915, 2071, 1915, 1915, 1915, - /* 240 */ 1915, 1970, 1915, 1970, 1915, 2012, 2012, 1915, 2012, 1915, - /* 250 */ 1915, 2012, 1915, 2012, 1915, 2012, 2012, 1915, 2012, 1915, - /* 260 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 270 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 2298, 2284, - /* 280 */ 1915, 2010, 1915, 2272, 2270, 1915, 2010, 2501, 1915, 1915, - /* 290 */ 2521, 2516, 2521, 2516, 2535, 2531, 2521, 2540, 2537, 2503, - /* 300 */ 2501, 2484, 2480, 2570, 2557, 2553, 1915, 1915, 2489, 2487, - /* 310 */ 1915, 2010, 2010, 2516, 1915, 1915, 1915, 1915, 2516, 1915, - /* 320 */ 1915, 2010, 1915, 2010, 1915, 1915, 2104, 1915, 1915, 2010, - /* 330 */ 1915, 1954, 1915, 2263, 2289, 2244, 2244, 2138, 2138, 2138, - /* 340 */ 2013, 1920, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 350 */ 1915, 1915, 1915, 1915, 2534, 2533, 2375, 1915, 2426, 2425, - /* 360 */ 2424, 2415, 2374, 2100, 1915, 1915, 2373, 2372, 1915, 1915, - /* 370 */ 1915, 1915, 1915, 1915, 1915, 1915, 2235, 2234, 2366, 1915, - /* 380 */ 1915, 2367, 2365, 2364, 1915, 1915, 1915, 1915, 1915, 1915, - /* 390 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 400 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 2554, 2558, - /* 410 */ 1915, 1915, 1915, 1915, 1915, 1915, 2451, 1915, 1915, 1915, - /* 420 */ 2346, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 430 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 440 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 450 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 460 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 470 */ 1915, 1915, 1915, 2212, 1915, 1915, 1915, 1915, 1915, 1915, - /* 480 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 490 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 500 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 510 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 520 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 530 */ 2227, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 540 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 550 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 560 */ 1915, 1915, 1959, 2353, 1915, 1915, 1915, 1915, 1915, 1915, - /* 570 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 2356, 1915, 1915, - /* 580 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 590 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 600 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 610 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 2052, 2051, - /* 620 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 630 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 640 */ 1915, 1915, 1915, 1915, 2357, 1915, 1915, 1915, 1915, 1915, - /* 650 */ 2348, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 660 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 2550, 2504, 1915, - /* 670 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 680 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 2346, 1915, 2532, - /* 690 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 2548, 1915, 2552, - /* 700 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 2461, 2457, 1915, - /* 710 */ 1915, 2453, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 720 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 2345, - /* 730 */ 1915, 2412, 1915, 1915, 1915, 2446, 1915, 1915, 2397, 1915, - /* 740 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 2357, 1915, - /* 750 */ 2360, 1915, 1915, 1915, 1915, 1915, 2132, 1915, 1915, 1915, - /* 760 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 770 */ 1915, 1915, 2116, 2114, 2113, 2112, 1915, 2145, 1915, 1915, - /* 780 */ 1915, 2141, 2140, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 790 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 2031, - /* 800 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 2023, 1915, - /* 810 */ 2022, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 820 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, - /* 830 */ 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1944, 1915, - /* 840 */ 1915, 1915, 1915, 1915, 1915, + /* 0 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 10 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 20 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 30 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 40 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 50 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 60 */ 1913, 2246, 1913, 1913, 2209, 1913, 1913, 1913, 1913, 1913, + /* 70 */ 1913, 1913, 1913, 1913, 1913, 1913, 2216, 1913, 1913, 1913, + /* 80 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 90 */ 1913, 1913, 1913, 1913, 1913, 1913, 2010, 1913, 1913, 1913, + /* 100 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 110 */ 1913, 1913, 1913, 2008, 2448, 1913, 1913, 1913, 1913, 1913, + /* 120 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 130 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 2460, 1913, + /* 140 */ 1913, 1984, 1984, 1913, 2460, 2460, 2460, 2008, 2420, 2420, + /* 150 */ 1913, 1913, 2010, 2284, 1913, 1913, 1913, 1913, 1913, 1913, + /* 160 */ 1913, 1913, 2133, 1943, 1913, 1913, 1913, 1913, 2157, 1913, + /* 170 */ 1913, 1913, 2272, 1913, 1913, 2504, 2452, 2453, 2564, 1913, + /* 180 */ 2466, 2471, 1913, 2507, 2466, 1913, 1913, 1913, 1913, 2221, + /* 190 */ 1913, 2494, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 200 */ 1913, 2086, 2266, 1913, 1913, 1913, 1913, 1913, 2548, 2450, + /* 210 */ 2488, 1913, 2498, 1913, 2308, 1913, 2298, 2010, 1913, 2010, + /* 220 */ 2259, 2204, 1913, 2214, 1913, 2214, 2211, 1913, 1913, 1913, + /* 230 */ 2214, 2211, 2211, 2075, 2071, 1913, 2069, 1913, 1913, 1913, + /* 240 */ 1913, 1968, 1913, 1968, 1913, 2010, 2010, 1913, 2010, 1913, + /* 250 */ 1913, 2010, 1913, 2010, 1913, 2010, 2010, 1913, 2010, 1913, + /* 260 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 270 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 2296, 2282, + /* 280 */ 1913, 2008, 1913, 2270, 2268, 1913, 2008, 2498, 1913, 1913, + /* 290 */ 2518, 2513, 2518, 2513, 2532, 2528, 2518, 2537, 2534, 2500, + /* 300 */ 2498, 2481, 2477, 2567, 2554, 2550, 1913, 1913, 2486, 2484, + /* 310 */ 1913, 2008, 2008, 2513, 1913, 1913, 1913, 1913, 2513, 1913, + /* 320 */ 1913, 2008, 1913, 2008, 1913, 1913, 2102, 1913, 1913, 2008, + /* 330 */ 1913, 1952, 1913, 2261, 2287, 2242, 2242, 2136, 2136, 2136, + /* 340 */ 2011, 1918, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 350 */ 1913, 1913, 1913, 1913, 2531, 2530, 2373, 1913, 2424, 2423, + /* 360 */ 2422, 2413, 2372, 2098, 1913, 1913, 2371, 2370, 1913, 1913, + /* 370 */ 1913, 1913, 1913, 1913, 1913, 1913, 2233, 2232, 2364, 1913, + /* 380 */ 1913, 2365, 2363, 2362, 1913, 1913, 1913, 1913, 1913, 1913, + /* 390 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 400 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 2551, 2555, + /* 410 */ 1913, 1913, 1913, 1913, 1913, 1913, 2449, 1913, 1913, 1913, + /* 420 */ 2344, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 430 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 440 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 450 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 460 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 470 */ 1913, 1913, 1913, 2210, 1913, 1913, 1913, 1913, 1913, 1913, + /* 480 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 490 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 500 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 510 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 520 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 530 */ 2225, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 540 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 550 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 560 */ 1913, 1913, 1957, 2351, 1913, 1913, 1913, 1913, 1913, 1913, + /* 570 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 2354, 1913, 1913, + /* 580 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 590 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 600 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 610 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 2050, 2049, + /* 620 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 630 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 640 */ 1913, 1913, 1913, 1913, 2355, 1913, 1913, 1913, 1913, 1913, + /* 650 */ 2346, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 660 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 2547, 2501, 1913, + /* 670 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 680 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 2344, 1913, 2529, + /* 690 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 2545, 1913, 2549, + /* 700 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 2459, 2455, 1913, + /* 710 */ 1913, 2451, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 720 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 2343, + /* 730 */ 1913, 2410, 1913, 1913, 1913, 2444, 1913, 1913, 2395, 1913, + /* 740 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 2355, 1913, + /* 750 */ 2358, 1913, 1913, 1913, 1913, 1913, 2130, 1913, 1913, 1913, + /* 760 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 770 */ 1913, 1913, 2114, 2112, 2111, 2110, 1913, 2143, 1913, 1913, + /* 780 */ 1913, 2139, 2138, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 790 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 2029, + /* 800 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 2021, 1913, + /* 810 */ 2020, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 820 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, + /* 830 */ 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1913, 1942, 1913, + /* 840 */ 1913, 1913, 1913, 1913, 1913, }; /********** End of lemon-generated parsing tables *****************************/ @@ -1271,7 +1249,7 @@ static const YYCODETYPE yyFallback[] = { 0, /* BWLIMIT => nothing */ 0, /* START => nothing */ 0, /* TIMESTAMP => nothing */ - 307, /* END => ABORT */ + 306, /* END => ABORT */ 0, /* TABLE => nothing */ 0, /* NK_LP => nothing */ 0, /* NK_RP => nothing */ @@ -1339,7 +1317,7 @@ static const YYCODETYPE yyFallback[] = { 0, /* VNODES => nothing */ 0, /* ALIVE => nothing */ 0, /* VIEWS => nothing */ - 307, /* VIEW => ABORT */ + 306, /* VIEW => ABORT */ 0, /* NORMAL => nothing */ 0, /* CHILD => nothing */ 0, /* LIKE => nothing */ @@ -1439,9 +1417,8 @@ static const YYCODETYPE yyFallback[] = { 0, /* RIGHT => nothing */ 0, /* FULL => nothing */ 0, /* OUTER => nothing */ - 307, /* SEMI => ABORT */ + 306, /* SEMI => ABORT */ 0, /* ANTI => nothing */ - 0, /* ANY => nothing */ 0, /* ASOF => nothing */ 0, /* WINDOW => nothing */ 0, /* WINDOW_OFFSET => nothing */ @@ -1475,54 +1452,54 @@ static const YYCODETYPE yyFallback[] = { 0, /* ASC => nothing */ 0, /* NULLS => nothing */ 0, /* ABORT => nothing */ - 307, /* AFTER => ABORT */ - 307, /* ATTACH => ABORT */ - 307, /* BEFORE => ABORT */ - 307, /* BEGIN => ABORT */ - 307, /* BITAND => ABORT */ - 307, /* BITNOT => ABORT */ - 307, /* BITOR => ABORT */ - 307, /* BLOCKS => ABORT */ - 307, /* CHANGE => ABORT */ - 307, /* COMMA => ABORT */ - 307, /* CONCAT => ABORT */ - 307, /* CONFLICT => ABORT */ - 307, /* COPY => ABORT */ - 307, /* DEFERRED => ABORT */ - 307, /* DELIMITERS => ABORT */ - 307, /* DETACH => ABORT */ - 307, /* DIVIDE => ABORT */ - 307, /* DOT => ABORT */ - 307, /* EACH => ABORT */ - 307, /* FAIL => ABORT */ - 307, /* FILE => ABORT */ - 307, /* FOR => ABORT */ - 307, /* GLOB => ABORT */ - 307, /* ID => ABORT */ - 307, /* IMMEDIATE => ABORT */ - 307, /* IMPORT => ABORT */ - 307, /* INITIALLY => ABORT */ - 307, /* INSTEAD => ABORT */ - 307, /* ISNULL => ABORT */ - 307, /* KEY => ABORT */ - 307, /* MODULES => ABORT */ - 307, /* NK_BITNOT => ABORT */ - 307, /* NK_SEMI => ABORT */ - 307, /* NOTNULL => ABORT */ - 307, /* OF => ABORT */ - 307, /* PLUS => ABORT */ - 307, /* PRIVILEGE => ABORT */ - 307, /* RAISE => ABORT */ - 307, /* RESTRICT => ABORT */ - 307, /* ROW => ABORT */ - 307, /* STAR => ABORT */ - 307, /* STATEMENT => ABORT */ - 307, /* STRICT => ABORT */ - 307, /* STRING => ABORT */ - 307, /* TIMES => ABORT */ - 307, /* VALUES => ABORT */ - 307, /* VARIABLE => ABORT */ - 307, /* WAL => ABORT */ + 306, /* AFTER => ABORT */ + 306, /* ATTACH => ABORT */ + 306, /* BEFORE => ABORT */ + 306, /* BEGIN => ABORT */ + 306, /* BITAND => ABORT */ + 306, /* BITNOT => ABORT */ + 306, /* BITOR => ABORT */ + 306, /* BLOCKS => ABORT */ + 306, /* CHANGE => ABORT */ + 306, /* COMMA => ABORT */ + 306, /* CONCAT => ABORT */ + 306, /* CONFLICT => ABORT */ + 306, /* COPY => ABORT */ + 306, /* DEFERRED => ABORT */ + 306, /* DELIMITERS => ABORT */ + 306, /* DETACH => ABORT */ + 306, /* DIVIDE => ABORT */ + 306, /* DOT => ABORT */ + 306, /* EACH => ABORT */ + 306, /* FAIL => ABORT */ + 306, /* FILE => ABORT */ + 306, /* FOR => ABORT */ + 306, /* GLOB => ABORT */ + 306, /* ID => ABORT */ + 306, /* IMMEDIATE => ABORT */ + 306, /* IMPORT => ABORT */ + 306, /* INITIALLY => ABORT */ + 306, /* INSTEAD => ABORT */ + 306, /* ISNULL => ABORT */ + 306, /* KEY => ABORT */ + 306, /* MODULES => ABORT */ + 306, /* NK_BITNOT => ABORT */ + 306, /* NK_SEMI => ABORT */ + 306, /* NOTNULL => ABORT */ + 306, /* OF => ABORT */ + 306, /* PLUS => ABORT */ + 306, /* PRIVILEGE => ABORT */ + 306, /* RAISE => ABORT */ + 306, /* RESTRICT => ABORT */ + 306, /* ROW => ABORT */ + 306, /* STAR => ABORT */ + 306, /* STATEMENT => ABORT */ + 306, /* STRICT => ABORT */ + 306, /* STRING => ABORT */ + 306, /* TIMES => ABORT */ + 306, /* VALUES => ABORT */ + 306, /* VARIABLE => ABORT */ + 306, /* WAL => ABORT */ }; #endif /* YYFALLBACK */ @@ -1884,253 +1861,252 @@ static const char *const yyTokenName[] = { /* 271 */ "OUTER", /* 272 */ "SEMI", /* 273 */ "ANTI", - /* 274 */ "ANY", - /* 275 */ "ASOF", - /* 276 */ "WINDOW", - /* 277 */ "WINDOW_OFFSET", - /* 278 */ "JLIMIT", - /* 279 */ "SELECT", - /* 280 */ "NK_HINT", - /* 281 */ "DISTINCT", - /* 282 */ "WHERE", - /* 283 */ "PARTITION", - /* 284 */ "BY", - /* 285 */ "SESSION", - /* 286 */ "STATE_WINDOW", - /* 287 */ "EVENT_WINDOW", - /* 288 */ "SLIDING", - /* 289 */ "FILL", - /* 290 */ "VALUE", - /* 291 */ "VALUE_F", - /* 292 */ "NONE", - /* 293 */ "PREV", - /* 294 */ "NULL_F", - /* 295 */ "LINEAR", - /* 296 */ "NEXT", - /* 297 */ "HAVING", - /* 298 */ "RANGE", - /* 299 */ "EVERY", - /* 300 */ "ORDER", - /* 301 */ "SLIMIT", - /* 302 */ "SOFFSET", - /* 303 */ "LIMIT", - /* 304 */ "OFFSET", - /* 305 */ "ASC", - /* 306 */ "NULLS", - /* 307 */ "ABORT", - /* 308 */ "AFTER", - /* 309 */ "ATTACH", - /* 310 */ "BEFORE", - /* 311 */ "BEGIN", - /* 312 */ "BITAND", - /* 313 */ "BITNOT", - /* 314 */ "BITOR", - /* 315 */ "BLOCKS", - /* 316 */ "CHANGE", - /* 317 */ "COMMA", - /* 318 */ "CONCAT", - /* 319 */ "CONFLICT", - /* 320 */ "COPY", - /* 321 */ "DEFERRED", - /* 322 */ "DELIMITERS", - /* 323 */ "DETACH", - /* 324 */ "DIVIDE", - /* 325 */ "DOT", - /* 326 */ "EACH", - /* 327 */ "FAIL", - /* 328 */ "FILE", - /* 329 */ "FOR", - /* 330 */ "GLOB", - /* 331 */ "ID", - /* 332 */ "IMMEDIATE", - /* 333 */ "IMPORT", - /* 334 */ "INITIALLY", - /* 335 */ "INSTEAD", - /* 336 */ "ISNULL", - /* 337 */ "KEY", - /* 338 */ "MODULES", - /* 339 */ "NK_BITNOT", - /* 340 */ "NK_SEMI", - /* 341 */ "NOTNULL", - /* 342 */ "OF", - /* 343 */ "PLUS", - /* 344 */ "PRIVILEGE", - /* 345 */ "RAISE", - /* 346 */ "RESTRICT", - /* 347 */ "ROW", - /* 348 */ "STAR", - /* 349 */ "STATEMENT", - /* 350 */ "STRICT", - /* 351 */ "STRING", - /* 352 */ "TIMES", - /* 353 */ "VALUES", - /* 354 */ "VARIABLE", - /* 355 */ "WAL", - /* 356 */ "cmd", - /* 357 */ "account_options", - /* 358 */ "alter_account_options", - /* 359 */ "literal", - /* 360 */ "alter_account_option", - /* 361 */ "ip_range_list", - /* 362 */ "white_list", - /* 363 */ "white_list_opt", - /* 364 */ "user_name", - /* 365 */ "sysinfo_opt", - /* 366 */ "privileges", - /* 367 */ "priv_level", - /* 368 */ "with_opt", - /* 369 */ "priv_type_list", - /* 370 */ "priv_type", - /* 371 */ "db_name", - /* 372 */ "table_name", - /* 373 */ "topic_name", - /* 374 */ "search_condition", - /* 375 */ "dnode_endpoint", - /* 376 */ "force_opt", - /* 377 */ "unsafe_opt", - /* 378 */ "not_exists_opt", - /* 379 */ "db_options", - /* 380 */ "exists_opt", - /* 381 */ "alter_db_options", - /* 382 */ "speed_opt", - /* 383 */ "start_opt", - /* 384 */ "end_opt", - /* 385 */ "integer_list", - /* 386 */ "variable_list", - /* 387 */ "retention_list", - /* 388 */ "signed", - /* 389 */ "alter_db_option", - /* 390 */ "retention", - /* 391 */ "full_table_name", - /* 392 */ "column_def_list", - /* 393 */ "tags_def_opt", - /* 394 */ "table_options", - /* 395 */ "multi_create_clause", - /* 396 */ "tags_def", - /* 397 */ "multi_drop_clause", - /* 398 */ "alter_table_clause", - /* 399 */ "alter_table_options", - /* 400 */ "column_name", - /* 401 */ "type_name", - /* 402 */ "signed_literal", - /* 403 */ "create_subtable_clause", - /* 404 */ "specific_cols_opt", - /* 405 */ "expression_list", - /* 406 */ "drop_table_clause", - /* 407 */ "col_name_list", - /* 408 */ "column_def", - /* 409 */ "duration_list", - /* 410 */ "rollup_func_list", - /* 411 */ "alter_table_option", - /* 412 */ "duration_literal", - /* 413 */ "rollup_func_name", - /* 414 */ "function_name", - /* 415 */ "col_name", - /* 416 */ "db_kind_opt", - /* 417 */ "table_kind_db_name_cond_opt", - /* 418 */ "like_pattern_opt", - /* 419 */ "db_name_cond_opt", - /* 420 */ "table_name_cond", - /* 421 */ "from_db_opt", - /* 422 */ "tag_list_opt", - /* 423 */ "table_kind", - /* 424 */ "tag_item", - /* 425 */ "column_alias", - /* 426 */ "index_options", - /* 427 */ "full_index_name", - /* 428 */ "index_name", - /* 429 */ "func_list", - /* 430 */ "sliding_opt", - /* 431 */ "sma_stream_opt", - /* 432 */ "func", - /* 433 */ "sma_func_name", - /* 434 */ "with_meta", - /* 435 */ "query_or_subquery", - /* 436 */ "where_clause_opt", - /* 437 */ "cgroup_name", - /* 438 */ "analyze_opt", - /* 439 */ "explain_options", - /* 440 */ "insert_query", - /* 441 */ "or_replace_opt", - /* 442 */ "agg_func_opt", - /* 443 */ "bufsize_opt", - /* 444 */ "language_opt", - /* 445 */ "full_view_name", - /* 446 */ "view_name", - /* 447 */ "stream_name", - /* 448 */ "stream_options", - /* 449 */ "col_list_opt", - /* 450 */ "tag_def_or_ref_opt", - /* 451 */ "subtable_opt", - /* 452 */ "ignore_opt", - /* 453 */ "expression", - /* 454 */ "on_vgroup_id", - /* 455 */ "dnode_list", - /* 456 */ "literal_func", - /* 457 */ "literal_list", - /* 458 */ "table_alias", - /* 459 */ "expr_or_subquery", - /* 460 */ "pseudo_column", - /* 461 */ "column_reference", - /* 462 */ "function_expression", - /* 463 */ "case_when_expression", - /* 464 */ "star_func", - /* 465 */ "star_func_para_list", - /* 466 */ "noarg_func", - /* 467 */ "other_para_list", - /* 468 */ "star_func_para", - /* 469 */ "when_then_list", - /* 470 */ "case_when_else_opt", - /* 471 */ "common_expression", - /* 472 */ "when_then_expr", - /* 473 */ "predicate", - /* 474 */ "compare_op", - /* 475 */ "in_op", - /* 476 */ "in_predicate_value", - /* 477 */ "boolean_value_expression", - /* 478 */ "boolean_primary", - /* 479 */ "from_clause_opt", - /* 480 */ "table_reference_list", - /* 481 */ "table_reference", - /* 482 */ "table_primary", - /* 483 */ "joined_table", - /* 484 */ "alias_opt", - /* 485 */ "subquery", - /* 486 */ "parenthesized_joined_table", - /* 487 */ "join_type", - /* 488 */ "join_subtype", - /* 489 */ "window_offset_clause_opt", - /* 490 */ "jlimit_clause_opt", - /* 491 */ "window_offset_literal", - /* 492 */ "query_specification", - /* 493 */ "hint_list", - /* 494 */ "set_quantifier_opt", - /* 495 */ "tag_mode_opt", - /* 496 */ "select_list", - /* 497 */ "partition_by_clause_opt", - /* 498 */ "range_opt", - /* 499 */ "every_opt", - /* 500 */ "fill_opt", - /* 501 */ "twindow_clause_opt", - /* 502 */ "group_by_clause_opt", - /* 503 */ "having_clause_opt", - /* 504 */ "select_item", - /* 505 */ "partition_list", - /* 506 */ "partition_item", - /* 507 */ "interval_sliding_duration_literal", - /* 508 */ "fill_mode", - /* 509 */ "group_by_list", - /* 510 */ "query_expression", - /* 511 */ "query_simple", - /* 512 */ "order_by_clause_opt", - /* 513 */ "slimit_clause_opt", - /* 514 */ "limit_clause_opt", - /* 515 */ "union_query_expression", - /* 516 */ "query_simple_or_subquery", - /* 517 */ "sort_specification_list", - /* 518 */ "sort_specification", - /* 519 */ "ordering_specification_opt", - /* 520 */ "null_ordering_opt", + /* 274 */ "ASOF", + /* 275 */ "WINDOW", + /* 276 */ "WINDOW_OFFSET", + /* 277 */ "JLIMIT", + /* 278 */ "SELECT", + /* 279 */ "NK_HINT", + /* 280 */ "DISTINCT", + /* 281 */ "WHERE", + /* 282 */ "PARTITION", + /* 283 */ "BY", + /* 284 */ "SESSION", + /* 285 */ "STATE_WINDOW", + /* 286 */ "EVENT_WINDOW", + /* 287 */ "SLIDING", + /* 288 */ "FILL", + /* 289 */ "VALUE", + /* 290 */ "VALUE_F", + /* 291 */ "NONE", + /* 292 */ "PREV", + /* 293 */ "NULL_F", + /* 294 */ "LINEAR", + /* 295 */ "NEXT", + /* 296 */ "HAVING", + /* 297 */ "RANGE", + /* 298 */ "EVERY", + /* 299 */ "ORDER", + /* 300 */ "SLIMIT", + /* 301 */ "SOFFSET", + /* 302 */ "LIMIT", + /* 303 */ "OFFSET", + /* 304 */ "ASC", + /* 305 */ "NULLS", + /* 306 */ "ABORT", + /* 307 */ "AFTER", + /* 308 */ "ATTACH", + /* 309 */ "BEFORE", + /* 310 */ "BEGIN", + /* 311 */ "BITAND", + /* 312 */ "BITNOT", + /* 313 */ "BITOR", + /* 314 */ "BLOCKS", + /* 315 */ "CHANGE", + /* 316 */ "COMMA", + /* 317 */ "CONCAT", + /* 318 */ "CONFLICT", + /* 319 */ "COPY", + /* 320 */ "DEFERRED", + /* 321 */ "DELIMITERS", + /* 322 */ "DETACH", + /* 323 */ "DIVIDE", + /* 324 */ "DOT", + /* 325 */ "EACH", + /* 326 */ "FAIL", + /* 327 */ "FILE", + /* 328 */ "FOR", + /* 329 */ "GLOB", + /* 330 */ "ID", + /* 331 */ "IMMEDIATE", + /* 332 */ "IMPORT", + /* 333 */ "INITIALLY", + /* 334 */ "INSTEAD", + /* 335 */ "ISNULL", + /* 336 */ "KEY", + /* 337 */ "MODULES", + /* 338 */ "NK_BITNOT", + /* 339 */ "NK_SEMI", + /* 340 */ "NOTNULL", + /* 341 */ "OF", + /* 342 */ "PLUS", + /* 343 */ "PRIVILEGE", + /* 344 */ "RAISE", + /* 345 */ "RESTRICT", + /* 346 */ "ROW", + /* 347 */ "STAR", + /* 348 */ "STATEMENT", + /* 349 */ "STRICT", + /* 350 */ "STRING", + /* 351 */ "TIMES", + /* 352 */ "VALUES", + /* 353 */ "VARIABLE", + /* 354 */ "WAL", + /* 355 */ "cmd", + /* 356 */ "account_options", + /* 357 */ "alter_account_options", + /* 358 */ "literal", + /* 359 */ "alter_account_option", + /* 360 */ "ip_range_list", + /* 361 */ "white_list", + /* 362 */ "white_list_opt", + /* 363 */ "user_name", + /* 364 */ "sysinfo_opt", + /* 365 */ "privileges", + /* 366 */ "priv_level", + /* 367 */ "with_opt", + /* 368 */ "priv_type_list", + /* 369 */ "priv_type", + /* 370 */ "db_name", + /* 371 */ "table_name", + /* 372 */ "topic_name", + /* 373 */ "search_condition", + /* 374 */ "dnode_endpoint", + /* 375 */ "force_opt", + /* 376 */ "unsafe_opt", + /* 377 */ "not_exists_opt", + /* 378 */ "db_options", + /* 379 */ "exists_opt", + /* 380 */ "alter_db_options", + /* 381 */ "speed_opt", + /* 382 */ "start_opt", + /* 383 */ "end_opt", + /* 384 */ "integer_list", + /* 385 */ "variable_list", + /* 386 */ "retention_list", + /* 387 */ "signed", + /* 388 */ "alter_db_option", + /* 389 */ "retention", + /* 390 */ "full_table_name", + /* 391 */ "column_def_list", + /* 392 */ "tags_def_opt", + /* 393 */ "table_options", + /* 394 */ "multi_create_clause", + /* 395 */ "tags_def", + /* 396 */ "multi_drop_clause", + /* 397 */ "alter_table_clause", + /* 398 */ "alter_table_options", + /* 399 */ "column_name", + /* 400 */ "type_name", + /* 401 */ "signed_literal", + /* 402 */ "create_subtable_clause", + /* 403 */ "specific_cols_opt", + /* 404 */ "expression_list", + /* 405 */ "drop_table_clause", + /* 406 */ "col_name_list", + /* 407 */ "column_def", + /* 408 */ "duration_list", + /* 409 */ "rollup_func_list", + /* 410 */ "alter_table_option", + /* 411 */ "duration_literal", + /* 412 */ "rollup_func_name", + /* 413 */ "function_name", + /* 414 */ "col_name", + /* 415 */ "db_kind_opt", + /* 416 */ "table_kind_db_name_cond_opt", + /* 417 */ "like_pattern_opt", + /* 418 */ "db_name_cond_opt", + /* 419 */ "table_name_cond", + /* 420 */ "from_db_opt", + /* 421 */ "tag_list_opt", + /* 422 */ "table_kind", + /* 423 */ "tag_item", + /* 424 */ "column_alias", + /* 425 */ "index_options", + /* 426 */ "full_index_name", + /* 427 */ "index_name", + /* 428 */ "func_list", + /* 429 */ "sliding_opt", + /* 430 */ "sma_stream_opt", + /* 431 */ "func", + /* 432 */ "sma_func_name", + /* 433 */ "with_meta", + /* 434 */ "query_or_subquery", + /* 435 */ "where_clause_opt", + /* 436 */ "cgroup_name", + /* 437 */ "analyze_opt", + /* 438 */ "explain_options", + /* 439 */ "insert_query", + /* 440 */ "or_replace_opt", + /* 441 */ "agg_func_opt", + /* 442 */ "bufsize_opt", + /* 443 */ "language_opt", + /* 444 */ "full_view_name", + /* 445 */ "view_name", + /* 446 */ "stream_name", + /* 447 */ "stream_options", + /* 448 */ "col_list_opt", + /* 449 */ "tag_def_or_ref_opt", + /* 450 */ "subtable_opt", + /* 451 */ "ignore_opt", + /* 452 */ "expression", + /* 453 */ "on_vgroup_id", + /* 454 */ "dnode_list", + /* 455 */ "literal_func", + /* 456 */ "literal_list", + /* 457 */ "table_alias", + /* 458 */ "expr_or_subquery", + /* 459 */ "pseudo_column", + /* 460 */ "column_reference", + /* 461 */ "function_expression", + /* 462 */ "case_when_expression", + /* 463 */ "star_func", + /* 464 */ "star_func_para_list", + /* 465 */ "noarg_func", + /* 466 */ "other_para_list", + /* 467 */ "star_func_para", + /* 468 */ "when_then_list", + /* 469 */ "case_when_else_opt", + /* 470 */ "common_expression", + /* 471 */ "when_then_expr", + /* 472 */ "predicate", + /* 473 */ "compare_op", + /* 474 */ "in_op", + /* 475 */ "in_predicate_value", + /* 476 */ "boolean_value_expression", + /* 477 */ "boolean_primary", + /* 478 */ "from_clause_opt", + /* 479 */ "table_reference_list", + /* 480 */ "table_reference", + /* 481 */ "table_primary", + /* 482 */ "joined_table", + /* 483 */ "alias_opt", + /* 484 */ "subquery", + /* 485 */ "parenthesized_joined_table", + /* 486 */ "join_type", + /* 487 */ "join_subtype", + /* 488 */ "window_offset_clause_opt", + /* 489 */ "jlimit_clause_opt", + /* 490 */ "window_offset_literal", + /* 491 */ "query_specification", + /* 492 */ "hint_list", + /* 493 */ "set_quantifier_opt", + /* 494 */ "tag_mode_opt", + /* 495 */ "select_list", + /* 496 */ "partition_by_clause_opt", + /* 497 */ "range_opt", + /* 498 */ "every_opt", + /* 499 */ "fill_opt", + /* 500 */ "twindow_clause_opt", + /* 501 */ "group_by_clause_opt", + /* 502 */ "having_clause_opt", + /* 503 */ "select_item", + /* 504 */ "partition_list", + /* 505 */ "partition_item", + /* 506 */ "interval_sliding_duration_literal", + /* 507 */ "fill_mode", + /* 508 */ "group_by_list", + /* 509 */ "query_expression", + /* 510 */ "query_simple", + /* 511 */ "order_by_clause_opt", + /* 512 */ "slimit_clause_opt", + /* 513 */ "limit_clause_opt", + /* 514 */ "union_query_expression", + /* 515 */ "query_simple_or_subquery", + /* 516 */ "sort_specification_list", + /* 517 */ "sort_specification", + /* 518 */ "ordering_specification_opt", + /* 519 */ "null_ordering_opt", }; #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */ @@ -2697,102 +2673,101 @@ static const char *const yyRuleName[] = { /* 556 */ "join_subtype ::= OUTER", /* 557 */ "join_subtype ::= SEMI", /* 558 */ "join_subtype ::= ANTI", - /* 559 */ "join_subtype ::= ANY", - /* 560 */ "join_subtype ::= ASOF", - /* 561 */ "join_subtype ::= WINDOW", - /* 562 */ "window_offset_clause_opt ::=", - /* 563 */ "window_offset_clause_opt ::= WINDOW_OFFSET NK_LP window_offset_literal NK_COMMA window_offset_literal NK_RP", - /* 564 */ "window_offset_literal ::= NK_VARIABLE", - /* 565 */ "window_offset_literal ::= NK_MINUS NK_VARIABLE", - /* 566 */ "jlimit_clause_opt ::=", - /* 567 */ "jlimit_clause_opt ::= JLIMIT NK_INTEGER", - /* 568 */ "query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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", - /* 569 */ "hint_list ::=", - /* 570 */ "hint_list ::= NK_HINT", - /* 571 */ "tag_mode_opt ::=", - /* 572 */ "tag_mode_opt ::= TAGS", - /* 573 */ "set_quantifier_opt ::=", - /* 574 */ "set_quantifier_opt ::= DISTINCT", - /* 575 */ "set_quantifier_opt ::= ALL", - /* 576 */ "select_list ::= select_item", - /* 577 */ "select_list ::= select_list NK_COMMA select_item", - /* 578 */ "select_item ::= NK_STAR", - /* 579 */ "select_item ::= common_expression", - /* 580 */ "select_item ::= common_expression column_alias", - /* 581 */ "select_item ::= common_expression AS column_alias", - /* 582 */ "select_item ::= table_name NK_DOT NK_STAR", - /* 583 */ "where_clause_opt ::=", - /* 584 */ "where_clause_opt ::= WHERE search_condition", - /* 585 */ "partition_by_clause_opt ::=", - /* 586 */ "partition_by_clause_opt ::= PARTITION BY partition_list", - /* 587 */ "partition_list ::= partition_item", - /* 588 */ "partition_list ::= partition_list NK_COMMA partition_item", - /* 589 */ "partition_item ::= expr_or_subquery", - /* 590 */ "partition_item ::= expr_or_subquery column_alias", - /* 591 */ "partition_item ::= expr_or_subquery AS column_alias", - /* 592 */ "twindow_clause_opt ::=", - /* 593 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP", - /* 594 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP", - /* 595 */ "twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt", - /* 596 */ "twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt", - /* 597 */ "twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition", - /* 598 */ "sliding_opt ::=", - /* 599 */ "sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP", - /* 600 */ "interval_sliding_duration_literal ::= NK_VARIABLE", - /* 601 */ "interval_sliding_duration_literal ::= NK_STRING", - /* 602 */ "interval_sliding_duration_literal ::= NK_INTEGER", - /* 603 */ "fill_opt ::=", - /* 604 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", - /* 605 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP", - /* 606 */ "fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP", - /* 607 */ "fill_mode ::= NONE", - /* 608 */ "fill_mode ::= PREV", - /* 609 */ "fill_mode ::= NULL", - /* 610 */ "fill_mode ::= NULL_F", - /* 611 */ "fill_mode ::= LINEAR", - /* 612 */ "fill_mode ::= NEXT", - /* 613 */ "group_by_clause_opt ::=", - /* 614 */ "group_by_clause_opt ::= GROUP BY group_by_list", - /* 615 */ "group_by_list ::= expr_or_subquery", - /* 616 */ "group_by_list ::= group_by_list NK_COMMA expr_or_subquery", - /* 617 */ "having_clause_opt ::=", - /* 618 */ "having_clause_opt ::= HAVING search_condition", - /* 619 */ "range_opt ::=", - /* 620 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP", - /* 621 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_RP", - /* 622 */ "every_opt ::=", - /* 623 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP", - /* 624 */ "query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt", - /* 625 */ "query_simple ::= query_specification", - /* 626 */ "query_simple ::= union_query_expression", - /* 627 */ "union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery", - /* 628 */ "union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery", - /* 629 */ "query_simple_or_subquery ::= query_simple", - /* 630 */ "query_simple_or_subquery ::= subquery", - /* 631 */ "query_or_subquery ::= query_expression", - /* 632 */ "query_or_subquery ::= subquery", - /* 633 */ "order_by_clause_opt ::=", - /* 634 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", - /* 635 */ "slimit_clause_opt ::=", - /* 636 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", - /* 637 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", - /* 638 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 639 */ "limit_clause_opt ::=", - /* 640 */ "limit_clause_opt ::= LIMIT NK_INTEGER", - /* 641 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", - /* 642 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 643 */ "subquery ::= NK_LP query_expression NK_RP", - /* 644 */ "subquery ::= NK_LP subquery NK_RP", - /* 645 */ "search_condition ::= common_expression", - /* 646 */ "sort_specification_list ::= sort_specification", - /* 647 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", - /* 648 */ "sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt", - /* 649 */ "ordering_specification_opt ::=", - /* 650 */ "ordering_specification_opt ::= ASC", - /* 651 */ "ordering_specification_opt ::= DESC", - /* 652 */ "null_ordering_opt ::=", - /* 653 */ "null_ordering_opt ::= NULLS FIRST", - /* 654 */ "null_ordering_opt ::= NULLS LAST", + /* 559 */ "join_subtype ::= ASOF", + /* 560 */ "join_subtype ::= WINDOW", + /* 561 */ "window_offset_clause_opt ::=", + /* 562 */ "window_offset_clause_opt ::= WINDOW_OFFSET NK_LP window_offset_literal NK_COMMA window_offset_literal NK_RP", + /* 563 */ "window_offset_literal ::= NK_VARIABLE", + /* 564 */ "window_offset_literal ::= NK_MINUS NK_VARIABLE", + /* 565 */ "jlimit_clause_opt ::=", + /* 566 */ "jlimit_clause_opt ::= JLIMIT NK_INTEGER", + /* 567 */ "query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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", + /* 568 */ "hint_list ::=", + /* 569 */ "hint_list ::= NK_HINT", + /* 570 */ "tag_mode_opt ::=", + /* 571 */ "tag_mode_opt ::= TAGS", + /* 572 */ "set_quantifier_opt ::=", + /* 573 */ "set_quantifier_opt ::= DISTINCT", + /* 574 */ "set_quantifier_opt ::= ALL", + /* 575 */ "select_list ::= select_item", + /* 576 */ "select_list ::= select_list NK_COMMA select_item", + /* 577 */ "select_item ::= NK_STAR", + /* 578 */ "select_item ::= common_expression", + /* 579 */ "select_item ::= common_expression column_alias", + /* 580 */ "select_item ::= common_expression AS column_alias", + /* 581 */ "select_item ::= table_name NK_DOT NK_STAR", + /* 582 */ "where_clause_opt ::=", + /* 583 */ "where_clause_opt ::= WHERE search_condition", + /* 584 */ "partition_by_clause_opt ::=", + /* 585 */ "partition_by_clause_opt ::= PARTITION BY partition_list", + /* 586 */ "partition_list ::= partition_item", + /* 587 */ "partition_list ::= partition_list NK_COMMA partition_item", + /* 588 */ "partition_item ::= expr_or_subquery", + /* 589 */ "partition_item ::= expr_or_subquery column_alias", + /* 590 */ "partition_item ::= expr_or_subquery AS column_alias", + /* 591 */ "twindow_clause_opt ::=", + /* 592 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP", + /* 593 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP", + /* 594 */ "twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt", + /* 595 */ "twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt", + /* 596 */ "twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition", + /* 597 */ "sliding_opt ::=", + /* 598 */ "sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP", + /* 599 */ "interval_sliding_duration_literal ::= NK_VARIABLE", + /* 600 */ "interval_sliding_duration_literal ::= NK_STRING", + /* 601 */ "interval_sliding_duration_literal ::= NK_INTEGER", + /* 602 */ "fill_opt ::=", + /* 603 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", + /* 604 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP", + /* 605 */ "fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP", + /* 606 */ "fill_mode ::= NONE", + /* 607 */ "fill_mode ::= PREV", + /* 608 */ "fill_mode ::= NULL", + /* 609 */ "fill_mode ::= NULL_F", + /* 610 */ "fill_mode ::= LINEAR", + /* 611 */ "fill_mode ::= NEXT", + /* 612 */ "group_by_clause_opt ::=", + /* 613 */ "group_by_clause_opt ::= GROUP BY group_by_list", + /* 614 */ "group_by_list ::= expr_or_subquery", + /* 615 */ "group_by_list ::= group_by_list NK_COMMA expr_or_subquery", + /* 616 */ "having_clause_opt ::=", + /* 617 */ "having_clause_opt ::= HAVING search_condition", + /* 618 */ "range_opt ::=", + /* 619 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP", + /* 620 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_RP", + /* 621 */ "every_opt ::=", + /* 622 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP", + /* 623 */ "query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt", + /* 624 */ "query_simple ::= query_specification", + /* 625 */ "query_simple ::= union_query_expression", + /* 626 */ "union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery", + /* 627 */ "union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery", + /* 628 */ "query_simple_or_subquery ::= query_simple", + /* 629 */ "query_simple_or_subquery ::= subquery", + /* 630 */ "query_or_subquery ::= query_expression", + /* 631 */ "query_or_subquery ::= subquery", + /* 632 */ "order_by_clause_opt ::=", + /* 633 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", + /* 634 */ "slimit_clause_opt ::=", + /* 635 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", + /* 636 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", + /* 637 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 638 */ "limit_clause_opt ::=", + /* 639 */ "limit_clause_opt ::= LIMIT NK_INTEGER", + /* 640 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", + /* 641 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 642 */ "subquery ::= NK_LP query_expression NK_RP", + /* 643 */ "subquery ::= NK_LP subquery NK_RP", + /* 644 */ "search_condition ::= common_expression", + /* 645 */ "sort_specification_list ::= sort_specification", + /* 646 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", + /* 647 */ "sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt", + /* 648 */ "ordering_specification_opt ::=", + /* 649 */ "ordering_specification_opt ::= ASC", + /* 650 */ "ordering_specification_opt ::= DESC", + /* 651 */ "null_ordering_opt ::=", + /* 652 */ "null_ordering_opt ::= NULLS FIRST", + /* 653 */ "null_ordering_opt ::= NULLS LAST", }; #endif /* NDEBUG */ @@ -2919,239 +2894,239 @@ static void yy_destructor( */ /********* Begin destructor definitions ***************************************/ /* Default NON-TERMINAL Destructor */ - case 356: /* cmd */ - case 359: /* literal */ - case 368: /* with_opt */ - case 374: /* search_condition */ - case 379: /* db_options */ - case 381: /* alter_db_options */ - case 383: /* start_opt */ - case 384: /* end_opt */ - case 388: /* signed */ - case 390: /* retention */ - case 391: /* full_table_name */ - case 394: /* table_options */ - case 398: /* alter_table_clause */ - case 399: /* alter_table_options */ - case 402: /* signed_literal */ - case 403: /* create_subtable_clause */ - case 406: /* drop_table_clause */ - case 408: /* column_def */ - case 412: /* duration_literal */ - case 413: /* rollup_func_name */ - case 415: /* col_name */ - case 418: /* like_pattern_opt */ - case 419: /* db_name_cond_opt */ - case 420: /* table_name_cond */ - case 421: /* from_db_opt */ - case 424: /* tag_item */ - case 426: /* index_options */ - case 427: /* full_index_name */ - case 430: /* sliding_opt */ - case 431: /* sma_stream_opt */ - case 432: /* func */ - case 435: /* query_or_subquery */ - case 436: /* where_clause_opt */ - case 439: /* explain_options */ - case 440: /* insert_query */ - case 445: /* full_view_name */ - case 448: /* stream_options */ - case 451: /* subtable_opt */ - case 453: /* expression */ - case 456: /* literal_func */ - case 459: /* expr_or_subquery */ - case 460: /* pseudo_column */ - case 461: /* column_reference */ - case 462: /* function_expression */ - case 463: /* case_when_expression */ - case 468: /* star_func_para */ - case 470: /* case_when_else_opt */ - case 471: /* common_expression */ - case 472: /* when_then_expr */ - case 473: /* predicate */ - case 476: /* in_predicate_value */ - case 477: /* boolean_value_expression */ - case 478: /* boolean_primary */ - case 479: /* from_clause_opt */ - case 480: /* table_reference_list */ - case 481: /* table_reference */ - case 482: /* table_primary */ - case 483: /* joined_table */ - case 485: /* subquery */ - case 486: /* parenthesized_joined_table */ - case 489: /* window_offset_clause_opt */ - case 490: /* jlimit_clause_opt */ - case 491: /* window_offset_literal */ - case 492: /* query_specification */ - case 498: /* range_opt */ - case 499: /* every_opt */ - case 500: /* fill_opt */ - case 501: /* twindow_clause_opt */ - case 503: /* having_clause_opt */ - case 504: /* select_item */ - case 506: /* partition_item */ - case 507: /* interval_sliding_duration_literal */ - case 510: /* query_expression */ - case 511: /* query_simple */ - case 513: /* slimit_clause_opt */ - case 514: /* limit_clause_opt */ - case 515: /* union_query_expression */ - case 516: /* query_simple_or_subquery */ - case 518: /* sort_specification */ + case 355: /* cmd */ + case 358: /* literal */ + case 367: /* with_opt */ + case 373: /* search_condition */ + case 378: /* db_options */ + case 380: /* alter_db_options */ + case 382: /* start_opt */ + case 383: /* end_opt */ + case 387: /* signed */ + case 389: /* retention */ + case 390: /* full_table_name */ + case 393: /* table_options */ + case 397: /* alter_table_clause */ + case 398: /* alter_table_options */ + case 401: /* signed_literal */ + case 402: /* create_subtable_clause */ + case 405: /* drop_table_clause */ + case 407: /* column_def */ + case 411: /* duration_literal */ + case 412: /* rollup_func_name */ + case 414: /* col_name */ + case 417: /* like_pattern_opt */ + case 418: /* db_name_cond_opt */ + case 419: /* table_name_cond */ + case 420: /* from_db_opt */ + case 423: /* tag_item */ + case 425: /* index_options */ + case 426: /* full_index_name */ + case 429: /* sliding_opt */ + case 430: /* sma_stream_opt */ + case 431: /* func */ + case 434: /* query_or_subquery */ + case 435: /* where_clause_opt */ + case 438: /* explain_options */ + case 439: /* insert_query */ + case 444: /* full_view_name */ + case 447: /* stream_options */ + case 450: /* subtable_opt */ + case 452: /* expression */ + case 455: /* literal_func */ + case 458: /* expr_or_subquery */ + case 459: /* pseudo_column */ + case 460: /* column_reference */ + case 461: /* function_expression */ + case 462: /* case_when_expression */ + case 467: /* star_func_para */ + case 469: /* case_when_else_opt */ + case 470: /* common_expression */ + case 471: /* when_then_expr */ + case 472: /* predicate */ + case 475: /* in_predicate_value */ + case 476: /* boolean_value_expression */ + case 477: /* boolean_primary */ + case 478: /* from_clause_opt */ + case 479: /* table_reference_list */ + case 480: /* table_reference */ + case 481: /* table_primary */ + case 482: /* joined_table */ + case 484: /* subquery */ + case 485: /* parenthesized_joined_table */ + case 488: /* window_offset_clause_opt */ + case 489: /* jlimit_clause_opt */ + case 490: /* window_offset_literal */ + case 491: /* query_specification */ + case 497: /* range_opt */ + case 498: /* every_opt */ + case 499: /* fill_opt */ + case 500: /* twindow_clause_opt */ + case 502: /* having_clause_opt */ + case 503: /* select_item */ + case 505: /* partition_item */ + case 506: /* interval_sliding_duration_literal */ + case 509: /* query_expression */ + case 510: /* query_simple */ + case 512: /* slimit_clause_opt */ + case 513: /* limit_clause_opt */ + case 514: /* union_query_expression */ + case 515: /* query_simple_or_subquery */ + case 517: /* sort_specification */ { - nodesDestroyNode((yypminor->yy664)); + nodesDestroyNode((yypminor->yy392)); } break; - case 357: /* account_options */ - case 358: /* alter_account_options */ - case 360: /* alter_account_option */ - case 382: /* speed_opt */ - case 434: /* with_meta */ - case 443: /* bufsize_opt */ + case 356: /* account_options */ + case 357: /* alter_account_options */ + case 359: /* alter_account_option */ + case 381: /* speed_opt */ + case 433: /* with_meta */ + case 442: /* bufsize_opt */ { } break; - case 361: /* ip_range_list */ - case 362: /* white_list */ - case 363: /* white_list_opt */ - case 385: /* integer_list */ - case 386: /* variable_list */ - case 387: /* retention_list */ - case 392: /* column_def_list */ - case 393: /* tags_def_opt */ - case 395: /* multi_create_clause */ - case 396: /* tags_def */ - case 397: /* multi_drop_clause */ - case 404: /* specific_cols_opt */ - case 405: /* expression_list */ - case 407: /* col_name_list */ - case 409: /* duration_list */ - case 410: /* rollup_func_list */ - case 422: /* tag_list_opt */ - case 429: /* func_list */ - case 449: /* col_list_opt */ - case 450: /* tag_def_or_ref_opt */ - case 455: /* dnode_list */ - case 457: /* literal_list */ - case 465: /* star_func_para_list */ - case 467: /* other_para_list */ - case 469: /* when_then_list */ - case 493: /* hint_list */ - case 496: /* select_list */ - case 497: /* partition_by_clause_opt */ - case 502: /* group_by_clause_opt */ - case 505: /* partition_list */ - case 509: /* group_by_list */ - case 512: /* order_by_clause_opt */ - case 517: /* sort_specification_list */ + case 360: /* ip_range_list */ + case 361: /* white_list */ + case 362: /* white_list_opt */ + case 384: /* integer_list */ + case 385: /* variable_list */ + case 386: /* retention_list */ + case 391: /* column_def_list */ + case 392: /* tags_def_opt */ + case 394: /* multi_create_clause */ + case 395: /* tags_def */ + case 396: /* multi_drop_clause */ + case 403: /* specific_cols_opt */ + case 404: /* expression_list */ + case 406: /* col_name_list */ + case 408: /* duration_list */ + case 409: /* rollup_func_list */ + case 421: /* tag_list_opt */ + case 428: /* func_list */ + case 448: /* col_list_opt */ + case 449: /* tag_def_or_ref_opt */ + case 454: /* dnode_list */ + case 456: /* literal_list */ + case 464: /* star_func_para_list */ + case 466: /* other_para_list */ + case 468: /* when_then_list */ + case 492: /* hint_list */ + case 495: /* select_list */ + case 496: /* partition_by_clause_opt */ + case 501: /* group_by_clause_opt */ + case 504: /* partition_list */ + case 508: /* group_by_list */ + case 511: /* order_by_clause_opt */ + case 516: /* sort_specification_list */ { - nodesDestroyList((yypminor->yy1006)); + nodesDestroyList((yypminor->yy184)); } break; - case 364: /* user_name */ - case 371: /* db_name */ - case 372: /* table_name */ - case 373: /* topic_name */ - case 375: /* dnode_endpoint */ - case 400: /* column_name */ - case 414: /* function_name */ - case 425: /* column_alias */ - case 428: /* index_name */ - case 433: /* sma_func_name */ - case 437: /* cgroup_name */ - case 444: /* language_opt */ - case 446: /* view_name */ - case 447: /* stream_name */ - case 454: /* on_vgroup_id */ - case 458: /* table_alias */ - case 464: /* star_func */ - case 466: /* noarg_func */ - case 484: /* alias_opt */ + case 363: /* user_name */ + case 370: /* db_name */ + case 371: /* table_name */ + case 372: /* topic_name */ + case 374: /* dnode_endpoint */ + case 399: /* column_name */ + case 413: /* function_name */ + case 424: /* column_alias */ + case 427: /* index_name */ + case 432: /* sma_func_name */ + case 436: /* cgroup_name */ + case 443: /* language_opt */ + case 445: /* view_name */ + case 446: /* stream_name */ + case 453: /* on_vgroup_id */ + case 457: /* table_alias */ + case 463: /* star_func */ + case 465: /* noarg_func */ + case 483: /* alias_opt */ { } break; - case 365: /* sysinfo_opt */ + case 364: /* sysinfo_opt */ { } break; - case 366: /* privileges */ - case 369: /* priv_type_list */ - case 370: /* priv_type */ + case 365: /* privileges */ + case 368: /* priv_type_list */ + case 369: /* priv_type */ { } break; - case 367: /* priv_level */ + case 366: /* priv_level */ { } break; - case 376: /* force_opt */ - case 377: /* unsafe_opt */ - case 378: /* not_exists_opt */ - case 380: /* exists_opt */ - case 438: /* analyze_opt */ - case 441: /* or_replace_opt */ - case 442: /* agg_func_opt */ - case 452: /* ignore_opt */ - case 494: /* set_quantifier_opt */ - case 495: /* tag_mode_opt */ + case 375: /* force_opt */ + case 376: /* unsafe_opt */ + case 377: /* not_exists_opt */ + case 379: /* exists_opt */ + case 437: /* analyze_opt */ + case 440: /* or_replace_opt */ + case 441: /* agg_func_opt */ + case 451: /* ignore_opt */ + case 493: /* set_quantifier_opt */ + case 494: /* tag_mode_opt */ { } break; - case 389: /* alter_db_option */ - case 411: /* alter_table_option */ + case 388: /* alter_db_option */ + case 410: /* alter_table_option */ { } break; - case 401: /* type_name */ + case 400: /* type_name */ { } break; - case 416: /* db_kind_opt */ - case 423: /* table_kind */ + case 415: /* db_kind_opt */ + case 422: /* table_kind */ { } break; - case 417: /* table_kind_db_name_cond_opt */ + case 416: /* table_kind_db_name_cond_opt */ { } break; - case 474: /* compare_op */ - case 475: /* in_op */ + case 473: /* compare_op */ + case 474: /* in_op */ { } break; - case 487: /* join_type */ + case 486: /* join_type */ { } break; - case 488: /* join_subtype */ + case 487: /* join_subtype */ { } break; - case 508: /* fill_mode */ + case 507: /* fill_mode */ { } break; - case 519: /* ordering_specification_opt */ + case 518: /* ordering_specification_opt */ { } break; - case 520: /* null_ordering_opt */ + case 519: /* null_ordering_opt */ { } @@ -3442,661 +3417,660 @@ static void yy_shift( /* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side ** of that rule */ static const YYCODETYPE yyRuleInfoLhs[] = { - 356, /* (0) cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */ - 356, /* (1) cmd ::= ALTER ACCOUNT NK_ID alter_account_options */ - 357, /* (2) account_options ::= */ - 357, /* (3) account_options ::= account_options PPS literal */ - 357, /* (4) account_options ::= account_options TSERIES literal */ - 357, /* (5) account_options ::= account_options STORAGE literal */ - 357, /* (6) account_options ::= account_options STREAMS literal */ - 357, /* (7) account_options ::= account_options QTIME literal */ - 357, /* (8) account_options ::= account_options DBS literal */ - 357, /* (9) account_options ::= account_options USERS literal */ - 357, /* (10) account_options ::= account_options CONNS literal */ - 357, /* (11) account_options ::= account_options STATE literal */ - 358, /* (12) alter_account_options ::= alter_account_option */ - 358, /* (13) alter_account_options ::= alter_account_options alter_account_option */ - 360, /* (14) alter_account_option ::= PASS literal */ - 360, /* (15) alter_account_option ::= PPS literal */ - 360, /* (16) alter_account_option ::= TSERIES literal */ - 360, /* (17) alter_account_option ::= STORAGE literal */ - 360, /* (18) alter_account_option ::= STREAMS literal */ - 360, /* (19) alter_account_option ::= QTIME literal */ - 360, /* (20) alter_account_option ::= DBS literal */ - 360, /* (21) alter_account_option ::= USERS literal */ - 360, /* (22) alter_account_option ::= CONNS literal */ - 360, /* (23) alter_account_option ::= STATE literal */ - 361, /* (24) ip_range_list ::= NK_STRING */ - 361, /* (25) ip_range_list ::= ip_range_list NK_COMMA NK_STRING */ - 362, /* (26) white_list ::= HOST ip_range_list */ - 363, /* (27) white_list_opt ::= */ - 363, /* (28) white_list_opt ::= white_list */ - 356, /* (29) cmd ::= CREATE USER user_name PASS NK_STRING sysinfo_opt white_list_opt */ - 356, /* (30) cmd ::= ALTER USER user_name PASS NK_STRING */ - 356, /* (31) cmd ::= ALTER USER user_name ENABLE NK_INTEGER */ - 356, /* (32) cmd ::= ALTER USER user_name SYSINFO NK_INTEGER */ - 356, /* (33) cmd ::= ALTER USER user_name ADD white_list */ - 356, /* (34) cmd ::= ALTER USER user_name DROP white_list */ - 356, /* (35) cmd ::= DROP USER user_name */ - 365, /* (36) sysinfo_opt ::= */ - 365, /* (37) sysinfo_opt ::= SYSINFO NK_INTEGER */ - 356, /* (38) cmd ::= GRANT privileges ON priv_level with_opt TO user_name */ - 356, /* (39) cmd ::= REVOKE privileges ON priv_level with_opt FROM user_name */ - 366, /* (40) privileges ::= ALL */ - 366, /* (41) privileges ::= priv_type_list */ - 366, /* (42) privileges ::= SUBSCRIBE */ - 369, /* (43) priv_type_list ::= priv_type */ - 369, /* (44) priv_type_list ::= priv_type_list NK_COMMA priv_type */ - 370, /* (45) priv_type ::= READ */ - 370, /* (46) priv_type ::= WRITE */ - 370, /* (47) priv_type ::= ALTER */ - 367, /* (48) priv_level ::= NK_STAR NK_DOT NK_STAR */ - 367, /* (49) priv_level ::= db_name NK_DOT NK_STAR */ - 367, /* (50) priv_level ::= db_name NK_DOT table_name */ - 367, /* (51) priv_level ::= topic_name */ - 368, /* (52) with_opt ::= */ - 368, /* (53) with_opt ::= WITH search_condition */ - 356, /* (54) cmd ::= CREATE DNODE dnode_endpoint */ - 356, /* (55) cmd ::= CREATE DNODE dnode_endpoint PORT NK_INTEGER */ - 356, /* (56) cmd ::= DROP DNODE NK_INTEGER force_opt */ - 356, /* (57) cmd ::= DROP DNODE dnode_endpoint force_opt */ - 356, /* (58) cmd ::= DROP DNODE NK_INTEGER unsafe_opt */ - 356, /* (59) cmd ::= DROP DNODE dnode_endpoint unsafe_opt */ - 356, /* (60) cmd ::= ALTER DNODE NK_INTEGER NK_STRING */ - 356, /* (61) cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */ - 356, /* (62) cmd ::= ALTER ALL DNODES NK_STRING */ - 356, /* (63) cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */ - 356, /* (64) cmd ::= RESTORE DNODE NK_INTEGER */ - 375, /* (65) dnode_endpoint ::= NK_STRING */ - 375, /* (66) dnode_endpoint ::= NK_ID */ - 375, /* (67) dnode_endpoint ::= NK_IPTOKEN */ - 376, /* (68) force_opt ::= */ - 376, /* (69) force_opt ::= FORCE */ - 377, /* (70) unsafe_opt ::= UNSAFE */ - 356, /* (71) cmd ::= ALTER LOCAL NK_STRING */ - 356, /* (72) cmd ::= ALTER LOCAL NK_STRING NK_STRING */ - 356, /* (73) cmd ::= CREATE QNODE ON DNODE NK_INTEGER */ - 356, /* (74) cmd ::= DROP QNODE ON DNODE NK_INTEGER */ - 356, /* (75) cmd ::= RESTORE QNODE ON DNODE NK_INTEGER */ - 356, /* (76) cmd ::= CREATE BNODE ON DNODE NK_INTEGER */ - 356, /* (77) cmd ::= DROP BNODE ON DNODE NK_INTEGER */ - 356, /* (78) cmd ::= CREATE SNODE ON DNODE NK_INTEGER */ - 356, /* (79) cmd ::= DROP SNODE ON DNODE NK_INTEGER */ - 356, /* (80) cmd ::= CREATE MNODE ON DNODE NK_INTEGER */ - 356, /* (81) cmd ::= DROP MNODE ON DNODE NK_INTEGER */ - 356, /* (82) cmd ::= RESTORE MNODE ON DNODE NK_INTEGER */ - 356, /* (83) cmd ::= RESTORE VNODE ON DNODE NK_INTEGER */ - 356, /* (84) cmd ::= CREATE DATABASE not_exists_opt db_name db_options */ - 356, /* (85) cmd ::= DROP DATABASE exists_opt db_name */ - 356, /* (86) cmd ::= USE db_name */ - 356, /* (87) cmd ::= ALTER DATABASE db_name alter_db_options */ - 356, /* (88) cmd ::= FLUSH DATABASE db_name */ - 356, /* (89) cmd ::= TRIM DATABASE db_name speed_opt */ - 356, /* (90) cmd ::= COMPACT DATABASE db_name start_opt end_opt */ - 378, /* (91) not_exists_opt ::= IF NOT EXISTS */ - 378, /* (92) not_exists_opt ::= */ - 380, /* (93) exists_opt ::= IF EXISTS */ - 380, /* (94) exists_opt ::= */ - 379, /* (95) db_options ::= */ - 379, /* (96) db_options ::= db_options BUFFER NK_INTEGER */ - 379, /* (97) db_options ::= db_options CACHEMODEL NK_STRING */ - 379, /* (98) db_options ::= db_options CACHESIZE NK_INTEGER */ - 379, /* (99) db_options ::= db_options COMP NK_INTEGER */ - 379, /* (100) db_options ::= db_options DURATION NK_INTEGER */ - 379, /* (101) db_options ::= db_options DURATION NK_VARIABLE */ - 379, /* (102) db_options ::= db_options MAXROWS NK_INTEGER */ - 379, /* (103) db_options ::= db_options MINROWS NK_INTEGER */ - 379, /* (104) db_options ::= db_options KEEP integer_list */ - 379, /* (105) db_options ::= db_options KEEP variable_list */ - 379, /* (106) db_options ::= db_options PAGES NK_INTEGER */ - 379, /* (107) db_options ::= db_options PAGESIZE NK_INTEGER */ - 379, /* (108) db_options ::= db_options TSDB_PAGESIZE NK_INTEGER */ - 379, /* (109) db_options ::= db_options PRECISION NK_STRING */ - 379, /* (110) db_options ::= db_options REPLICA NK_INTEGER */ - 379, /* (111) db_options ::= db_options VGROUPS NK_INTEGER */ - 379, /* (112) db_options ::= db_options SINGLE_STABLE NK_INTEGER */ - 379, /* (113) db_options ::= db_options RETENTIONS retention_list */ - 379, /* (114) db_options ::= db_options SCHEMALESS NK_INTEGER */ - 379, /* (115) db_options ::= db_options WAL_LEVEL NK_INTEGER */ - 379, /* (116) db_options ::= db_options WAL_FSYNC_PERIOD NK_INTEGER */ - 379, /* (117) db_options ::= db_options WAL_RETENTION_PERIOD NK_INTEGER */ - 379, /* (118) db_options ::= db_options WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ - 379, /* (119) db_options ::= db_options WAL_RETENTION_SIZE NK_INTEGER */ - 379, /* (120) db_options ::= db_options WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ - 379, /* (121) db_options ::= db_options WAL_ROLL_PERIOD NK_INTEGER */ - 379, /* (122) db_options ::= db_options WAL_SEGMENT_SIZE NK_INTEGER */ - 379, /* (123) db_options ::= db_options STT_TRIGGER NK_INTEGER */ - 379, /* (124) db_options ::= db_options TABLE_PREFIX signed */ - 379, /* (125) db_options ::= db_options TABLE_SUFFIX signed */ - 379, /* (126) db_options ::= db_options KEEP_TIME_OFFSET NK_INTEGER */ - 381, /* (127) alter_db_options ::= alter_db_option */ - 381, /* (128) alter_db_options ::= alter_db_options alter_db_option */ - 389, /* (129) alter_db_option ::= BUFFER NK_INTEGER */ - 389, /* (130) alter_db_option ::= CACHEMODEL NK_STRING */ - 389, /* (131) alter_db_option ::= CACHESIZE NK_INTEGER */ - 389, /* (132) alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */ - 389, /* (133) alter_db_option ::= KEEP integer_list */ - 389, /* (134) alter_db_option ::= KEEP variable_list */ - 389, /* (135) alter_db_option ::= PAGES NK_INTEGER */ - 389, /* (136) alter_db_option ::= REPLICA NK_INTEGER */ - 389, /* (137) alter_db_option ::= WAL_LEVEL NK_INTEGER */ - 389, /* (138) alter_db_option ::= STT_TRIGGER NK_INTEGER */ - 389, /* (139) alter_db_option ::= MINROWS NK_INTEGER */ - 389, /* (140) alter_db_option ::= WAL_RETENTION_PERIOD NK_INTEGER */ - 389, /* (141) alter_db_option ::= WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ - 389, /* (142) alter_db_option ::= WAL_RETENTION_SIZE NK_INTEGER */ - 389, /* (143) alter_db_option ::= WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ - 389, /* (144) alter_db_option ::= KEEP_TIME_OFFSET NK_INTEGER */ - 385, /* (145) integer_list ::= NK_INTEGER */ - 385, /* (146) integer_list ::= integer_list NK_COMMA NK_INTEGER */ - 386, /* (147) variable_list ::= NK_VARIABLE */ - 386, /* (148) variable_list ::= variable_list NK_COMMA NK_VARIABLE */ - 387, /* (149) retention_list ::= retention */ - 387, /* (150) retention_list ::= retention_list NK_COMMA retention */ - 390, /* (151) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ - 390, /* (152) retention ::= NK_MINUS NK_COLON NK_VARIABLE */ - 382, /* (153) speed_opt ::= */ - 382, /* (154) speed_opt ::= BWLIMIT NK_INTEGER */ - 383, /* (155) start_opt ::= */ - 383, /* (156) start_opt ::= START WITH NK_INTEGER */ - 383, /* (157) start_opt ::= START WITH NK_STRING */ - 383, /* (158) start_opt ::= START WITH TIMESTAMP NK_STRING */ - 384, /* (159) end_opt ::= */ - 384, /* (160) end_opt ::= END WITH NK_INTEGER */ - 384, /* (161) end_opt ::= END WITH NK_STRING */ - 384, /* (162) end_opt ::= END WITH TIMESTAMP NK_STRING */ - 356, /* (163) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ - 356, /* (164) cmd ::= CREATE TABLE multi_create_clause */ - 356, /* (165) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ - 356, /* (166) cmd ::= DROP TABLE multi_drop_clause */ - 356, /* (167) cmd ::= DROP STABLE exists_opt full_table_name */ - 356, /* (168) cmd ::= ALTER TABLE alter_table_clause */ - 356, /* (169) cmd ::= ALTER STABLE alter_table_clause */ - 398, /* (170) alter_table_clause ::= full_table_name alter_table_options */ - 398, /* (171) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ - 398, /* (172) alter_table_clause ::= full_table_name DROP COLUMN column_name */ - 398, /* (173) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ - 398, /* (174) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ - 398, /* (175) alter_table_clause ::= full_table_name ADD TAG column_name type_name */ - 398, /* (176) alter_table_clause ::= full_table_name DROP TAG column_name */ - 398, /* (177) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ - 398, /* (178) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ - 398, /* (179) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ - 395, /* (180) multi_create_clause ::= create_subtable_clause */ - 395, /* (181) multi_create_clause ::= multi_create_clause create_subtable_clause */ - 403, /* (182) 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 */ - 397, /* (183) multi_drop_clause ::= drop_table_clause */ - 397, /* (184) multi_drop_clause ::= multi_drop_clause NK_COMMA drop_table_clause */ - 406, /* (185) drop_table_clause ::= exists_opt full_table_name */ - 404, /* (186) specific_cols_opt ::= */ - 404, /* (187) specific_cols_opt ::= NK_LP col_name_list NK_RP */ - 391, /* (188) full_table_name ::= table_name */ - 391, /* (189) full_table_name ::= db_name NK_DOT table_name */ - 392, /* (190) column_def_list ::= column_def */ - 392, /* (191) column_def_list ::= column_def_list NK_COMMA column_def */ - 408, /* (192) column_def ::= column_name type_name */ - 401, /* (193) type_name ::= BOOL */ - 401, /* (194) type_name ::= TINYINT */ - 401, /* (195) type_name ::= SMALLINT */ - 401, /* (196) type_name ::= INT */ - 401, /* (197) type_name ::= INTEGER */ - 401, /* (198) type_name ::= BIGINT */ - 401, /* (199) type_name ::= FLOAT */ - 401, /* (200) type_name ::= DOUBLE */ - 401, /* (201) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ - 401, /* (202) type_name ::= TIMESTAMP */ - 401, /* (203) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ - 401, /* (204) type_name ::= TINYINT UNSIGNED */ - 401, /* (205) type_name ::= SMALLINT UNSIGNED */ - 401, /* (206) type_name ::= INT UNSIGNED */ - 401, /* (207) type_name ::= BIGINT UNSIGNED */ - 401, /* (208) type_name ::= JSON */ - 401, /* (209) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ - 401, /* (210) type_name ::= MEDIUMBLOB */ - 401, /* (211) type_name ::= BLOB */ - 401, /* (212) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ - 401, /* (213) type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP */ - 401, /* (214) type_name ::= DECIMAL */ - 401, /* (215) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ - 401, /* (216) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ - 393, /* (217) tags_def_opt ::= */ - 393, /* (218) tags_def_opt ::= tags_def */ - 396, /* (219) tags_def ::= TAGS NK_LP column_def_list NK_RP */ - 394, /* (220) table_options ::= */ - 394, /* (221) table_options ::= table_options COMMENT NK_STRING */ - 394, /* (222) table_options ::= table_options MAX_DELAY duration_list */ - 394, /* (223) table_options ::= table_options WATERMARK duration_list */ - 394, /* (224) table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ - 394, /* (225) table_options ::= table_options TTL NK_INTEGER */ - 394, /* (226) table_options ::= table_options SMA NK_LP col_name_list NK_RP */ - 394, /* (227) table_options ::= table_options DELETE_MARK duration_list */ - 399, /* (228) alter_table_options ::= alter_table_option */ - 399, /* (229) alter_table_options ::= alter_table_options alter_table_option */ - 411, /* (230) alter_table_option ::= COMMENT NK_STRING */ - 411, /* (231) alter_table_option ::= TTL NK_INTEGER */ - 409, /* (232) duration_list ::= duration_literal */ - 409, /* (233) duration_list ::= duration_list NK_COMMA duration_literal */ - 410, /* (234) rollup_func_list ::= rollup_func_name */ - 410, /* (235) rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ - 413, /* (236) rollup_func_name ::= function_name */ - 413, /* (237) rollup_func_name ::= FIRST */ - 413, /* (238) rollup_func_name ::= LAST */ - 407, /* (239) col_name_list ::= col_name */ - 407, /* (240) col_name_list ::= col_name_list NK_COMMA col_name */ - 415, /* (241) col_name ::= column_name */ - 356, /* (242) cmd ::= SHOW DNODES */ - 356, /* (243) cmd ::= SHOW USERS */ - 356, /* (244) cmd ::= SHOW USER PRIVILEGES */ - 356, /* (245) cmd ::= SHOW db_kind_opt DATABASES */ - 356, /* (246) cmd ::= SHOW table_kind_db_name_cond_opt TABLES like_pattern_opt */ - 356, /* (247) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ - 356, /* (248) cmd ::= SHOW db_name_cond_opt VGROUPS */ - 356, /* (249) cmd ::= SHOW MNODES */ - 356, /* (250) cmd ::= SHOW QNODES */ - 356, /* (251) cmd ::= SHOW FUNCTIONS */ - 356, /* (252) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ - 356, /* (253) cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */ - 356, /* (254) cmd ::= SHOW STREAMS */ - 356, /* (255) cmd ::= SHOW ACCOUNTS */ - 356, /* (256) cmd ::= SHOW APPS */ - 356, /* (257) cmd ::= SHOW CONNECTIONS */ - 356, /* (258) cmd ::= SHOW LICENCES */ - 356, /* (259) cmd ::= SHOW GRANTS */ - 356, /* (260) cmd ::= SHOW CREATE DATABASE db_name */ - 356, /* (261) cmd ::= SHOW CREATE TABLE full_table_name */ - 356, /* (262) cmd ::= SHOW CREATE STABLE full_table_name */ - 356, /* (263) cmd ::= SHOW QUERIES */ - 356, /* (264) cmd ::= SHOW SCORES */ - 356, /* (265) cmd ::= SHOW TOPICS */ - 356, /* (266) cmd ::= SHOW VARIABLES */ - 356, /* (267) cmd ::= SHOW CLUSTER VARIABLES */ - 356, /* (268) cmd ::= SHOW LOCAL VARIABLES */ - 356, /* (269) cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */ - 356, /* (270) cmd ::= SHOW BNODES */ - 356, /* (271) cmd ::= SHOW SNODES */ - 356, /* (272) cmd ::= SHOW CLUSTER */ - 356, /* (273) cmd ::= SHOW TRANSACTIONS */ - 356, /* (274) cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ - 356, /* (275) cmd ::= SHOW CONSUMERS */ - 356, /* (276) cmd ::= SHOW SUBSCRIPTIONS */ - 356, /* (277) cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ - 356, /* (278) cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */ - 356, /* (279) cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */ - 356, /* (280) cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */ - 356, /* (281) cmd ::= SHOW VNODES ON DNODE NK_INTEGER */ - 356, /* (282) cmd ::= SHOW VNODES */ - 356, /* (283) cmd ::= SHOW db_name_cond_opt ALIVE */ - 356, /* (284) cmd ::= SHOW CLUSTER ALIVE */ - 356, /* (285) cmd ::= SHOW db_name_cond_opt VIEWS */ - 356, /* (286) cmd ::= SHOW CREATE VIEW full_table_name */ - 417, /* (287) table_kind_db_name_cond_opt ::= */ - 417, /* (288) table_kind_db_name_cond_opt ::= table_kind */ - 417, /* (289) table_kind_db_name_cond_opt ::= db_name NK_DOT */ - 417, /* (290) table_kind_db_name_cond_opt ::= table_kind db_name NK_DOT */ - 423, /* (291) table_kind ::= NORMAL */ - 423, /* (292) table_kind ::= CHILD */ - 419, /* (293) db_name_cond_opt ::= */ - 419, /* (294) db_name_cond_opt ::= db_name NK_DOT */ - 418, /* (295) like_pattern_opt ::= */ - 418, /* (296) like_pattern_opt ::= LIKE NK_STRING */ - 420, /* (297) table_name_cond ::= table_name */ - 421, /* (298) from_db_opt ::= */ - 421, /* (299) from_db_opt ::= FROM db_name */ - 422, /* (300) tag_list_opt ::= */ - 422, /* (301) tag_list_opt ::= tag_item */ - 422, /* (302) tag_list_opt ::= tag_list_opt NK_COMMA tag_item */ - 424, /* (303) tag_item ::= TBNAME */ - 424, /* (304) tag_item ::= QTAGS */ - 424, /* (305) tag_item ::= column_name */ - 424, /* (306) tag_item ::= column_name column_alias */ - 424, /* (307) tag_item ::= column_name AS column_alias */ - 416, /* (308) db_kind_opt ::= */ - 416, /* (309) db_kind_opt ::= USER */ - 416, /* (310) db_kind_opt ::= SYSTEM */ - 356, /* (311) cmd ::= CREATE SMA INDEX not_exists_opt col_name ON full_table_name index_options */ - 356, /* (312) cmd ::= CREATE INDEX not_exists_opt col_name ON full_table_name NK_LP col_name_list NK_RP */ - 356, /* (313) cmd ::= DROP INDEX exists_opt full_index_name */ - 427, /* (314) full_index_name ::= index_name */ - 427, /* (315) full_index_name ::= db_name NK_DOT index_name */ - 426, /* (316) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ - 426, /* (317) 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 */ - 429, /* (318) func_list ::= func */ - 429, /* (319) func_list ::= func_list NK_COMMA func */ - 432, /* (320) func ::= sma_func_name NK_LP expression_list NK_RP */ - 433, /* (321) sma_func_name ::= function_name */ - 433, /* (322) sma_func_name ::= COUNT */ - 433, /* (323) sma_func_name ::= FIRST */ - 433, /* (324) sma_func_name ::= LAST */ - 433, /* (325) sma_func_name ::= LAST_ROW */ - 431, /* (326) sma_stream_opt ::= */ - 431, /* (327) sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */ - 431, /* (328) sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */ - 431, /* (329) sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */ - 434, /* (330) with_meta ::= AS */ - 434, /* (331) with_meta ::= WITH META AS */ - 434, /* (332) with_meta ::= ONLY META AS */ - 356, /* (333) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */ - 356, /* (334) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */ - 356, /* (335) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */ - 356, /* (336) cmd ::= DROP TOPIC exists_opt topic_name */ - 356, /* (337) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ - 356, /* (338) cmd ::= DESC full_table_name */ - 356, /* (339) cmd ::= DESCRIBE full_table_name */ - 356, /* (340) cmd ::= RESET QUERY CACHE */ - 356, /* (341) cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */ - 356, /* (342) cmd ::= EXPLAIN analyze_opt explain_options insert_query */ - 438, /* (343) analyze_opt ::= */ - 438, /* (344) analyze_opt ::= ANALYZE */ - 439, /* (345) explain_options ::= */ - 439, /* (346) explain_options ::= explain_options VERBOSE NK_BOOL */ - 439, /* (347) explain_options ::= explain_options RATIO NK_FLOAT */ - 356, /* (348) cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */ - 356, /* (349) cmd ::= DROP FUNCTION exists_opt function_name */ - 442, /* (350) agg_func_opt ::= */ - 442, /* (351) agg_func_opt ::= AGGREGATE */ - 443, /* (352) bufsize_opt ::= */ - 443, /* (353) bufsize_opt ::= BUFSIZE NK_INTEGER */ - 444, /* (354) language_opt ::= */ - 444, /* (355) language_opt ::= LANGUAGE NK_STRING */ - 441, /* (356) or_replace_opt ::= */ - 441, /* (357) or_replace_opt ::= OR REPLACE */ - 356, /* (358) cmd ::= CREATE or_replace_opt VIEW full_view_name AS query_or_subquery */ - 356, /* (359) cmd ::= DROP VIEW exists_opt full_view_name */ - 445, /* (360) full_view_name ::= view_name */ - 445, /* (361) full_view_name ::= db_name NK_DOT view_name */ - 356, /* (362) 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 */ - 356, /* (363) cmd ::= DROP STREAM exists_opt stream_name */ - 356, /* (364) cmd ::= PAUSE STREAM exists_opt stream_name */ - 356, /* (365) cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */ - 449, /* (366) col_list_opt ::= */ - 449, /* (367) col_list_opt ::= NK_LP col_name_list NK_RP */ - 450, /* (368) tag_def_or_ref_opt ::= */ - 450, /* (369) tag_def_or_ref_opt ::= tags_def */ - 450, /* (370) tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP */ - 448, /* (371) stream_options ::= */ - 448, /* (372) stream_options ::= stream_options TRIGGER AT_ONCE */ - 448, /* (373) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ - 448, /* (374) stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ - 448, /* (375) stream_options ::= stream_options WATERMARK duration_literal */ - 448, /* (376) stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ - 448, /* (377) stream_options ::= stream_options FILL_HISTORY NK_INTEGER */ - 448, /* (378) stream_options ::= stream_options DELETE_MARK duration_literal */ - 448, /* (379) stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */ - 451, /* (380) subtable_opt ::= */ - 451, /* (381) subtable_opt ::= SUBTABLE NK_LP expression NK_RP */ - 452, /* (382) ignore_opt ::= */ - 452, /* (383) ignore_opt ::= IGNORE UNTREATED */ - 356, /* (384) cmd ::= KILL CONNECTION NK_INTEGER */ - 356, /* (385) cmd ::= KILL QUERY NK_STRING */ - 356, /* (386) cmd ::= KILL TRANSACTION NK_INTEGER */ - 356, /* (387) cmd ::= BALANCE VGROUP */ - 356, /* (388) cmd ::= BALANCE VGROUP LEADER on_vgroup_id */ - 356, /* (389) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ - 356, /* (390) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ - 356, /* (391) cmd ::= SPLIT VGROUP NK_INTEGER */ - 454, /* (392) on_vgroup_id ::= */ - 454, /* (393) on_vgroup_id ::= ON NK_INTEGER */ - 455, /* (394) dnode_list ::= DNODE NK_INTEGER */ - 455, /* (395) dnode_list ::= dnode_list DNODE NK_INTEGER */ - 356, /* (396) cmd ::= DELETE FROM full_table_name where_clause_opt */ - 356, /* (397) cmd ::= query_or_subquery */ - 356, /* (398) cmd ::= insert_query */ - 440, /* (399) insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */ - 440, /* (400) insert_query ::= INSERT INTO full_table_name query_or_subquery */ - 359, /* (401) literal ::= NK_INTEGER */ - 359, /* (402) literal ::= NK_FLOAT */ - 359, /* (403) literal ::= NK_STRING */ - 359, /* (404) literal ::= NK_BOOL */ - 359, /* (405) literal ::= TIMESTAMP NK_STRING */ - 359, /* (406) literal ::= duration_literal */ - 359, /* (407) literal ::= NULL */ - 359, /* (408) literal ::= NK_QUESTION */ - 412, /* (409) duration_literal ::= NK_VARIABLE */ - 388, /* (410) signed ::= NK_INTEGER */ - 388, /* (411) signed ::= NK_PLUS NK_INTEGER */ - 388, /* (412) signed ::= NK_MINUS NK_INTEGER */ - 388, /* (413) signed ::= NK_FLOAT */ - 388, /* (414) signed ::= NK_PLUS NK_FLOAT */ - 388, /* (415) signed ::= NK_MINUS NK_FLOAT */ - 402, /* (416) signed_literal ::= signed */ - 402, /* (417) signed_literal ::= NK_STRING */ - 402, /* (418) signed_literal ::= NK_BOOL */ - 402, /* (419) signed_literal ::= TIMESTAMP NK_STRING */ - 402, /* (420) signed_literal ::= duration_literal */ - 402, /* (421) signed_literal ::= NULL */ - 402, /* (422) signed_literal ::= literal_func */ - 402, /* (423) signed_literal ::= NK_QUESTION */ - 457, /* (424) literal_list ::= signed_literal */ - 457, /* (425) literal_list ::= literal_list NK_COMMA signed_literal */ - 371, /* (426) db_name ::= NK_ID */ - 372, /* (427) table_name ::= NK_ID */ - 400, /* (428) column_name ::= NK_ID */ - 414, /* (429) function_name ::= NK_ID */ - 446, /* (430) view_name ::= NK_ID */ - 458, /* (431) table_alias ::= NK_ID */ - 425, /* (432) column_alias ::= NK_ID */ - 425, /* (433) column_alias ::= NK_ALIAS */ - 364, /* (434) user_name ::= NK_ID */ - 373, /* (435) topic_name ::= NK_ID */ - 447, /* (436) stream_name ::= NK_ID */ - 437, /* (437) cgroup_name ::= NK_ID */ - 428, /* (438) index_name ::= NK_ID */ - 459, /* (439) expr_or_subquery ::= expression */ - 453, /* (440) expression ::= literal */ - 453, /* (441) expression ::= pseudo_column */ - 453, /* (442) expression ::= column_reference */ - 453, /* (443) expression ::= function_expression */ - 453, /* (444) expression ::= case_when_expression */ - 453, /* (445) expression ::= NK_LP expression NK_RP */ - 453, /* (446) expression ::= NK_PLUS expr_or_subquery */ - 453, /* (447) expression ::= NK_MINUS expr_or_subquery */ - 453, /* (448) expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ - 453, /* (449) expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ - 453, /* (450) expression ::= expr_or_subquery NK_STAR expr_or_subquery */ - 453, /* (451) expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ - 453, /* (452) expression ::= expr_or_subquery NK_REM expr_or_subquery */ - 453, /* (453) expression ::= column_reference NK_ARROW NK_STRING */ - 453, /* (454) expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ - 453, /* (455) expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ - 405, /* (456) expression_list ::= expr_or_subquery */ - 405, /* (457) expression_list ::= expression_list NK_COMMA expr_or_subquery */ - 461, /* (458) column_reference ::= column_name */ - 461, /* (459) column_reference ::= table_name NK_DOT column_name */ - 461, /* (460) column_reference ::= NK_ALIAS */ - 461, /* (461) column_reference ::= table_name NK_DOT NK_ALIAS */ - 460, /* (462) pseudo_column ::= ROWTS */ - 460, /* (463) pseudo_column ::= TBNAME */ - 460, /* (464) pseudo_column ::= table_name NK_DOT TBNAME */ - 460, /* (465) pseudo_column ::= QSTART */ - 460, /* (466) pseudo_column ::= QEND */ - 460, /* (467) pseudo_column ::= QDURATION */ - 460, /* (468) pseudo_column ::= WSTART */ - 460, /* (469) pseudo_column ::= WEND */ - 460, /* (470) pseudo_column ::= WDURATION */ - 460, /* (471) pseudo_column ::= IROWTS */ - 460, /* (472) pseudo_column ::= ISFILLED */ - 460, /* (473) pseudo_column ::= QTAGS */ - 462, /* (474) function_expression ::= function_name NK_LP expression_list NK_RP */ - 462, /* (475) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ - 462, /* (476) function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ - 462, /* (477) function_expression ::= literal_func */ - 456, /* (478) literal_func ::= noarg_func NK_LP NK_RP */ - 456, /* (479) literal_func ::= NOW */ - 466, /* (480) noarg_func ::= NOW */ - 466, /* (481) noarg_func ::= TODAY */ - 466, /* (482) noarg_func ::= TIMEZONE */ - 466, /* (483) noarg_func ::= DATABASE */ - 466, /* (484) noarg_func ::= CLIENT_VERSION */ - 466, /* (485) noarg_func ::= SERVER_VERSION */ - 466, /* (486) noarg_func ::= SERVER_STATUS */ - 466, /* (487) noarg_func ::= CURRENT_USER */ - 466, /* (488) noarg_func ::= USER */ - 464, /* (489) star_func ::= COUNT */ - 464, /* (490) star_func ::= FIRST */ - 464, /* (491) star_func ::= LAST */ - 464, /* (492) star_func ::= LAST_ROW */ - 465, /* (493) star_func_para_list ::= NK_STAR */ - 465, /* (494) star_func_para_list ::= other_para_list */ - 467, /* (495) other_para_list ::= star_func_para */ - 467, /* (496) other_para_list ::= other_para_list NK_COMMA star_func_para */ - 468, /* (497) star_func_para ::= expr_or_subquery */ - 468, /* (498) star_func_para ::= table_name NK_DOT NK_STAR */ - 463, /* (499) case_when_expression ::= CASE when_then_list case_when_else_opt END */ - 463, /* (500) case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ - 469, /* (501) when_then_list ::= when_then_expr */ - 469, /* (502) when_then_list ::= when_then_list when_then_expr */ - 472, /* (503) when_then_expr ::= WHEN common_expression THEN common_expression */ - 470, /* (504) case_when_else_opt ::= */ - 470, /* (505) case_when_else_opt ::= ELSE common_expression */ - 473, /* (506) predicate ::= expr_or_subquery compare_op expr_or_subquery */ - 473, /* (507) predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ - 473, /* (508) predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ - 473, /* (509) predicate ::= expr_or_subquery IS NULL */ - 473, /* (510) predicate ::= expr_or_subquery IS NOT NULL */ - 473, /* (511) predicate ::= expr_or_subquery in_op in_predicate_value */ - 474, /* (512) compare_op ::= NK_LT */ - 474, /* (513) compare_op ::= NK_GT */ - 474, /* (514) compare_op ::= NK_LE */ - 474, /* (515) compare_op ::= NK_GE */ - 474, /* (516) compare_op ::= NK_NE */ - 474, /* (517) compare_op ::= NK_EQ */ - 474, /* (518) compare_op ::= LIKE */ - 474, /* (519) compare_op ::= NOT LIKE */ - 474, /* (520) compare_op ::= MATCH */ - 474, /* (521) compare_op ::= NMATCH */ - 474, /* (522) compare_op ::= CONTAINS */ - 475, /* (523) in_op ::= IN */ - 475, /* (524) in_op ::= NOT IN */ - 476, /* (525) in_predicate_value ::= NK_LP literal_list NK_RP */ - 477, /* (526) boolean_value_expression ::= boolean_primary */ - 477, /* (527) boolean_value_expression ::= NOT boolean_primary */ - 477, /* (528) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ - 477, /* (529) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ - 478, /* (530) boolean_primary ::= predicate */ - 478, /* (531) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ - 471, /* (532) common_expression ::= expr_or_subquery */ - 471, /* (533) common_expression ::= boolean_value_expression */ - 479, /* (534) from_clause_opt ::= */ - 479, /* (535) from_clause_opt ::= FROM table_reference_list */ - 480, /* (536) table_reference_list ::= table_reference */ - 480, /* (537) table_reference_list ::= table_reference_list NK_COMMA table_reference */ - 481, /* (538) table_reference ::= table_primary */ - 481, /* (539) table_reference ::= joined_table */ - 482, /* (540) table_primary ::= table_name alias_opt */ - 482, /* (541) table_primary ::= db_name NK_DOT table_name alias_opt */ - 482, /* (542) table_primary ::= subquery alias_opt */ - 482, /* (543) table_primary ::= parenthesized_joined_table */ - 484, /* (544) alias_opt ::= */ - 484, /* (545) alias_opt ::= table_alias */ - 484, /* (546) alias_opt ::= AS table_alias */ - 486, /* (547) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - 486, /* (548) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ - 483, /* (549) joined_table ::= table_reference join_type join_subtype JOIN table_reference ON search_condition window_offset_clause_opt jlimit_clause_opt */ - 487, /* (550) join_type ::= */ - 487, /* (551) join_type ::= INNER */ - 487, /* (552) join_type ::= LEFT */ - 487, /* (553) join_type ::= RIGHT */ - 487, /* (554) join_type ::= FULL */ - 488, /* (555) join_subtype ::= */ - 488, /* (556) join_subtype ::= OUTER */ - 488, /* (557) join_subtype ::= SEMI */ - 488, /* (558) join_subtype ::= ANTI */ - 488, /* (559) join_subtype ::= ANY */ - 488, /* (560) join_subtype ::= ASOF */ - 488, /* (561) join_subtype ::= WINDOW */ - 489, /* (562) window_offset_clause_opt ::= */ - 489, /* (563) window_offset_clause_opt ::= WINDOW_OFFSET NK_LP window_offset_literal NK_COMMA window_offset_literal NK_RP */ - 491, /* (564) window_offset_literal ::= NK_VARIABLE */ - 491, /* (565) window_offset_literal ::= NK_MINUS NK_VARIABLE */ - 490, /* (566) jlimit_clause_opt ::= */ - 490, /* (567) jlimit_clause_opt ::= JLIMIT NK_INTEGER */ - 492, /* (568) query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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 */ - 493, /* (569) hint_list ::= */ - 493, /* (570) hint_list ::= NK_HINT */ - 495, /* (571) tag_mode_opt ::= */ - 495, /* (572) tag_mode_opt ::= TAGS */ - 494, /* (573) set_quantifier_opt ::= */ - 494, /* (574) set_quantifier_opt ::= DISTINCT */ - 494, /* (575) set_quantifier_opt ::= ALL */ - 496, /* (576) select_list ::= select_item */ - 496, /* (577) select_list ::= select_list NK_COMMA select_item */ - 504, /* (578) select_item ::= NK_STAR */ - 504, /* (579) select_item ::= common_expression */ - 504, /* (580) select_item ::= common_expression column_alias */ - 504, /* (581) select_item ::= common_expression AS column_alias */ - 504, /* (582) select_item ::= table_name NK_DOT NK_STAR */ - 436, /* (583) where_clause_opt ::= */ - 436, /* (584) where_clause_opt ::= WHERE search_condition */ - 497, /* (585) partition_by_clause_opt ::= */ - 497, /* (586) partition_by_clause_opt ::= PARTITION BY partition_list */ - 505, /* (587) partition_list ::= partition_item */ - 505, /* (588) partition_list ::= partition_list NK_COMMA partition_item */ - 506, /* (589) partition_item ::= expr_or_subquery */ - 506, /* (590) partition_item ::= expr_or_subquery column_alias */ - 506, /* (591) partition_item ::= expr_or_subquery AS column_alias */ - 501, /* (592) twindow_clause_opt ::= */ - 501, /* (593) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP */ - 501, /* (594) twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ - 501, /* (595) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ - 501, /* (596) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ - 501, /* (597) twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ - 430, /* (598) sliding_opt ::= */ - 430, /* (599) sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP */ - 507, /* (600) interval_sliding_duration_literal ::= NK_VARIABLE */ - 507, /* (601) interval_sliding_duration_literal ::= NK_STRING */ - 507, /* (602) interval_sliding_duration_literal ::= NK_INTEGER */ - 500, /* (603) fill_opt ::= */ - 500, /* (604) fill_opt ::= FILL NK_LP fill_mode NK_RP */ - 500, /* (605) fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ - 500, /* (606) fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ - 508, /* (607) fill_mode ::= NONE */ - 508, /* (608) fill_mode ::= PREV */ - 508, /* (609) fill_mode ::= NULL */ - 508, /* (610) fill_mode ::= NULL_F */ - 508, /* (611) fill_mode ::= LINEAR */ - 508, /* (612) fill_mode ::= NEXT */ - 502, /* (613) group_by_clause_opt ::= */ - 502, /* (614) group_by_clause_opt ::= GROUP BY group_by_list */ - 509, /* (615) group_by_list ::= expr_or_subquery */ - 509, /* (616) group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ - 503, /* (617) having_clause_opt ::= */ - 503, /* (618) having_clause_opt ::= HAVING search_condition */ - 498, /* (619) range_opt ::= */ - 498, /* (620) range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ - 498, /* (621) range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ - 499, /* (622) every_opt ::= */ - 499, /* (623) every_opt ::= EVERY NK_LP duration_literal NK_RP */ - 510, /* (624) query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ - 511, /* (625) query_simple ::= query_specification */ - 511, /* (626) query_simple ::= union_query_expression */ - 515, /* (627) union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ - 515, /* (628) union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ - 516, /* (629) query_simple_or_subquery ::= query_simple */ - 516, /* (630) query_simple_or_subquery ::= subquery */ - 435, /* (631) query_or_subquery ::= query_expression */ - 435, /* (632) query_or_subquery ::= subquery */ - 512, /* (633) order_by_clause_opt ::= */ - 512, /* (634) order_by_clause_opt ::= ORDER BY sort_specification_list */ - 513, /* (635) slimit_clause_opt ::= */ - 513, /* (636) slimit_clause_opt ::= SLIMIT NK_INTEGER */ - 513, /* (637) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - 513, /* (638) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - 514, /* (639) limit_clause_opt ::= */ - 514, /* (640) limit_clause_opt ::= LIMIT NK_INTEGER */ - 514, /* (641) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ - 514, /* (642) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - 485, /* (643) subquery ::= NK_LP query_expression NK_RP */ - 485, /* (644) subquery ::= NK_LP subquery NK_RP */ - 374, /* (645) search_condition ::= common_expression */ - 517, /* (646) sort_specification_list ::= sort_specification */ - 517, /* (647) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ - 518, /* (648) sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ - 519, /* (649) ordering_specification_opt ::= */ - 519, /* (650) ordering_specification_opt ::= ASC */ - 519, /* (651) ordering_specification_opt ::= DESC */ - 520, /* (652) null_ordering_opt ::= */ - 520, /* (653) null_ordering_opt ::= NULLS FIRST */ - 520, /* (654) null_ordering_opt ::= NULLS LAST */ + 355, /* (0) cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */ + 355, /* (1) cmd ::= ALTER ACCOUNT NK_ID alter_account_options */ + 356, /* (2) account_options ::= */ + 356, /* (3) account_options ::= account_options PPS literal */ + 356, /* (4) account_options ::= account_options TSERIES literal */ + 356, /* (5) account_options ::= account_options STORAGE literal */ + 356, /* (6) account_options ::= account_options STREAMS literal */ + 356, /* (7) account_options ::= account_options QTIME literal */ + 356, /* (8) account_options ::= account_options DBS literal */ + 356, /* (9) account_options ::= account_options USERS literal */ + 356, /* (10) account_options ::= account_options CONNS literal */ + 356, /* (11) account_options ::= account_options STATE literal */ + 357, /* (12) alter_account_options ::= alter_account_option */ + 357, /* (13) alter_account_options ::= alter_account_options alter_account_option */ + 359, /* (14) alter_account_option ::= PASS literal */ + 359, /* (15) alter_account_option ::= PPS literal */ + 359, /* (16) alter_account_option ::= TSERIES literal */ + 359, /* (17) alter_account_option ::= STORAGE literal */ + 359, /* (18) alter_account_option ::= STREAMS literal */ + 359, /* (19) alter_account_option ::= QTIME literal */ + 359, /* (20) alter_account_option ::= DBS literal */ + 359, /* (21) alter_account_option ::= USERS literal */ + 359, /* (22) alter_account_option ::= CONNS literal */ + 359, /* (23) alter_account_option ::= STATE literal */ + 360, /* (24) ip_range_list ::= NK_STRING */ + 360, /* (25) ip_range_list ::= ip_range_list NK_COMMA NK_STRING */ + 361, /* (26) white_list ::= HOST ip_range_list */ + 362, /* (27) white_list_opt ::= */ + 362, /* (28) white_list_opt ::= white_list */ + 355, /* (29) cmd ::= CREATE USER user_name PASS NK_STRING sysinfo_opt white_list_opt */ + 355, /* (30) cmd ::= ALTER USER user_name PASS NK_STRING */ + 355, /* (31) cmd ::= ALTER USER user_name ENABLE NK_INTEGER */ + 355, /* (32) cmd ::= ALTER USER user_name SYSINFO NK_INTEGER */ + 355, /* (33) cmd ::= ALTER USER user_name ADD white_list */ + 355, /* (34) cmd ::= ALTER USER user_name DROP white_list */ + 355, /* (35) cmd ::= DROP USER user_name */ + 364, /* (36) sysinfo_opt ::= */ + 364, /* (37) sysinfo_opt ::= SYSINFO NK_INTEGER */ + 355, /* (38) cmd ::= GRANT privileges ON priv_level with_opt TO user_name */ + 355, /* (39) cmd ::= REVOKE privileges ON priv_level with_opt FROM user_name */ + 365, /* (40) privileges ::= ALL */ + 365, /* (41) privileges ::= priv_type_list */ + 365, /* (42) privileges ::= SUBSCRIBE */ + 368, /* (43) priv_type_list ::= priv_type */ + 368, /* (44) priv_type_list ::= priv_type_list NK_COMMA priv_type */ + 369, /* (45) priv_type ::= READ */ + 369, /* (46) priv_type ::= WRITE */ + 369, /* (47) priv_type ::= ALTER */ + 366, /* (48) priv_level ::= NK_STAR NK_DOT NK_STAR */ + 366, /* (49) priv_level ::= db_name NK_DOT NK_STAR */ + 366, /* (50) priv_level ::= db_name NK_DOT table_name */ + 366, /* (51) priv_level ::= topic_name */ + 367, /* (52) with_opt ::= */ + 367, /* (53) with_opt ::= WITH search_condition */ + 355, /* (54) cmd ::= CREATE DNODE dnode_endpoint */ + 355, /* (55) cmd ::= CREATE DNODE dnode_endpoint PORT NK_INTEGER */ + 355, /* (56) cmd ::= DROP DNODE NK_INTEGER force_opt */ + 355, /* (57) cmd ::= DROP DNODE dnode_endpoint force_opt */ + 355, /* (58) cmd ::= DROP DNODE NK_INTEGER unsafe_opt */ + 355, /* (59) cmd ::= DROP DNODE dnode_endpoint unsafe_opt */ + 355, /* (60) cmd ::= ALTER DNODE NK_INTEGER NK_STRING */ + 355, /* (61) cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */ + 355, /* (62) cmd ::= ALTER ALL DNODES NK_STRING */ + 355, /* (63) cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */ + 355, /* (64) cmd ::= RESTORE DNODE NK_INTEGER */ + 374, /* (65) dnode_endpoint ::= NK_STRING */ + 374, /* (66) dnode_endpoint ::= NK_ID */ + 374, /* (67) dnode_endpoint ::= NK_IPTOKEN */ + 375, /* (68) force_opt ::= */ + 375, /* (69) force_opt ::= FORCE */ + 376, /* (70) unsafe_opt ::= UNSAFE */ + 355, /* (71) cmd ::= ALTER LOCAL NK_STRING */ + 355, /* (72) cmd ::= ALTER LOCAL NK_STRING NK_STRING */ + 355, /* (73) cmd ::= CREATE QNODE ON DNODE NK_INTEGER */ + 355, /* (74) cmd ::= DROP QNODE ON DNODE NK_INTEGER */ + 355, /* (75) cmd ::= RESTORE QNODE ON DNODE NK_INTEGER */ + 355, /* (76) cmd ::= CREATE BNODE ON DNODE NK_INTEGER */ + 355, /* (77) cmd ::= DROP BNODE ON DNODE NK_INTEGER */ + 355, /* (78) cmd ::= CREATE SNODE ON DNODE NK_INTEGER */ + 355, /* (79) cmd ::= DROP SNODE ON DNODE NK_INTEGER */ + 355, /* (80) cmd ::= CREATE MNODE ON DNODE NK_INTEGER */ + 355, /* (81) cmd ::= DROP MNODE ON DNODE NK_INTEGER */ + 355, /* (82) cmd ::= RESTORE MNODE ON DNODE NK_INTEGER */ + 355, /* (83) cmd ::= RESTORE VNODE ON DNODE NK_INTEGER */ + 355, /* (84) cmd ::= CREATE DATABASE not_exists_opt db_name db_options */ + 355, /* (85) cmd ::= DROP DATABASE exists_opt db_name */ + 355, /* (86) cmd ::= USE db_name */ + 355, /* (87) cmd ::= ALTER DATABASE db_name alter_db_options */ + 355, /* (88) cmd ::= FLUSH DATABASE db_name */ + 355, /* (89) cmd ::= TRIM DATABASE db_name speed_opt */ + 355, /* (90) cmd ::= COMPACT DATABASE db_name start_opt end_opt */ + 377, /* (91) not_exists_opt ::= IF NOT EXISTS */ + 377, /* (92) not_exists_opt ::= */ + 379, /* (93) exists_opt ::= IF EXISTS */ + 379, /* (94) exists_opt ::= */ + 378, /* (95) db_options ::= */ + 378, /* (96) db_options ::= db_options BUFFER NK_INTEGER */ + 378, /* (97) db_options ::= db_options CACHEMODEL NK_STRING */ + 378, /* (98) db_options ::= db_options CACHESIZE NK_INTEGER */ + 378, /* (99) db_options ::= db_options COMP NK_INTEGER */ + 378, /* (100) db_options ::= db_options DURATION NK_INTEGER */ + 378, /* (101) db_options ::= db_options DURATION NK_VARIABLE */ + 378, /* (102) db_options ::= db_options MAXROWS NK_INTEGER */ + 378, /* (103) db_options ::= db_options MINROWS NK_INTEGER */ + 378, /* (104) db_options ::= db_options KEEP integer_list */ + 378, /* (105) db_options ::= db_options KEEP variable_list */ + 378, /* (106) db_options ::= db_options PAGES NK_INTEGER */ + 378, /* (107) db_options ::= db_options PAGESIZE NK_INTEGER */ + 378, /* (108) db_options ::= db_options TSDB_PAGESIZE NK_INTEGER */ + 378, /* (109) db_options ::= db_options PRECISION NK_STRING */ + 378, /* (110) db_options ::= db_options REPLICA NK_INTEGER */ + 378, /* (111) db_options ::= db_options VGROUPS NK_INTEGER */ + 378, /* (112) db_options ::= db_options SINGLE_STABLE NK_INTEGER */ + 378, /* (113) db_options ::= db_options RETENTIONS retention_list */ + 378, /* (114) db_options ::= db_options SCHEMALESS NK_INTEGER */ + 378, /* (115) db_options ::= db_options WAL_LEVEL NK_INTEGER */ + 378, /* (116) db_options ::= db_options WAL_FSYNC_PERIOD NK_INTEGER */ + 378, /* (117) db_options ::= db_options WAL_RETENTION_PERIOD NK_INTEGER */ + 378, /* (118) db_options ::= db_options WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ + 378, /* (119) db_options ::= db_options WAL_RETENTION_SIZE NK_INTEGER */ + 378, /* (120) db_options ::= db_options WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ + 378, /* (121) db_options ::= db_options WAL_ROLL_PERIOD NK_INTEGER */ + 378, /* (122) db_options ::= db_options WAL_SEGMENT_SIZE NK_INTEGER */ + 378, /* (123) db_options ::= db_options STT_TRIGGER NK_INTEGER */ + 378, /* (124) db_options ::= db_options TABLE_PREFIX signed */ + 378, /* (125) db_options ::= db_options TABLE_SUFFIX signed */ + 378, /* (126) db_options ::= db_options KEEP_TIME_OFFSET NK_INTEGER */ + 380, /* (127) alter_db_options ::= alter_db_option */ + 380, /* (128) alter_db_options ::= alter_db_options alter_db_option */ + 388, /* (129) alter_db_option ::= BUFFER NK_INTEGER */ + 388, /* (130) alter_db_option ::= CACHEMODEL NK_STRING */ + 388, /* (131) alter_db_option ::= CACHESIZE NK_INTEGER */ + 388, /* (132) alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */ + 388, /* (133) alter_db_option ::= KEEP integer_list */ + 388, /* (134) alter_db_option ::= KEEP variable_list */ + 388, /* (135) alter_db_option ::= PAGES NK_INTEGER */ + 388, /* (136) alter_db_option ::= REPLICA NK_INTEGER */ + 388, /* (137) alter_db_option ::= WAL_LEVEL NK_INTEGER */ + 388, /* (138) alter_db_option ::= STT_TRIGGER NK_INTEGER */ + 388, /* (139) alter_db_option ::= MINROWS NK_INTEGER */ + 388, /* (140) alter_db_option ::= WAL_RETENTION_PERIOD NK_INTEGER */ + 388, /* (141) alter_db_option ::= WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ + 388, /* (142) alter_db_option ::= WAL_RETENTION_SIZE NK_INTEGER */ + 388, /* (143) alter_db_option ::= WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ + 388, /* (144) alter_db_option ::= KEEP_TIME_OFFSET NK_INTEGER */ + 384, /* (145) integer_list ::= NK_INTEGER */ + 384, /* (146) integer_list ::= integer_list NK_COMMA NK_INTEGER */ + 385, /* (147) variable_list ::= NK_VARIABLE */ + 385, /* (148) variable_list ::= variable_list NK_COMMA NK_VARIABLE */ + 386, /* (149) retention_list ::= retention */ + 386, /* (150) retention_list ::= retention_list NK_COMMA retention */ + 389, /* (151) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ + 389, /* (152) retention ::= NK_MINUS NK_COLON NK_VARIABLE */ + 381, /* (153) speed_opt ::= */ + 381, /* (154) speed_opt ::= BWLIMIT NK_INTEGER */ + 382, /* (155) start_opt ::= */ + 382, /* (156) start_opt ::= START WITH NK_INTEGER */ + 382, /* (157) start_opt ::= START WITH NK_STRING */ + 382, /* (158) start_opt ::= START WITH TIMESTAMP NK_STRING */ + 383, /* (159) end_opt ::= */ + 383, /* (160) end_opt ::= END WITH NK_INTEGER */ + 383, /* (161) end_opt ::= END WITH NK_STRING */ + 383, /* (162) end_opt ::= END WITH TIMESTAMP NK_STRING */ + 355, /* (163) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ + 355, /* (164) cmd ::= CREATE TABLE multi_create_clause */ + 355, /* (165) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ + 355, /* (166) cmd ::= DROP TABLE multi_drop_clause */ + 355, /* (167) cmd ::= DROP STABLE exists_opt full_table_name */ + 355, /* (168) cmd ::= ALTER TABLE alter_table_clause */ + 355, /* (169) cmd ::= ALTER STABLE alter_table_clause */ + 397, /* (170) alter_table_clause ::= full_table_name alter_table_options */ + 397, /* (171) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ + 397, /* (172) alter_table_clause ::= full_table_name DROP COLUMN column_name */ + 397, /* (173) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ + 397, /* (174) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ + 397, /* (175) alter_table_clause ::= full_table_name ADD TAG column_name type_name */ + 397, /* (176) alter_table_clause ::= full_table_name DROP TAG column_name */ + 397, /* (177) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ + 397, /* (178) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ + 397, /* (179) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ + 394, /* (180) multi_create_clause ::= create_subtable_clause */ + 394, /* (181) multi_create_clause ::= multi_create_clause create_subtable_clause */ + 402, /* (182) 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 */ + 396, /* (183) multi_drop_clause ::= drop_table_clause */ + 396, /* (184) multi_drop_clause ::= multi_drop_clause NK_COMMA drop_table_clause */ + 405, /* (185) drop_table_clause ::= exists_opt full_table_name */ + 403, /* (186) specific_cols_opt ::= */ + 403, /* (187) specific_cols_opt ::= NK_LP col_name_list NK_RP */ + 390, /* (188) full_table_name ::= table_name */ + 390, /* (189) full_table_name ::= db_name NK_DOT table_name */ + 391, /* (190) column_def_list ::= column_def */ + 391, /* (191) column_def_list ::= column_def_list NK_COMMA column_def */ + 407, /* (192) column_def ::= column_name type_name */ + 400, /* (193) type_name ::= BOOL */ + 400, /* (194) type_name ::= TINYINT */ + 400, /* (195) type_name ::= SMALLINT */ + 400, /* (196) type_name ::= INT */ + 400, /* (197) type_name ::= INTEGER */ + 400, /* (198) type_name ::= BIGINT */ + 400, /* (199) type_name ::= FLOAT */ + 400, /* (200) type_name ::= DOUBLE */ + 400, /* (201) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ + 400, /* (202) type_name ::= TIMESTAMP */ + 400, /* (203) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ + 400, /* (204) type_name ::= TINYINT UNSIGNED */ + 400, /* (205) type_name ::= SMALLINT UNSIGNED */ + 400, /* (206) type_name ::= INT UNSIGNED */ + 400, /* (207) type_name ::= BIGINT UNSIGNED */ + 400, /* (208) type_name ::= JSON */ + 400, /* (209) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ + 400, /* (210) type_name ::= MEDIUMBLOB */ + 400, /* (211) type_name ::= BLOB */ + 400, /* (212) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ + 400, /* (213) type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP */ + 400, /* (214) type_name ::= DECIMAL */ + 400, /* (215) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ + 400, /* (216) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ + 392, /* (217) tags_def_opt ::= */ + 392, /* (218) tags_def_opt ::= tags_def */ + 395, /* (219) tags_def ::= TAGS NK_LP column_def_list NK_RP */ + 393, /* (220) table_options ::= */ + 393, /* (221) table_options ::= table_options COMMENT NK_STRING */ + 393, /* (222) table_options ::= table_options MAX_DELAY duration_list */ + 393, /* (223) table_options ::= table_options WATERMARK duration_list */ + 393, /* (224) table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ + 393, /* (225) table_options ::= table_options TTL NK_INTEGER */ + 393, /* (226) table_options ::= table_options SMA NK_LP col_name_list NK_RP */ + 393, /* (227) table_options ::= table_options DELETE_MARK duration_list */ + 398, /* (228) alter_table_options ::= alter_table_option */ + 398, /* (229) alter_table_options ::= alter_table_options alter_table_option */ + 410, /* (230) alter_table_option ::= COMMENT NK_STRING */ + 410, /* (231) alter_table_option ::= TTL NK_INTEGER */ + 408, /* (232) duration_list ::= duration_literal */ + 408, /* (233) duration_list ::= duration_list NK_COMMA duration_literal */ + 409, /* (234) rollup_func_list ::= rollup_func_name */ + 409, /* (235) rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ + 412, /* (236) rollup_func_name ::= function_name */ + 412, /* (237) rollup_func_name ::= FIRST */ + 412, /* (238) rollup_func_name ::= LAST */ + 406, /* (239) col_name_list ::= col_name */ + 406, /* (240) col_name_list ::= col_name_list NK_COMMA col_name */ + 414, /* (241) col_name ::= column_name */ + 355, /* (242) cmd ::= SHOW DNODES */ + 355, /* (243) cmd ::= SHOW USERS */ + 355, /* (244) cmd ::= SHOW USER PRIVILEGES */ + 355, /* (245) cmd ::= SHOW db_kind_opt DATABASES */ + 355, /* (246) cmd ::= SHOW table_kind_db_name_cond_opt TABLES like_pattern_opt */ + 355, /* (247) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ + 355, /* (248) cmd ::= SHOW db_name_cond_opt VGROUPS */ + 355, /* (249) cmd ::= SHOW MNODES */ + 355, /* (250) cmd ::= SHOW QNODES */ + 355, /* (251) cmd ::= SHOW FUNCTIONS */ + 355, /* (252) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ + 355, /* (253) cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */ + 355, /* (254) cmd ::= SHOW STREAMS */ + 355, /* (255) cmd ::= SHOW ACCOUNTS */ + 355, /* (256) cmd ::= SHOW APPS */ + 355, /* (257) cmd ::= SHOW CONNECTIONS */ + 355, /* (258) cmd ::= SHOW LICENCES */ + 355, /* (259) cmd ::= SHOW GRANTS */ + 355, /* (260) cmd ::= SHOW CREATE DATABASE db_name */ + 355, /* (261) cmd ::= SHOW CREATE TABLE full_table_name */ + 355, /* (262) cmd ::= SHOW CREATE STABLE full_table_name */ + 355, /* (263) cmd ::= SHOW QUERIES */ + 355, /* (264) cmd ::= SHOW SCORES */ + 355, /* (265) cmd ::= SHOW TOPICS */ + 355, /* (266) cmd ::= SHOW VARIABLES */ + 355, /* (267) cmd ::= SHOW CLUSTER VARIABLES */ + 355, /* (268) cmd ::= SHOW LOCAL VARIABLES */ + 355, /* (269) cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */ + 355, /* (270) cmd ::= SHOW BNODES */ + 355, /* (271) cmd ::= SHOW SNODES */ + 355, /* (272) cmd ::= SHOW CLUSTER */ + 355, /* (273) cmd ::= SHOW TRANSACTIONS */ + 355, /* (274) cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ + 355, /* (275) cmd ::= SHOW CONSUMERS */ + 355, /* (276) cmd ::= SHOW SUBSCRIPTIONS */ + 355, /* (277) cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ + 355, /* (278) cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */ + 355, /* (279) cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */ + 355, /* (280) cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */ + 355, /* (281) cmd ::= SHOW VNODES ON DNODE NK_INTEGER */ + 355, /* (282) cmd ::= SHOW VNODES */ + 355, /* (283) cmd ::= SHOW db_name_cond_opt ALIVE */ + 355, /* (284) cmd ::= SHOW CLUSTER ALIVE */ + 355, /* (285) cmd ::= SHOW db_name_cond_opt VIEWS */ + 355, /* (286) cmd ::= SHOW CREATE VIEW full_table_name */ + 416, /* (287) table_kind_db_name_cond_opt ::= */ + 416, /* (288) table_kind_db_name_cond_opt ::= table_kind */ + 416, /* (289) table_kind_db_name_cond_opt ::= db_name NK_DOT */ + 416, /* (290) table_kind_db_name_cond_opt ::= table_kind db_name NK_DOT */ + 422, /* (291) table_kind ::= NORMAL */ + 422, /* (292) table_kind ::= CHILD */ + 418, /* (293) db_name_cond_opt ::= */ + 418, /* (294) db_name_cond_opt ::= db_name NK_DOT */ + 417, /* (295) like_pattern_opt ::= */ + 417, /* (296) like_pattern_opt ::= LIKE NK_STRING */ + 419, /* (297) table_name_cond ::= table_name */ + 420, /* (298) from_db_opt ::= */ + 420, /* (299) from_db_opt ::= FROM db_name */ + 421, /* (300) tag_list_opt ::= */ + 421, /* (301) tag_list_opt ::= tag_item */ + 421, /* (302) tag_list_opt ::= tag_list_opt NK_COMMA tag_item */ + 423, /* (303) tag_item ::= TBNAME */ + 423, /* (304) tag_item ::= QTAGS */ + 423, /* (305) tag_item ::= column_name */ + 423, /* (306) tag_item ::= column_name column_alias */ + 423, /* (307) tag_item ::= column_name AS column_alias */ + 415, /* (308) db_kind_opt ::= */ + 415, /* (309) db_kind_opt ::= USER */ + 415, /* (310) db_kind_opt ::= SYSTEM */ + 355, /* (311) cmd ::= CREATE SMA INDEX not_exists_opt col_name ON full_table_name index_options */ + 355, /* (312) cmd ::= CREATE INDEX not_exists_opt col_name ON full_table_name NK_LP col_name_list NK_RP */ + 355, /* (313) cmd ::= DROP INDEX exists_opt full_index_name */ + 426, /* (314) full_index_name ::= index_name */ + 426, /* (315) full_index_name ::= db_name NK_DOT index_name */ + 425, /* (316) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ + 425, /* (317) 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 */ + 428, /* (318) func_list ::= func */ + 428, /* (319) func_list ::= func_list NK_COMMA func */ + 431, /* (320) func ::= sma_func_name NK_LP expression_list NK_RP */ + 432, /* (321) sma_func_name ::= function_name */ + 432, /* (322) sma_func_name ::= COUNT */ + 432, /* (323) sma_func_name ::= FIRST */ + 432, /* (324) sma_func_name ::= LAST */ + 432, /* (325) sma_func_name ::= LAST_ROW */ + 430, /* (326) sma_stream_opt ::= */ + 430, /* (327) sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */ + 430, /* (328) sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */ + 430, /* (329) sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */ + 433, /* (330) with_meta ::= AS */ + 433, /* (331) with_meta ::= WITH META AS */ + 433, /* (332) with_meta ::= ONLY META AS */ + 355, /* (333) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */ + 355, /* (334) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */ + 355, /* (335) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */ + 355, /* (336) cmd ::= DROP TOPIC exists_opt topic_name */ + 355, /* (337) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ + 355, /* (338) cmd ::= DESC full_table_name */ + 355, /* (339) cmd ::= DESCRIBE full_table_name */ + 355, /* (340) cmd ::= RESET QUERY CACHE */ + 355, /* (341) cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */ + 355, /* (342) cmd ::= EXPLAIN analyze_opt explain_options insert_query */ + 437, /* (343) analyze_opt ::= */ + 437, /* (344) analyze_opt ::= ANALYZE */ + 438, /* (345) explain_options ::= */ + 438, /* (346) explain_options ::= explain_options VERBOSE NK_BOOL */ + 438, /* (347) explain_options ::= explain_options RATIO NK_FLOAT */ + 355, /* (348) cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */ + 355, /* (349) cmd ::= DROP FUNCTION exists_opt function_name */ + 441, /* (350) agg_func_opt ::= */ + 441, /* (351) agg_func_opt ::= AGGREGATE */ + 442, /* (352) bufsize_opt ::= */ + 442, /* (353) bufsize_opt ::= BUFSIZE NK_INTEGER */ + 443, /* (354) language_opt ::= */ + 443, /* (355) language_opt ::= LANGUAGE NK_STRING */ + 440, /* (356) or_replace_opt ::= */ + 440, /* (357) or_replace_opt ::= OR REPLACE */ + 355, /* (358) cmd ::= CREATE or_replace_opt VIEW full_view_name AS query_or_subquery */ + 355, /* (359) cmd ::= DROP VIEW exists_opt full_view_name */ + 444, /* (360) full_view_name ::= view_name */ + 444, /* (361) full_view_name ::= db_name NK_DOT view_name */ + 355, /* (362) 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 */ + 355, /* (363) cmd ::= DROP STREAM exists_opt stream_name */ + 355, /* (364) cmd ::= PAUSE STREAM exists_opt stream_name */ + 355, /* (365) cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */ + 448, /* (366) col_list_opt ::= */ + 448, /* (367) col_list_opt ::= NK_LP col_name_list NK_RP */ + 449, /* (368) tag_def_or_ref_opt ::= */ + 449, /* (369) tag_def_or_ref_opt ::= tags_def */ + 449, /* (370) tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP */ + 447, /* (371) stream_options ::= */ + 447, /* (372) stream_options ::= stream_options TRIGGER AT_ONCE */ + 447, /* (373) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ + 447, /* (374) stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ + 447, /* (375) stream_options ::= stream_options WATERMARK duration_literal */ + 447, /* (376) stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ + 447, /* (377) stream_options ::= stream_options FILL_HISTORY NK_INTEGER */ + 447, /* (378) stream_options ::= stream_options DELETE_MARK duration_literal */ + 447, /* (379) stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */ + 450, /* (380) subtable_opt ::= */ + 450, /* (381) subtable_opt ::= SUBTABLE NK_LP expression NK_RP */ + 451, /* (382) ignore_opt ::= */ + 451, /* (383) ignore_opt ::= IGNORE UNTREATED */ + 355, /* (384) cmd ::= KILL CONNECTION NK_INTEGER */ + 355, /* (385) cmd ::= KILL QUERY NK_STRING */ + 355, /* (386) cmd ::= KILL TRANSACTION NK_INTEGER */ + 355, /* (387) cmd ::= BALANCE VGROUP */ + 355, /* (388) cmd ::= BALANCE VGROUP LEADER on_vgroup_id */ + 355, /* (389) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ + 355, /* (390) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ + 355, /* (391) cmd ::= SPLIT VGROUP NK_INTEGER */ + 453, /* (392) on_vgroup_id ::= */ + 453, /* (393) on_vgroup_id ::= ON NK_INTEGER */ + 454, /* (394) dnode_list ::= DNODE NK_INTEGER */ + 454, /* (395) dnode_list ::= dnode_list DNODE NK_INTEGER */ + 355, /* (396) cmd ::= DELETE FROM full_table_name where_clause_opt */ + 355, /* (397) cmd ::= query_or_subquery */ + 355, /* (398) cmd ::= insert_query */ + 439, /* (399) insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */ + 439, /* (400) insert_query ::= INSERT INTO full_table_name query_or_subquery */ + 358, /* (401) literal ::= NK_INTEGER */ + 358, /* (402) literal ::= NK_FLOAT */ + 358, /* (403) literal ::= NK_STRING */ + 358, /* (404) literal ::= NK_BOOL */ + 358, /* (405) literal ::= TIMESTAMP NK_STRING */ + 358, /* (406) literal ::= duration_literal */ + 358, /* (407) literal ::= NULL */ + 358, /* (408) literal ::= NK_QUESTION */ + 411, /* (409) duration_literal ::= NK_VARIABLE */ + 387, /* (410) signed ::= NK_INTEGER */ + 387, /* (411) signed ::= NK_PLUS NK_INTEGER */ + 387, /* (412) signed ::= NK_MINUS NK_INTEGER */ + 387, /* (413) signed ::= NK_FLOAT */ + 387, /* (414) signed ::= NK_PLUS NK_FLOAT */ + 387, /* (415) signed ::= NK_MINUS NK_FLOAT */ + 401, /* (416) signed_literal ::= signed */ + 401, /* (417) signed_literal ::= NK_STRING */ + 401, /* (418) signed_literal ::= NK_BOOL */ + 401, /* (419) signed_literal ::= TIMESTAMP NK_STRING */ + 401, /* (420) signed_literal ::= duration_literal */ + 401, /* (421) signed_literal ::= NULL */ + 401, /* (422) signed_literal ::= literal_func */ + 401, /* (423) signed_literal ::= NK_QUESTION */ + 456, /* (424) literal_list ::= signed_literal */ + 456, /* (425) literal_list ::= literal_list NK_COMMA signed_literal */ + 370, /* (426) db_name ::= NK_ID */ + 371, /* (427) table_name ::= NK_ID */ + 399, /* (428) column_name ::= NK_ID */ + 413, /* (429) function_name ::= NK_ID */ + 445, /* (430) view_name ::= NK_ID */ + 457, /* (431) table_alias ::= NK_ID */ + 424, /* (432) column_alias ::= NK_ID */ + 424, /* (433) column_alias ::= NK_ALIAS */ + 363, /* (434) user_name ::= NK_ID */ + 372, /* (435) topic_name ::= NK_ID */ + 446, /* (436) stream_name ::= NK_ID */ + 436, /* (437) cgroup_name ::= NK_ID */ + 427, /* (438) index_name ::= NK_ID */ + 458, /* (439) expr_or_subquery ::= expression */ + 452, /* (440) expression ::= literal */ + 452, /* (441) expression ::= pseudo_column */ + 452, /* (442) expression ::= column_reference */ + 452, /* (443) expression ::= function_expression */ + 452, /* (444) expression ::= case_when_expression */ + 452, /* (445) expression ::= NK_LP expression NK_RP */ + 452, /* (446) expression ::= NK_PLUS expr_or_subquery */ + 452, /* (447) expression ::= NK_MINUS expr_or_subquery */ + 452, /* (448) expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ + 452, /* (449) expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ + 452, /* (450) expression ::= expr_or_subquery NK_STAR expr_or_subquery */ + 452, /* (451) expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ + 452, /* (452) expression ::= expr_or_subquery NK_REM expr_or_subquery */ + 452, /* (453) expression ::= column_reference NK_ARROW NK_STRING */ + 452, /* (454) expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ + 452, /* (455) expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ + 404, /* (456) expression_list ::= expr_or_subquery */ + 404, /* (457) expression_list ::= expression_list NK_COMMA expr_or_subquery */ + 460, /* (458) column_reference ::= column_name */ + 460, /* (459) column_reference ::= table_name NK_DOT column_name */ + 460, /* (460) column_reference ::= NK_ALIAS */ + 460, /* (461) column_reference ::= table_name NK_DOT NK_ALIAS */ + 459, /* (462) pseudo_column ::= ROWTS */ + 459, /* (463) pseudo_column ::= TBNAME */ + 459, /* (464) pseudo_column ::= table_name NK_DOT TBNAME */ + 459, /* (465) pseudo_column ::= QSTART */ + 459, /* (466) pseudo_column ::= QEND */ + 459, /* (467) pseudo_column ::= QDURATION */ + 459, /* (468) pseudo_column ::= WSTART */ + 459, /* (469) pseudo_column ::= WEND */ + 459, /* (470) pseudo_column ::= WDURATION */ + 459, /* (471) pseudo_column ::= IROWTS */ + 459, /* (472) pseudo_column ::= ISFILLED */ + 459, /* (473) pseudo_column ::= QTAGS */ + 461, /* (474) function_expression ::= function_name NK_LP expression_list NK_RP */ + 461, /* (475) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ + 461, /* (476) function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ + 461, /* (477) function_expression ::= literal_func */ + 455, /* (478) literal_func ::= noarg_func NK_LP NK_RP */ + 455, /* (479) literal_func ::= NOW */ + 465, /* (480) noarg_func ::= NOW */ + 465, /* (481) noarg_func ::= TODAY */ + 465, /* (482) noarg_func ::= TIMEZONE */ + 465, /* (483) noarg_func ::= DATABASE */ + 465, /* (484) noarg_func ::= CLIENT_VERSION */ + 465, /* (485) noarg_func ::= SERVER_VERSION */ + 465, /* (486) noarg_func ::= SERVER_STATUS */ + 465, /* (487) noarg_func ::= CURRENT_USER */ + 465, /* (488) noarg_func ::= USER */ + 463, /* (489) star_func ::= COUNT */ + 463, /* (490) star_func ::= FIRST */ + 463, /* (491) star_func ::= LAST */ + 463, /* (492) star_func ::= LAST_ROW */ + 464, /* (493) star_func_para_list ::= NK_STAR */ + 464, /* (494) star_func_para_list ::= other_para_list */ + 466, /* (495) other_para_list ::= star_func_para */ + 466, /* (496) other_para_list ::= other_para_list NK_COMMA star_func_para */ + 467, /* (497) star_func_para ::= expr_or_subquery */ + 467, /* (498) star_func_para ::= table_name NK_DOT NK_STAR */ + 462, /* (499) case_when_expression ::= CASE when_then_list case_when_else_opt END */ + 462, /* (500) case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ + 468, /* (501) when_then_list ::= when_then_expr */ + 468, /* (502) when_then_list ::= when_then_list when_then_expr */ + 471, /* (503) when_then_expr ::= WHEN common_expression THEN common_expression */ + 469, /* (504) case_when_else_opt ::= */ + 469, /* (505) case_when_else_opt ::= ELSE common_expression */ + 472, /* (506) predicate ::= expr_or_subquery compare_op expr_or_subquery */ + 472, /* (507) predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ + 472, /* (508) predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ + 472, /* (509) predicate ::= expr_or_subquery IS NULL */ + 472, /* (510) predicate ::= expr_or_subquery IS NOT NULL */ + 472, /* (511) predicate ::= expr_or_subquery in_op in_predicate_value */ + 473, /* (512) compare_op ::= NK_LT */ + 473, /* (513) compare_op ::= NK_GT */ + 473, /* (514) compare_op ::= NK_LE */ + 473, /* (515) compare_op ::= NK_GE */ + 473, /* (516) compare_op ::= NK_NE */ + 473, /* (517) compare_op ::= NK_EQ */ + 473, /* (518) compare_op ::= LIKE */ + 473, /* (519) compare_op ::= NOT LIKE */ + 473, /* (520) compare_op ::= MATCH */ + 473, /* (521) compare_op ::= NMATCH */ + 473, /* (522) compare_op ::= CONTAINS */ + 474, /* (523) in_op ::= IN */ + 474, /* (524) in_op ::= NOT IN */ + 475, /* (525) in_predicate_value ::= NK_LP literal_list NK_RP */ + 476, /* (526) boolean_value_expression ::= boolean_primary */ + 476, /* (527) boolean_value_expression ::= NOT boolean_primary */ + 476, /* (528) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ + 476, /* (529) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ + 477, /* (530) boolean_primary ::= predicate */ + 477, /* (531) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ + 470, /* (532) common_expression ::= expr_or_subquery */ + 470, /* (533) common_expression ::= boolean_value_expression */ + 478, /* (534) from_clause_opt ::= */ + 478, /* (535) from_clause_opt ::= FROM table_reference_list */ + 479, /* (536) table_reference_list ::= table_reference */ + 479, /* (537) table_reference_list ::= table_reference_list NK_COMMA table_reference */ + 480, /* (538) table_reference ::= table_primary */ + 480, /* (539) table_reference ::= joined_table */ + 481, /* (540) table_primary ::= table_name alias_opt */ + 481, /* (541) table_primary ::= db_name NK_DOT table_name alias_opt */ + 481, /* (542) table_primary ::= subquery alias_opt */ + 481, /* (543) table_primary ::= parenthesized_joined_table */ + 483, /* (544) alias_opt ::= */ + 483, /* (545) alias_opt ::= table_alias */ + 483, /* (546) alias_opt ::= AS table_alias */ + 485, /* (547) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ + 485, /* (548) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ + 482, /* (549) joined_table ::= table_reference join_type join_subtype JOIN table_reference ON search_condition window_offset_clause_opt jlimit_clause_opt */ + 486, /* (550) join_type ::= */ + 486, /* (551) join_type ::= INNER */ + 486, /* (552) join_type ::= LEFT */ + 486, /* (553) join_type ::= RIGHT */ + 486, /* (554) join_type ::= FULL */ + 487, /* (555) join_subtype ::= */ + 487, /* (556) join_subtype ::= OUTER */ + 487, /* (557) join_subtype ::= SEMI */ + 487, /* (558) join_subtype ::= ANTI */ + 487, /* (559) join_subtype ::= ASOF */ + 487, /* (560) join_subtype ::= WINDOW */ + 488, /* (561) window_offset_clause_opt ::= */ + 488, /* (562) window_offset_clause_opt ::= WINDOW_OFFSET NK_LP window_offset_literal NK_COMMA window_offset_literal NK_RP */ + 490, /* (563) window_offset_literal ::= NK_VARIABLE */ + 490, /* (564) window_offset_literal ::= NK_MINUS NK_VARIABLE */ + 489, /* (565) jlimit_clause_opt ::= */ + 489, /* (566) jlimit_clause_opt ::= JLIMIT NK_INTEGER */ + 491, /* (567) query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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 */ + 492, /* (568) hint_list ::= */ + 492, /* (569) hint_list ::= NK_HINT */ + 494, /* (570) tag_mode_opt ::= */ + 494, /* (571) tag_mode_opt ::= TAGS */ + 493, /* (572) set_quantifier_opt ::= */ + 493, /* (573) set_quantifier_opt ::= DISTINCT */ + 493, /* (574) set_quantifier_opt ::= ALL */ + 495, /* (575) select_list ::= select_item */ + 495, /* (576) select_list ::= select_list NK_COMMA select_item */ + 503, /* (577) select_item ::= NK_STAR */ + 503, /* (578) select_item ::= common_expression */ + 503, /* (579) select_item ::= common_expression column_alias */ + 503, /* (580) select_item ::= common_expression AS column_alias */ + 503, /* (581) select_item ::= table_name NK_DOT NK_STAR */ + 435, /* (582) where_clause_opt ::= */ + 435, /* (583) where_clause_opt ::= WHERE search_condition */ + 496, /* (584) partition_by_clause_opt ::= */ + 496, /* (585) partition_by_clause_opt ::= PARTITION BY partition_list */ + 504, /* (586) partition_list ::= partition_item */ + 504, /* (587) partition_list ::= partition_list NK_COMMA partition_item */ + 505, /* (588) partition_item ::= expr_or_subquery */ + 505, /* (589) partition_item ::= expr_or_subquery column_alias */ + 505, /* (590) partition_item ::= expr_or_subquery AS column_alias */ + 500, /* (591) twindow_clause_opt ::= */ + 500, /* (592) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP */ + 500, /* (593) twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ + 500, /* (594) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ + 500, /* (595) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ + 500, /* (596) twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ + 429, /* (597) sliding_opt ::= */ + 429, /* (598) sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP */ + 506, /* (599) interval_sliding_duration_literal ::= NK_VARIABLE */ + 506, /* (600) interval_sliding_duration_literal ::= NK_STRING */ + 506, /* (601) interval_sliding_duration_literal ::= NK_INTEGER */ + 499, /* (602) fill_opt ::= */ + 499, /* (603) fill_opt ::= FILL NK_LP fill_mode NK_RP */ + 499, /* (604) fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ + 499, /* (605) fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ + 507, /* (606) fill_mode ::= NONE */ + 507, /* (607) fill_mode ::= PREV */ + 507, /* (608) fill_mode ::= NULL */ + 507, /* (609) fill_mode ::= NULL_F */ + 507, /* (610) fill_mode ::= LINEAR */ + 507, /* (611) fill_mode ::= NEXT */ + 501, /* (612) group_by_clause_opt ::= */ + 501, /* (613) group_by_clause_opt ::= GROUP BY group_by_list */ + 508, /* (614) group_by_list ::= expr_or_subquery */ + 508, /* (615) group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ + 502, /* (616) having_clause_opt ::= */ + 502, /* (617) having_clause_opt ::= HAVING search_condition */ + 497, /* (618) range_opt ::= */ + 497, /* (619) range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ + 497, /* (620) range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ + 498, /* (621) every_opt ::= */ + 498, /* (622) every_opt ::= EVERY NK_LP duration_literal NK_RP */ + 509, /* (623) query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ + 510, /* (624) query_simple ::= query_specification */ + 510, /* (625) query_simple ::= union_query_expression */ + 514, /* (626) union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ + 514, /* (627) union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ + 515, /* (628) query_simple_or_subquery ::= query_simple */ + 515, /* (629) query_simple_or_subquery ::= subquery */ + 434, /* (630) query_or_subquery ::= query_expression */ + 434, /* (631) query_or_subquery ::= subquery */ + 511, /* (632) order_by_clause_opt ::= */ + 511, /* (633) order_by_clause_opt ::= ORDER BY sort_specification_list */ + 512, /* (634) slimit_clause_opt ::= */ + 512, /* (635) slimit_clause_opt ::= SLIMIT NK_INTEGER */ + 512, /* (636) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + 512, /* (637) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + 513, /* (638) limit_clause_opt ::= */ + 513, /* (639) limit_clause_opt ::= LIMIT NK_INTEGER */ + 513, /* (640) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ + 513, /* (641) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + 484, /* (642) subquery ::= NK_LP query_expression NK_RP */ + 484, /* (643) subquery ::= NK_LP subquery NK_RP */ + 373, /* (644) search_condition ::= common_expression */ + 516, /* (645) sort_specification_list ::= sort_specification */ + 516, /* (646) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ + 517, /* (647) sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ + 518, /* (648) ordering_specification_opt ::= */ + 518, /* (649) ordering_specification_opt ::= ASC */ + 518, /* (650) ordering_specification_opt ::= DESC */ + 519, /* (651) null_ordering_opt ::= */ + 519, /* (652) null_ordering_opt ::= NULLS FIRST */ + 519, /* (653) null_ordering_opt ::= NULLS LAST */ }; /* For rule J, yyRuleInfoNRhs[J] contains the negative of the number @@ -4661,102 +4635,101 @@ static const signed char yyRuleInfoNRhs[] = { -1, /* (556) join_subtype ::= OUTER */ -1, /* (557) join_subtype ::= SEMI */ -1, /* (558) join_subtype ::= ANTI */ - -1, /* (559) join_subtype ::= ANY */ - -1, /* (560) join_subtype ::= ASOF */ - -1, /* (561) join_subtype ::= WINDOW */ - 0, /* (562) window_offset_clause_opt ::= */ - -6, /* (563) window_offset_clause_opt ::= WINDOW_OFFSET NK_LP window_offset_literal NK_COMMA window_offset_literal NK_RP */ - -1, /* (564) window_offset_literal ::= NK_VARIABLE */ - -2, /* (565) window_offset_literal ::= NK_MINUS NK_VARIABLE */ - 0, /* (566) jlimit_clause_opt ::= */ - -2, /* (567) jlimit_clause_opt ::= JLIMIT NK_INTEGER */ - -14, /* (568) query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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 */ - 0, /* (569) hint_list ::= */ - -1, /* (570) hint_list ::= NK_HINT */ - 0, /* (571) tag_mode_opt ::= */ - -1, /* (572) tag_mode_opt ::= TAGS */ - 0, /* (573) set_quantifier_opt ::= */ - -1, /* (574) set_quantifier_opt ::= DISTINCT */ - -1, /* (575) set_quantifier_opt ::= ALL */ - -1, /* (576) select_list ::= select_item */ - -3, /* (577) select_list ::= select_list NK_COMMA select_item */ - -1, /* (578) select_item ::= NK_STAR */ - -1, /* (579) select_item ::= common_expression */ - -2, /* (580) select_item ::= common_expression column_alias */ - -3, /* (581) select_item ::= common_expression AS column_alias */ - -3, /* (582) select_item ::= table_name NK_DOT NK_STAR */ - 0, /* (583) where_clause_opt ::= */ - -2, /* (584) where_clause_opt ::= WHERE search_condition */ - 0, /* (585) partition_by_clause_opt ::= */ - -3, /* (586) partition_by_clause_opt ::= PARTITION BY partition_list */ - -1, /* (587) partition_list ::= partition_item */ - -3, /* (588) partition_list ::= partition_list NK_COMMA partition_item */ - -1, /* (589) partition_item ::= expr_or_subquery */ - -2, /* (590) partition_item ::= expr_or_subquery column_alias */ - -3, /* (591) partition_item ::= expr_or_subquery AS column_alias */ - 0, /* (592) twindow_clause_opt ::= */ - -6, /* (593) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP */ - -4, /* (594) twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ - -6, /* (595) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ - -8, /* (596) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ - -7, /* (597) twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ - 0, /* (598) sliding_opt ::= */ - -4, /* (599) sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP */ - -1, /* (600) interval_sliding_duration_literal ::= NK_VARIABLE */ - -1, /* (601) interval_sliding_duration_literal ::= NK_STRING */ - -1, /* (602) interval_sliding_duration_literal ::= NK_INTEGER */ - 0, /* (603) fill_opt ::= */ - -4, /* (604) fill_opt ::= FILL NK_LP fill_mode NK_RP */ - -6, /* (605) fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ - -6, /* (606) fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ - -1, /* (607) fill_mode ::= NONE */ - -1, /* (608) fill_mode ::= PREV */ - -1, /* (609) fill_mode ::= NULL */ - -1, /* (610) fill_mode ::= NULL_F */ - -1, /* (611) fill_mode ::= LINEAR */ - -1, /* (612) fill_mode ::= NEXT */ - 0, /* (613) group_by_clause_opt ::= */ - -3, /* (614) group_by_clause_opt ::= GROUP BY group_by_list */ - -1, /* (615) group_by_list ::= expr_or_subquery */ - -3, /* (616) group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ - 0, /* (617) having_clause_opt ::= */ - -2, /* (618) having_clause_opt ::= HAVING search_condition */ - 0, /* (619) range_opt ::= */ - -6, /* (620) range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ - -4, /* (621) range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ - 0, /* (622) every_opt ::= */ - -4, /* (623) every_opt ::= EVERY NK_LP duration_literal NK_RP */ - -4, /* (624) query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ - -1, /* (625) query_simple ::= query_specification */ - -1, /* (626) query_simple ::= union_query_expression */ - -4, /* (627) union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ - -3, /* (628) union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ - -1, /* (629) query_simple_or_subquery ::= query_simple */ - -1, /* (630) query_simple_or_subquery ::= subquery */ - -1, /* (631) query_or_subquery ::= query_expression */ - -1, /* (632) query_or_subquery ::= subquery */ - 0, /* (633) order_by_clause_opt ::= */ - -3, /* (634) order_by_clause_opt ::= ORDER BY sort_specification_list */ - 0, /* (635) slimit_clause_opt ::= */ - -2, /* (636) slimit_clause_opt ::= SLIMIT NK_INTEGER */ - -4, /* (637) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - -4, /* (638) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - 0, /* (639) limit_clause_opt ::= */ - -2, /* (640) limit_clause_opt ::= LIMIT NK_INTEGER */ - -4, /* (641) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ - -4, /* (642) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - -3, /* (643) subquery ::= NK_LP query_expression NK_RP */ - -3, /* (644) subquery ::= NK_LP subquery NK_RP */ - -1, /* (645) search_condition ::= common_expression */ - -1, /* (646) sort_specification_list ::= sort_specification */ - -3, /* (647) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ - -3, /* (648) sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ - 0, /* (649) ordering_specification_opt ::= */ - -1, /* (650) ordering_specification_opt ::= ASC */ - -1, /* (651) ordering_specification_opt ::= DESC */ - 0, /* (652) null_ordering_opt ::= */ - -2, /* (653) null_ordering_opt ::= NULLS FIRST */ - -2, /* (654) null_ordering_opt ::= NULLS LAST */ + -1, /* (559) join_subtype ::= ASOF */ + -1, /* (560) join_subtype ::= WINDOW */ + 0, /* (561) window_offset_clause_opt ::= */ + -6, /* (562) window_offset_clause_opt ::= WINDOW_OFFSET NK_LP window_offset_literal NK_COMMA window_offset_literal NK_RP */ + -1, /* (563) window_offset_literal ::= NK_VARIABLE */ + -2, /* (564) window_offset_literal ::= NK_MINUS NK_VARIABLE */ + 0, /* (565) jlimit_clause_opt ::= */ + -2, /* (566) jlimit_clause_opt ::= JLIMIT NK_INTEGER */ + -14, /* (567) query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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 */ + 0, /* (568) hint_list ::= */ + -1, /* (569) hint_list ::= NK_HINT */ + 0, /* (570) tag_mode_opt ::= */ + -1, /* (571) tag_mode_opt ::= TAGS */ + 0, /* (572) set_quantifier_opt ::= */ + -1, /* (573) set_quantifier_opt ::= DISTINCT */ + -1, /* (574) set_quantifier_opt ::= ALL */ + -1, /* (575) select_list ::= select_item */ + -3, /* (576) select_list ::= select_list NK_COMMA select_item */ + -1, /* (577) select_item ::= NK_STAR */ + -1, /* (578) select_item ::= common_expression */ + -2, /* (579) select_item ::= common_expression column_alias */ + -3, /* (580) select_item ::= common_expression AS column_alias */ + -3, /* (581) select_item ::= table_name NK_DOT NK_STAR */ + 0, /* (582) where_clause_opt ::= */ + -2, /* (583) where_clause_opt ::= WHERE search_condition */ + 0, /* (584) partition_by_clause_opt ::= */ + -3, /* (585) partition_by_clause_opt ::= PARTITION BY partition_list */ + -1, /* (586) partition_list ::= partition_item */ + -3, /* (587) partition_list ::= partition_list NK_COMMA partition_item */ + -1, /* (588) partition_item ::= expr_or_subquery */ + -2, /* (589) partition_item ::= expr_or_subquery column_alias */ + -3, /* (590) partition_item ::= expr_or_subquery AS column_alias */ + 0, /* (591) twindow_clause_opt ::= */ + -6, /* (592) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP */ + -4, /* (593) twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ + -6, /* (594) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ + -8, /* (595) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ + -7, /* (596) twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ + 0, /* (597) sliding_opt ::= */ + -4, /* (598) sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP */ + -1, /* (599) interval_sliding_duration_literal ::= NK_VARIABLE */ + -1, /* (600) interval_sliding_duration_literal ::= NK_STRING */ + -1, /* (601) interval_sliding_duration_literal ::= NK_INTEGER */ + 0, /* (602) fill_opt ::= */ + -4, /* (603) fill_opt ::= FILL NK_LP fill_mode NK_RP */ + -6, /* (604) fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ + -6, /* (605) fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ + -1, /* (606) fill_mode ::= NONE */ + -1, /* (607) fill_mode ::= PREV */ + -1, /* (608) fill_mode ::= NULL */ + -1, /* (609) fill_mode ::= NULL_F */ + -1, /* (610) fill_mode ::= LINEAR */ + -1, /* (611) fill_mode ::= NEXT */ + 0, /* (612) group_by_clause_opt ::= */ + -3, /* (613) group_by_clause_opt ::= GROUP BY group_by_list */ + -1, /* (614) group_by_list ::= expr_or_subquery */ + -3, /* (615) group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ + 0, /* (616) having_clause_opt ::= */ + -2, /* (617) having_clause_opt ::= HAVING search_condition */ + 0, /* (618) range_opt ::= */ + -6, /* (619) range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ + -4, /* (620) range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ + 0, /* (621) every_opt ::= */ + -4, /* (622) every_opt ::= EVERY NK_LP duration_literal NK_RP */ + -4, /* (623) query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ + -1, /* (624) query_simple ::= query_specification */ + -1, /* (625) query_simple ::= union_query_expression */ + -4, /* (626) union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ + -3, /* (627) union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ + -1, /* (628) query_simple_or_subquery ::= query_simple */ + -1, /* (629) query_simple_or_subquery ::= subquery */ + -1, /* (630) query_or_subquery ::= query_expression */ + -1, /* (631) query_or_subquery ::= subquery */ + 0, /* (632) order_by_clause_opt ::= */ + -3, /* (633) order_by_clause_opt ::= ORDER BY sort_specification_list */ + 0, /* (634) slimit_clause_opt ::= */ + -2, /* (635) slimit_clause_opt ::= SLIMIT NK_INTEGER */ + -4, /* (636) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + -4, /* (637) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + 0, /* (638) limit_clause_opt ::= */ + -2, /* (639) limit_clause_opt ::= LIMIT NK_INTEGER */ + -4, /* (640) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ + -4, /* (641) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + -3, /* (642) subquery ::= NK_LP query_expression NK_RP */ + -3, /* (643) subquery ::= NK_LP subquery NK_RP */ + -1, /* (644) search_condition ::= common_expression */ + -1, /* (645) sort_specification_list ::= sort_specification */ + -3, /* (646) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ + -3, /* (647) sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ + 0, /* (648) ordering_specification_opt ::= */ + -1, /* (649) ordering_specification_opt ::= ASC */ + -1, /* (650) ordering_specification_opt ::= DESC */ + 0, /* (651) null_ordering_opt ::= */ + -2, /* (652) null_ordering_opt ::= NULLS FIRST */ + -2, /* (653) null_ordering_opt ::= NULLS LAST */ }; static void yy_accept(yyParser*); /* Forward Declaration */ @@ -4848,11 +4821,11 @@ static YYACTIONTYPE yy_reduce( YYMINORTYPE yylhsminor; case 0: /* cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */ { pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); } - yy_destructor(yypParser,357,&yymsp[0].minor); + yy_destructor(yypParser,356,&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,358,&yymsp[0].minor); + yy_destructor(yypParser,357,&yymsp[0].minor); break; case 2: /* account_options ::= */ { } @@ -4866,20 +4839,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,357,&yymsp[-2].minor); +{ yy_destructor(yypParser,356,&yymsp[-2].minor); { } - yy_destructor(yypParser,359,&yymsp[0].minor); + yy_destructor(yypParser,358,&yymsp[0].minor); } break; case 12: /* alter_account_options ::= alter_account_option */ -{ yy_destructor(yypParser,360,&yymsp[0].minor); +{ yy_destructor(yypParser,359,&yymsp[0].minor); { } } break; case 13: /* alter_account_options ::= alter_account_options alter_account_option */ -{ yy_destructor(yypParser,358,&yymsp[-1].minor); +{ yy_destructor(yypParser,357,&yymsp[-1].minor); { } - yy_destructor(yypParser,360,&yymsp[0].minor); + yy_destructor(yypParser,359,&yymsp[0].minor); } break; case 14: /* alter_account_option ::= PASS literal */ @@ -4893,18 +4866,18 @@ static YYACTIONTYPE yy_reduce( case 22: /* alter_account_option ::= CONNS literal */ yytestcase(yyruleno==22); case 23: /* alter_account_option ::= STATE literal */ yytestcase(yyruleno==23); { } - yy_destructor(yypParser,359,&yymsp[0].minor); + yy_destructor(yypParser,358,&yymsp[0].minor); break; case 24: /* ip_range_list ::= NK_STRING */ -{ yylhsminor.yy1006 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy1006 = yylhsminor.yy1006; +{ yylhsminor.yy184 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy184 = yylhsminor.yy184; break; case 25: /* ip_range_list ::= ip_range_list NK_COMMA NK_STRING */ -{ yylhsminor.yy1006 = addNodeToList(pCxt, yymsp[-2].minor.yy1006, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } - yymsp[-2].minor.yy1006 = yylhsminor.yy1006; +{ yylhsminor.yy184 = addNodeToList(pCxt, yymsp[-2].minor.yy184, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy184 = yylhsminor.yy184; break; case 26: /* white_list ::= HOST ip_range_list */ -{ yymsp[-1].minor.yy1006 = yymsp[0].minor.yy1006; } +{ yymsp[-1].minor.yy184 = yymsp[0].minor.yy184; } break; case 27: /* white_list_opt ::= */ case 186: /* specific_cols_opt ::= */ yytestcase(yyruleno==186); @@ -4912,93 +4885,93 @@ static YYACTIONTYPE yy_reduce( case 300: /* tag_list_opt ::= */ yytestcase(yyruleno==300); case 366: /* col_list_opt ::= */ yytestcase(yyruleno==366); case 368: /* tag_def_or_ref_opt ::= */ yytestcase(yyruleno==368); - case 585: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==585); - case 613: /* group_by_clause_opt ::= */ yytestcase(yyruleno==613); - case 633: /* order_by_clause_opt ::= */ yytestcase(yyruleno==633); -{ yymsp[1].minor.yy1006 = NULL; } + case 584: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==584); + case 612: /* group_by_clause_opt ::= */ yytestcase(yyruleno==612); + case 632: /* order_by_clause_opt ::= */ yytestcase(yyruleno==632); +{ yymsp[1].minor.yy184 = NULL; } break; case 28: /* white_list_opt ::= white_list */ case 218: /* tags_def_opt ::= tags_def */ yytestcase(yyruleno==218); case 369: /* tag_def_or_ref_opt ::= tags_def */ yytestcase(yyruleno==369); case 494: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==494); -{ yylhsminor.yy1006 = yymsp[0].minor.yy1006; } - yymsp[0].minor.yy1006 = yylhsminor.yy1006; +{ yylhsminor.yy184 = yymsp[0].minor.yy184; } + yymsp[0].minor.yy184 = yylhsminor.yy184; break; case 29: /* cmd ::= CREATE USER user_name PASS NK_STRING sysinfo_opt white_list_opt */ { - pCxt->pRootNode = createCreateUserStmt(pCxt, &yymsp[-4].minor.yy213, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy379); - pCxt->pRootNode = addCreateUserStmtWhiteList(pCxt, pCxt->pRootNode, yymsp[0].minor.yy1006); + pCxt->pRootNode = createCreateUserStmt(pCxt, &yymsp[-4].minor.yy369, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy743); + pCxt->pRootNode = addCreateUserStmtWhiteList(pCxt, pCxt->pRootNode, yymsp[0].minor.yy184); } break; case 30: /* cmd ::= ALTER USER user_name PASS NK_STRING */ -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy213, TSDB_ALTER_USER_PASSWD, &yymsp[0].minor.yy0); } +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy369, TSDB_ALTER_USER_PASSWD, &yymsp[0].minor.yy0); } break; case 31: /* cmd ::= ALTER USER user_name ENABLE NK_INTEGER */ -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy213, TSDB_ALTER_USER_ENABLE, &yymsp[0].minor.yy0); } +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy369, TSDB_ALTER_USER_ENABLE, &yymsp[0].minor.yy0); } break; case 32: /* cmd ::= ALTER USER user_name SYSINFO NK_INTEGER */ -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy213, TSDB_ALTER_USER_SYSINFO, &yymsp[0].minor.yy0); } +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy369, TSDB_ALTER_USER_SYSINFO, &yymsp[0].minor.yy0); } break; case 33: /* cmd ::= ALTER USER user_name ADD white_list */ -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy213, TSDB_ALTER_USER_ADD_WHITE_LIST, yymsp[0].minor.yy1006); } +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy369, TSDB_ALTER_USER_ADD_WHITE_LIST, yymsp[0].minor.yy184); } break; case 34: /* cmd ::= ALTER USER user_name DROP white_list */ -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy213, TSDB_ALTER_USER_DROP_WHITE_LIST, yymsp[0].minor.yy1006); } +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy369, TSDB_ALTER_USER_DROP_WHITE_LIST, yymsp[0].minor.yy184); } break; case 35: /* cmd ::= DROP USER user_name */ -{ pCxt->pRootNode = createDropUserStmt(pCxt, &yymsp[0].minor.yy213); } +{ pCxt->pRootNode = createDropUserStmt(pCxt, &yymsp[0].minor.yy369); } break; case 36: /* sysinfo_opt ::= */ -{ yymsp[1].minor.yy379 = 1; } +{ yymsp[1].minor.yy743 = 1; } break; case 37: /* sysinfo_opt ::= SYSINFO NK_INTEGER */ -{ yymsp[-1].minor.yy379 = taosStr2Int8(yymsp[0].minor.yy0.z, NULL, 10); } +{ yymsp[-1].minor.yy743 = taosStr2Int8(yymsp[0].minor.yy0.z, NULL, 10); } break; case 38: /* cmd ::= GRANT privileges ON priv_level with_opt TO user_name */ -{ pCxt->pRootNode = createGrantStmt(pCxt, yymsp[-5].minor.yy337, &yymsp[-3].minor.yy285, &yymsp[0].minor.yy213, yymsp[-2].minor.yy664); } +{ pCxt->pRootNode = createGrantStmt(pCxt, yymsp[-5].minor.yy909, &yymsp[-3].minor.yy937, &yymsp[0].minor.yy369, yymsp[-2].minor.yy392); } break; case 39: /* cmd ::= REVOKE privileges ON priv_level with_opt FROM user_name */ -{ pCxt->pRootNode = createRevokeStmt(pCxt, yymsp[-5].minor.yy337, &yymsp[-3].minor.yy285, &yymsp[0].minor.yy213, yymsp[-2].minor.yy664); } +{ pCxt->pRootNode = createRevokeStmt(pCxt, yymsp[-5].minor.yy909, &yymsp[-3].minor.yy937, &yymsp[0].minor.yy369, yymsp[-2].minor.yy392); } break; case 40: /* privileges ::= ALL */ -{ yymsp[0].minor.yy337 = PRIVILEGE_TYPE_ALL; } +{ yymsp[0].minor.yy909 = PRIVILEGE_TYPE_ALL; } break; case 41: /* privileges ::= priv_type_list */ case 43: /* priv_type_list ::= priv_type */ yytestcase(yyruleno==43); -{ yylhsminor.yy337 = yymsp[0].minor.yy337; } - yymsp[0].minor.yy337 = yylhsminor.yy337; +{ yylhsminor.yy909 = yymsp[0].minor.yy909; } + yymsp[0].minor.yy909 = yylhsminor.yy909; break; case 42: /* privileges ::= SUBSCRIBE */ -{ yymsp[0].minor.yy337 = PRIVILEGE_TYPE_SUBSCRIBE; } +{ yymsp[0].minor.yy909 = PRIVILEGE_TYPE_SUBSCRIBE; } break; case 44: /* priv_type_list ::= priv_type_list NK_COMMA priv_type */ -{ yylhsminor.yy337 = yymsp[-2].minor.yy337 | yymsp[0].minor.yy337; } - yymsp[-2].minor.yy337 = yylhsminor.yy337; +{ yylhsminor.yy909 = yymsp[-2].minor.yy909 | yymsp[0].minor.yy909; } + yymsp[-2].minor.yy909 = yylhsminor.yy909; break; case 45: /* priv_type ::= READ */ -{ yymsp[0].minor.yy337 = PRIVILEGE_TYPE_READ; } +{ yymsp[0].minor.yy909 = PRIVILEGE_TYPE_READ; } break; case 46: /* priv_type ::= WRITE */ -{ yymsp[0].minor.yy337 = PRIVILEGE_TYPE_WRITE; } +{ yymsp[0].minor.yy909 = PRIVILEGE_TYPE_WRITE; } break; case 47: /* priv_type ::= ALTER */ -{ yymsp[0].minor.yy337 = PRIVILEGE_TYPE_ALTER; } +{ yymsp[0].minor.yy909 = PRIVILEGE_TYPE_ALTER; } break; case 48: /* priv_level ::= NK_STAR NK_DOT NK_STAR */ -{ yylhsminor.yy285.first = yymsp[-2].minor.yy0; yylhsminor.yy285.second = yymsp[0].minor.yy0; } - yymsp[-2].minor.yy285 = yylhsminor.yy285; +{ yylhsminor.yy937.first = yymsp[-2].minor.yy0; yylhsminor.yy937.second = yymsp[0].minor.yy0; } + yymsp[-2].minor.yy937 = yylhsminor.yy937; break; case 49: /* priv_level ::= db_name NK_DOT NK_STAR */ -{ yylhsminor.yy285.first = yymsp[-2].minor.yy213; yylhsminor.yy285.second = yymsp[0].minor.yy0; } - yymsp[-2].minor.yy285 = yylhsminor.yy285; +{ yylhsminor.yy937.first = yymsp[-2].minor.yy369; yylhsminor.yy937.second = yymsp[0].minor.yy0; } + yymsp[-2].minor.yy937 = yylhsminor.yy937; break; case 50: /* priv_level ::= db_name NK_DOT table_name */ -{ yylhsminor.yy285.first = yymsp[-2].minor.yy213; yylhsminor.yy285.second = yymsp[0].minor.yy213; } - yymsp[-2].minor.yy285 = yylhsminor.yy285; +{ yylhsminor.yy937.first = yymsp[-2].minor.yy369; yylhsminor.yy937.second = yymsp[0].minor.yy369; } + yymsp[-2].minor.yy937 = yylhsminor.yy937; break; case 51: /* priv_level ::= topic_name */ -{ yylhsminor.yy285.first = yymsp[0].minor.yy213; yylhsminor.yy285.second = nil_token; } - yymsp[0].minor.yy285 = yylhsminor.yy285; +{ yylhsminor.yy937.first = yymsp[0].minor.yy369; yylhsminor.yy937.second = nil_token; } + yymsp[0].minor.yy937 = yylhsminor.yy937; break; case 52: /* with_opt ::= */ case 155: /* start_opt ::= */ yytestcase(yyruleno==155); @@ -5007,42 +4980,42 @@ static YYACTIONTYPE yy_reduce( case 380: /* subtable_opt ::= */ yytestcase(yyruleno==380); case 504: /* case_when_else_opt ::= */ yytestcase(yyruleno==504); case 534: /* from_clause_opt ::= */ yytestcase(yyruleno==534); - case 562: /* window_offset_clause_opt ::= */ yytestcase(yyruleno==562); - case 566: /* jlimit_clause_opt ::= */ yytestcase(yyruleno==566); - case 583: /* where_clause_opt ::= */ yytestcase(yyruleno==583); - case 592: /* twindow_clause_opt ::= */ yytestcase(yyruleno==592); - case 598: /* sliding_opt ::= */ yytestcase(yyruleno==598); - case 603: /* fill_opt ::= */ yytestcase(yyruleno==603); - case 617: /* having_clause_opt ::= */ yytestcase(yyruleno==617); - case 619: /* range_opt ::= */ yytestcase(yyruleno==619); - case 622: /* every_opt ::= */ yytestcase(yyruleno==622); - case 635: /* slimit_clause_opt ::= */ yytestcase(yyruleno==635); - case 639: /* limit_clause_opt ::= */ yytestcase(yyruleno==639); -{ yymsp[1].minor.yy664 = NULL; } + case 561: /* window_offset_clause_opt ::= */ yytestcase(yyruleno==561); + case 565: /* jlimit_clause_opt ::= */ yytestcase(yyruleno==565); + case 582: /* where_clause_opt ::= */ yytestcase(yyruleno==582); + case 591: /* twindow_clause_opt ::= */ yytestcase(yyruleno==591); + case 597: /* sliding_opt ::= */ yytestcase(yyruleno==597); + case 602: /* fill_opt ::= */ yytestcase(yyruleno==602); + case 616: /* having_clause_opt ::= */ yytestcase(yyruleno==616); + case 618: /* range_opt ::= */ yytestcase(yyruleno==618); + case 621: /* every_opt ::= */ yytestcase(yyruleno==621); + case 634: /* slimit_clause_opt ::= */ yytestcase(yyruleno==634); + case 638: /* limit_clause_opt ::= */ yytestcase(yyruleno==638); +{ yymsp[1].minor.yy392 = NULL; } break; case 53: /* with_opt ::= WITH search_condition */ case 535: /* from_clause_opt ::= FROM table_reference_list */ yytestcase(yyruleno==535); - case 584: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==584); - case 618: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==618); -{ yymsp[-1].minor.yy664 = yymsp[0].minor.yy664; } + case 583: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==583); + case 617: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==617); +{ yymsp[-1].minor.yy392 = yymsp[0].minor.yy392; } break; case 54: /* cmd ::= CREATE DNODE dnode_endpoint */ -{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[0].minor.yy213, NULL); } +{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[0].minor.yy369, NULL); } break; case 55: /* cmd ::= CREATE DNODE dnode_endpoint PORT NK_INTEGER */ -{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[-2].minor.yy213, &yymsp[0].minor.yy0); } +{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[-2].minor.yy369, &yymsp[0].minor.yy0); } break; case 56: /* cmd ::= DROP DNODE NK_INTEGER force_opt */ -{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy885, false); } +{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy377, false); } break; case 57: /* cmd ::= DROP DNODE dnode_endpoint force_opt */ -{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy213, yymsp[0].minor.yy885, false); } +{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy369, yymsp[0].minor.yy377, false); } break; case 58: /* cmd ::= DROP DNODE NK_INTEGER unsafe_opt */ -{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy0, false, yymsp[0].minor.yy885); } +{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy0, false, yymsp[0].minor.yy377); } break; case 59: /* cmd ::= DROP DNODE dnode_endpoint unsafe_opt */ -{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy213, false, yymsp[0].minor.yy885); } +{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy369, false, yymsp[0].minor.yy377); } break; case 60: /* cmd ::= ALTER DNODE NK_INTEGER NK_STRING */ { pCxt->pRootNode = createAlterDnodeStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, NULL); } @@ -5092,8 +5065,8 @@ static YYACTIONTYPE yy_reduce( case 490: /* star_func ::= FIRST */ yytestcase(yyruleno==490); case 491: /* star_func ::= LAST */ yytestcase(yyruleno==491); case 492: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==492); -{ yylhsminor.yy213 = yymsp[0].minor.yy0; } - yymsp[0].minor.yy213 = yylhsminor.yy213; +{ yylhsminor.yy369 = yymsp[0].minor.yy0; } + yymsp[0].minor.yy369 = yylhsminor.yy369; break; case 68: /* force_opt ::= */ case 92: /* not_exists_opt ::= */ yytestcase(yyruleno==92); @@ -5102,17 +5075,17 @@ static YYACTIONTYPE yy_reduce( case 350: /* agg_func_opt ::= */ yytestcase(yyruleno==350); case 356: /* or_replace_opt ::= */ yytestcase(yyruleno==356); case 382: /* ignore_opt ::= */ yytestcase(yyruleno==382); - case 571: /* tag_mode_opt ::= */ yytestcase(yyruleno==571); - case 573: /* set_quantifier_opt ::= */ yytestcase(yyruleno==573); -{ yymsp[1].minor.yy885 = false; } + case 570: /* tag_mode_opt ::= */ yytestcase(yyruleno==570); + case 572: /* set_quantifier_opt ::= */ yytestcase(yyruleno==572); +{ yymsp[1].minor.yy377 = false; } break; case 69: /* force_opt ::= FORCE */ case 70: /* unsafe_opt ::= UNSAFE */ yytestcase(yyruleno==70); case 344: /* analyze_opt ::= ANALYZE */ yytestcase(yyruleno==344); case 351: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==351); - case 572: /* tag_mode_opt ::= TAGS */ yytestcase(yyruleno==572); - case 574: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==574); -{ yymsp[0].minor.yy885 = true; } + case 571: /* tag_mode_opt ::= TAGS */ yytestcase(yyruleno==571); + case 573: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==573); +{ yymsp[0].minor.yy377 = true; } break; case 71: /* cmd ::= ALTER LOCAL NK_STRING */ { pCxt->pRootNode = createAlterLocalStmt(pCxt, &yymsp[0].minor.yy0, NULL); } @@ -5154,241 +5127,241 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createRestoreComponentNodeStmt(pCxt, QUERY_NODE_RESTORE_VNODE_STMT, &yymsp[0].minor.yy0); } break; case 84: /* cmd ::= CREATE DATABASE not_exists_opt db_name db_options */ -{ pCxt->pRootNode = createCreateDatabaseStmt(pCxt, yymsp[-2].minor.yy885, &yymsp[-1].minor.yy213, yymsp[0].minor.yy664); } +{ pCxt->pRootNode = createCreateDatabaseStmt(pCxt, yymsp[-2].minor.yy377, &yymsp[-1].minor.yy369, yymsp[0].minor.yy392); } break; case 85: /* cmd ::= DROP DATABASE exists_opt db_name */ -{ pCxt->pRootNode = createDropDatabaseStmt(pCxt, yymsp[-1].minor.yy885, &yymsp[0].minor.yy213); } +{ pCxt->pRootNode = createDropDatabaseStmt(pCxt, yymsp[-1].minor.yy377, &yymsp[0].minor.yy369); } break; case 86: /* cmd ::= USE db_name */ -{ pCxt->pRootNode = createUseDatabaseStmt(pCxt, &yymsp[0].minor.yy213); } +{ pCxt->pRootNode = createUseDatabaseStmt(pCxt, &yymsp[0].minor.yy369); } break; case 87: /* cmd ::= ALTER DATABASE db_name alter_db_options */ -{ pCxt->pRootNode = createAlterDatabaseStmt(pCxt, &yymsp[-1].minor.yy213, yymsp[0].minor.yy664); } +{ pCxt->pRootNode = createAlterDatabaseStmt(pCxt, &yymsp[-1].minor.yy369, yymsp[0].minor.yy392); } break; case 88: /* cmd ::= FLUSH DATABASE db_name */ -{ pCxt->pRootNode = createFlushDatabaseStmt(pCxt, &yymsp[0].minor.yy213); } +{ pCxt->pRootNode = createFlushDatabaseStmt(pCxt, &yymsp[0].minor.yy369); } break; case 89: /* cmd ::= TRIM DATABASE db_name speed_opt */ -{ pCxt->pRootNode = createTrimDatabaseStmt(pCxt, &yymsp[-1].minor.yy213, yymsp[0].minor.yy316); } +{ pCxt->pRootNode = createTrimDatabaseStmt(pCxt, &yymsp[-1].minor.yy369, yymsp[0].minor.yy20); } break; case 90: /* cmd ::= COMPACT DATABASE db_name start_opt end_opt */ -{ pCxt->pRootNode = createCompactStmt(pCxt, &yymsp[-2].minor.yy213, yymsp[-1].minor.yy664, yymsp[0].minor.yy664); } +{ pCxt->pRootNode = createCompactStmt(pCxt, &yymsp[-2].minor.yy369, yymsp[-1].minor.yy392, yymsp[0].minor.yy392); } break; case 91: /* not_exists_opt ::= IF NOT EXISTS */ -{ yymsp[-2].minor.yy885 = true; } +{ yymsp[-2].minor.yy377 = true; } break; case 93: /* exists_opt ::= IF EXISTS */ case 357: /* or_replace_opt ::= OR REPLACE */ yytestcase(yyruleno==357); case 383: /* ignore_opt ::= IGNORE UNTREATED */ yytestcase(yyruleno==383); -{ yymsp[-1].minor.yy885 = true; } +{ yymsp[-1].minor.yy377 = true; } break; case 95: /* db_options ::= */ -{ yymsp[1].minor.yy664 = createDefaultDatabaseOptions(pCxt); } +{ yymsp[1].minor.yy392 = createDefaultDatabaseOptions(pCxt); } break; case 96: /* db_options ::= db_options BUFFER NK_INTEGER */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_BUFFER, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_BUFFER, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 97: /* db_options ::= db_options CACHEMODEL NK_STRING */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_CACHEMODEL, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_CACHEMODEL, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 98: /* db_options ::= db_options CACHESIZE NK_INTEGER */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_CACHESIZE, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_CACHESIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 99: /* db_options ::= db_options COMP NK_INTEGER */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_COMP, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_COMP, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 100: /* db_options ::= db_options DURATION NK_INTEGER */ case 101: /* db_options ::= db_options DURATION NK_VARIABLE */ yytestcase(yyruleno==101); -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_DAYS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_DAYS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 102: /* db_options ::= db_options MAXROWS NK_INTEGER */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_MAXROWS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_MAXROWS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 103: /* db_options ::= db_options MINROWS NK_INTEGER */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_MINROWS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_MINROWS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 104: /* db_options ::= db_options KEEP integer_list */ case 105: /* db_options ::= db_options KEEP variable_list */ yytestcase(yyruleno==105); -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_KEEP, yymsp[0].minor.yy1006); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_KEEP, yymsp[0].minor.yy184); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 106: /* db_options ::= db_options PAGES NK_INTEGER */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_PAGES, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_PAGES, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 107: /* db_options ::= db_options PAGESIZE NK_INTEGER */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_PAGESIZE, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_PAGESIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 108: /* db_options ::= db_options TSDB_PAGESIZE NK_INTEGER */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_TSDB_PAGESIZE, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_TSDB_PAGESIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 109: /* db_options ::= db_options PRECISION NK_STRING */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_PRECISION, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_PRECISION, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 110: /* db_options ::= db_options REPLICA NK_INTEGER */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_REPLICA, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_REPLICA, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 111: /* db_options ::= db_options VGROUPS NK_INTEGER */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_VGROUPS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_VGROUPS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 112: /* db_options ::= db_options SINGLE_STABLE NK_INTEGER */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_SINGLE_STABLE, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_SINGLE_STABLE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 113: /* db_options ::= db_options RETENTIONS retention_list */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_RETENTIONS, yymsp[0].minor.yy1006); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_RETENTIONS, yymsp[0].minor.yy184); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 114: /* db_options ::= db_options SCHEMALESS NK_INTEGER */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_SCHEMALESS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_SCHEMALESS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 115: /* db_options ::= db_options WAL_LEVEL NK_INTEGER */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_WAL, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_WAL, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 116: /* db_options ::= db_options WAL_FSYNC_PERIOD NK_INTEGER */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_FSYNC, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_FSYNC, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 117: /* db_options ::= db_options WAL_RETENTION_PERIOD NK_INTEGER */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_WAL_RETENTION_PERIOD, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_WAL_RETENTION_PERIOD, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 118: /* db_options ::= db_options WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-3].minor.yy664, DB_OPTION_WAL_RETENTION_PERIOD, &t); + yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-3].minor.yy392, DB_OPTION_WAL_RETENTION_PERIOD, &t); } - yymsp[-3].minor.yy664 = yylhsminor.yy664; + yymsp[-3].minor.yy392 = yylhsminor.yy392; break; case 119: /* db_options ::= db_options WAL_RETENTION_SIZE NK_INTEGER */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_WAL_RETENTION_SIZE, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_WAL_RETENTION_SIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 120: /* db_options ::= db_options WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-3].minor.yy664, DB_OPTION_WAL_RETENTION_SIZE, &t); + yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-3].minor.yy392, DB_OPTION_WAL_RETENTION_SIZE, &t); } - yymsp[-3].minor.yy664 = yylhsminor.yy664; + yymsp[-3].minor.yy392 = yylhsminor.yy392; break; case 121: /* db_options ::= db_options WAL_ROLL_PERIOD NK_INTEGER */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_WAL_ROLL_PERIOD, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_WAL_ROLL_PERIOD, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 122: /* db_options ::= db_options WAL_SEGMENT_SIZE NK_INTEGER */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_WAL_SEGMENT_SIZE, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_WAL_SEGMENT_SIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 123: /* db_options ::= db_options STT_TRIGGER NK_INTEGER */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_STT_TRIGGER, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_STT_TRIGGER, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 124: /* db_options ::= db_options TABLE_PREFIX signed */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_TABLE_PREFIX, yymsp[0].minor.yy664); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_TABLE_PREFIX, yymsp[0].minor.yy392); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 125: /* db_options ::= db_options TABLE_SUFFIX signed */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_TABLE_SUFFIX, yymsp[0].minor.yy664); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_TABLE_SUFFIX, yymsp[0].minor.yy392); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 126: /* db_options ::= db_options KEEP_TIME_OFFSET NK_INTEGER */ -{ yylhsminor.yy664 = setDatabaseOption(pCxt, yymsp[-2].minor.yy664, DB_OPTION_KEEP_TIME_OFFSET, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setDatabaseOption(pCxt, yymsp[-2].minor.yy392, DB_OPTION_KEEP_TIME_OFFSET, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 127: /* alter_db_options ::= alter_db_option */ -{ yylhsminor.yy664 = createAlterDatabaseOptions(pCxt); yylhsminor.yy664 = setAlterDatabaseOption(pCxt, yylhsminor.yy664, &yymsp[0].minor.yy549); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createAlterDatabaseOptions(pCxt); yylhsminor.yy392 = setAlterDatabaseOption(pCxt, yylhsminor.yy392, &yymsp[0].minor.yy845); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 128: /* alter_db_options ::= alter_db_options alter_db_option */ -{ yylhsminor.yy664 = setAlterDatabaseOption(pCxt, yymsp[-1].minor.yy664, &yymsp[0].minor.yy549); } - yymsp[-1].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setAlterDatabaseOption(pCxt, yymsp[-1].minor.yy392, &yymsp[0].minor.yy845); } + yymsp[-1].minor.yy392 = yylhsminor.yy392; break; case 129: /* alter_db_option ::= BUFFER NK_INTEGER */ -{ yymsp[-1].minor.yy549.type = DB_OPTION_BUFFER; yymsp[-1].minor.yy549.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy845.type = DB_OPTION_BUFFER; yymsp[-1].minor.yy845.val = yymsp[0].minor.yy0; } break; case 130: /* alter_db_option ::= CACHEMODEL NK_STRING */ -{ yymsp[-1].minor.yy549.type = DB_OPTION_CACHEMODEL; yymsp[-1].minor.yy549.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy845.type = DB_OPTION_CACHEMODEL; yymsp[-1].minor.yy845.val = yymsp[0].minor.yy0; } break; case 131: /* alter_db_option ::= CACHESIZE NK_INTEGER */ -{ yymsp[-1].minor.yy549.type = DB_OPTION_CACHESIZE; yymsp[-1].minor.yy549.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy845.type = DB_OPTION_CACHESIZE; yymsp[-1].minor.yy845.val = yymsp[0].minor.yy0; } break; case 132: /* alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */ -{ yymsp[-1].minor.yy549.type = DB_OPTION_FSYNC; yymsp[-1].minor.yy549.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy845.type = DB_OPTION_FSYNC; yymsp[-1].minor.yy845.val = yymsp[0].minor.yy0; } break; case 133: /* alter_db_option ::= KEEP integer_list */ case 134: /* alter_db_option ::= KEEP variable_list */ yytestcase(yyruleno==134); -{ yymsp[-1].minor.yy549.type = DB_OPTION_KEEP; yymsp[-1].minor.yy549.pList = yymsp[0].minor.yy1006; } +{ yymsp[-1].minor.yy845.type = DB_OPTION_KEEP; yymsp[-1].minor.yy845.pList = yymsp[0].minor.yy184; } break; case 135: /* alter_db_option ::= PAGES NK_INTEGER */ -{ yymsp[-1].minor.yy549.type = DB_OPTION_PAGES; yymsp[-1].minor.yy549.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy845.type = DB_OPTION_PAGES; yymsp[-1].minor.yy845.val = yymsp[0].minor.yy0; } break; case 136: /* alter_db_option ::= REPLICA NK_INTEGER */ -{ yymsp[-1].minor.yy549.type = DB_OPTION_REPLICA; yymsp[-1].minor.yy549.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy845.type = DB_OPTION_REPLICA; yymsp[-1].minor.yy845.val = yymsp[0].minor.yy0; } break; case 137: /* alter_db_option ::= WAL_LEVEL NK_INTEGER */ -{ yymsp[-1].minor.yy549.type = DB_OPTION_WAL; yymsp[-1].minor.yy549.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy845.type = DB_OPTION_WAL; yymsp[-1].minor.yy845.val = yymsp[0].minor.yy0; } break; case 138: /* alter_db_option ::= STT_TRIGGER NK_INTEGER */ -{ yymsp[-1].minor.yy549.type = DB_OPTION_STT_TRIGGER; yymsp[-1].minor.yy549.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy845.type = DB_OPTION_STT_TRIGGER; yymsp[-1].minor.yy845.val = yymsp[0].minor.yy0; } break; case 139: /* alter_db_option ::= MINROWS NK_INTEGER */ -{ yymsp[-1].minor.yy549.type = DB_OPTION_MINROWS; yymsp[-1].minor.yy549.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy845.type = DB_OPTION_MINROWS; yymsp[-1].minor.yy845.val = yymsp[0].minor.yy0; } break; case 140: /* alter_db_option ::= WAL_RETENTION_PERIOD NK_INTEGER */ -{ yymsp[-1].minor.yy549.type = DB_OPTION_WAL_RETENTION_PERIOD; yymsp[-1].minor.yy549.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy845.type = DB_OPTION_WAL_RETENTION_PERIOD; yymsp[-1].minor.yy845.val = yymsp[0].minor.yy0; } break; case 141: /* alter_db_option ::= WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ { 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.yy549.type = DB_OPTION_WAL_RETENTION_PERIOD; yymsp[-2].minor.yy549.val = t; + yymsp[-2].minor.yy845.type = DB_OPTION_WAL_RETENTION_PERIOD; yymsp[-2].minor.yy845.val = t; } break; case 142: /* alter_db_option ::= WAL_RETENTION_SIZE NK_INTEGER */ -{ yymsp[-1].minor.yy549.type = DB_OPTION_WAL_RETENTION_SIZE; yymsp[-1].minor.yy549.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy845.type = DB_OPTION_WAL_RETENTION_SIZE; yymsp[-1].minor.yy845.val = yymsp[0].minor.yy0; } break; case 143: /* alter_db_option ::= WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ { 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.yy549.type = DB_OPTION_WAL_RETENTION_SIZE; yymsp[-2].minor.yy549.val = t; + yymsp[-2].minor.yy845.type = DB_OPTION_WAL_RETENTION_SIZE; yymsp[-2].minor.yy845.val = t; } break; case 144: /* alter_db_option ::= KEEP_TIME_OFFSET NK_INTEGER */ -{ yymsp[-1].minor.yy549.type = DB_OPTION_KEEP_TIME_OFFSET; yymsp[-1].minor.yy549.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy845.type = DB_OPTION_KEEP_TIME_OFFSET; yymsp[-1].minor.yy845.val = yymsp[0].minor.yy0; } break; case 145: /* integer_list ::= NK_INTEGER */ -{ yylhsminor.yy1006 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy1006 = yylhsminor.yy1006; +{ yylhsminor.yy184 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy184 = yylhsminor.yy184; break; case 146: /* integer_list ::= integer_list NK_COMMA NK_INTEGER */ case 395: /* dnode_list ::= dnode_list DNODE NK_INTEGER */ yytestcase(yyruleno==395); -{ yylhsminor.yy1006 = addNodeToList(pCxt, yymsp[-2].minor.yy1006, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } - yymsp[-2].minor.yy1006 = yylhsminor.yy1006; +{ yylhsminor.yy184 = addNodeToList(pCxt, yymsp[-2].minor.yy184, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy184 = yylhsminor.yy184; break; case 147: /* variable_list ::= NK_VARIABLE */ -{ yylhsminor.yy1006 = createNodeList(pCxt, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy1006 = yylhsminor.yy1006; +{ yylhsminor.yy184 = createNodeList(pCxt, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy184 = yylhsminor.yy184; break; case 148: /* variable_list ::= variable_list NK_COMMA NK_VARIABLE */ -{ yylhsminor.yy1006 = addNodeToList(pCxt, yymsp[-2].minor.yy1006, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[-2].minor.yy1006 = yylhsminor.yy1006; +{ yylhsminor.yy184 = addNodeToList(pCxt, yymsp[-2].minor.yy184, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy184 = yylhsminor.yy184; break; case 149: /* retention_list ::= retention */ case 180: /* multi_create_clause ::= create_subtable_clause */ yytestcase(yyruleno==180); @@ -5401,11 +5374,11 @@ static YYACTIONTYPE yy_reduce( case 424: /* literal_list ::= signed_literal */ yytestcase(yyruleno==424); case 495: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==495); case 501: /* when_then_list ::= when_then_expr */ yytestcase(yyruleno==501); - case 576: /* select_list ::= select_item */ yytestcase(yyruleno==576); - case 587: /* partition_list ::= partition_item */ yytestcase(yyruleno==587); - case 646: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==646); -{ yylhsminor.yy1006 = createNodeList(pCxt, yymsp[0].minor.yy664); } - yymsp[0].minor.yy1006 = yylhsminor.yy1006; + case 575: /* select_list ::= select_item */ yytestcase(yyruleno==575); + case 586: /* partition_list ::= partition_item */ yytestcase(yyruleno==586); + case 645: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==645); +{ yylhsminor.yy184 = createNodeList(pCxt, yymsp[0].minor.yy392); } + yymsp[0].minor.yy184 = yylhsminor.yy184; break; case 150: /* retention_list ::= retention_list NK_COMMA retention */ case 184: /* multi_drop_clause ::= multi_drop_clause NK_COMMA drop_table_clause */ yytestcase(yyruleno==184); @@ -5416,270 +5389,270 @@ static YYACTIONTYPE yy_reduce( case 319: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==319); case 425: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==425); case 496: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==496); - case 577: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==577); - case 588: /* partition_list ::= partition_list NK_COMMA partition_item */ yytestcase(yyruleno==588); - case 647: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==647); -{ yylhsminor.yy1006 = addNodeToList(pCxt, yymsp[-2].minor.yy1006, yymsp[0].minor.yy664); } - yymsp[-2].minor.yy1006 = yylhsminor.yy1006; + case 576: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==576); + case 587: /* partition_list ::= partition_list NK_COMMA partition_item */ yytestcase(yyruleno==587); + case 646: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==646); +{ yylhsminor.yy184 = addNodeToList(pCxt, yymsp[-2].minor.yy184, yymsp[0].minor.yy392); } + yymsp[-2].minor.yy184 = yylhsminor.yy184; break; case 151: /* retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ case 152: /* retention ::= NK_MINUS NK_COLON NK_VARIABLE */ yytestcase(yyruleno==152); -{ yylhsminor.yy664 = createNodeListNodeEx(pCxt, createDurationValueNode(pCxt, &yymsp[-2].minor.yy0), createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createNodeListNodeEx(pCxt, createDurationValueNode(pCxt, &yymsp[-2].minor.yy0), createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 153: /* speed_opt ::= */ case 352: /* bufsize_opt ::= */ yytestcase(yyruleno==352); -{ yymsp[1].minor.yy316 = 0; } +{ yymsp[1].minor.yy20 = 0; } break; case 154: /* speed_opt ::= BWLIMIT NK_INTEGER */ case 353: /* bufsize_opt ::= BUFSIZE NK_INTEGER */ yytestcase(yyruleno==353); -{ yymsp[-1].minor.yy316 = taosStr2Int32(yymsp[0].minor.yy0.z, NULL, 10); } +{ yymsp[-1].minor.yy20 = taosStr2Int32(yymsp[0].minor.yy0.z, NULL, 10); } break; case 156: /* start_opt ::= START WITH NK_INTEGER */ case 160: /* end_opt ::= END WITH NK_INTEGER */ yytestcase(yyruleno==160); -{ yymsp[-2].minor.yy664 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); } +{ yymsp[-2].minor.yy392 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); } break; case 157: /* start_opt ::= START WITH NK_STRING */ case 161: /* end_opt ::= END WITH NK_STRING */ yytestcase(yyruleno==161); -{ yymsp[-2].minor.yy664 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } +{ yymsp[-2].minor.yy392 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } break; case 158: /* start_opt ::= START WITH TIMESTAMP NK_STRING */ case 162: /* end_opt ::= END WITH TIMESTAMP NK_STRING */ yytestcase(yyruleno==162); -{ yymsp[-3].minor.yy664 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } +{ yymsp[-3].minor.yy392 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } break; case 163: /* cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ case 165: /* cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ yytestcase(yyruleno==165); -{ pCxt->pRootNode = createCreateTableStmt(pCxt, yymsp[-6].minor.yy885, yymsp[-5].minor.yy664, yymsp[-3].minor.yy1006, yymsp[-1].minor.yy1006, yymsp[0].minor.yy664); } +{ pCxt->pRootNode = createCreateTableStmt(pCxt, yymsp[-6].minor.yy377, yymsp[-5].minor.yy392, yymsp[-3].minor.yy184, yymsp[-1].minor.yy184, yymsp[0].minor.yy392); } break; case 164: /* cmd ::= CREATE TABLE multi_create_clause */ -{ pCxt->pRootNode = createCreateMultiTableStmt(pCxt, yymsp[0].minor.yy1006); } +{ pCxt->pRootNode = createCreateMultiTableStmt(pCxt, yymsp[0].minor.yy184); } break; case 166: /* cmd ::= DROP TABLE multi_drop_clause */ -{ pCxt->pRootNode = createDropTableStmt(pCxt, yymsp[0].minor.yy1006); } +{ pCxt->pRootNode = createDropTableStmt(pCxt, yymsp[0].minor.yy184); } break; case 167: /* cmd ::= DROP STABLE exists_opt full_table_name */ -{ pCxt->pRootNode = createDropSuperTableStmt(pCxt, yymsp[-1].minor.yy885, yymsp[0].minor.yy664); } +{ pCxt->pRootNode = createDropSuperTableStmt(pCxt, yymsp[-1].minor.yy377, yymsp[0].minor.yy392); } break; case 168: /* cmd ::= ALTER TABLE alter_table_clause */ case 397: /* cmd ::= query_or_subquery */ yytestcase(yyruleno==397); case 398: /* cmd ::= insert_query */ yytestcase(yyruleno==398); -{ pCxt->pRootNode = yymsp[0].minor.yy664; } +{ pCxt->pRootNode = yymsp[0].minor.yy392; } break; case 169: /* cmd ::= ALTER STABLE alter_table_clause */ -{ pCxt->pRootNode = setAlterSuperTableType(yymsp[0].minor.yy664); } +{ pCxt->pRootNode = setAlterSuperTableType(yymsp[0].minor.yy392); } break; case 170: /* alter_table_clause ::= full_table_name alter_table_options */ -{ yylhsminor.yy664 = createAlterTableModifyOptions(pCxt, yymsp[-1].minor.yy664, yymsp[0].minor.yy664); } - yymsp[-1].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createAlterTableModifyOptions(pCxt, yymsp[-1].minor.yy392, yymsp[0].minor.yy392); } + yymsp[-1].minor.yy392 = yylhsminor.yy392; break; case 171: /* alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ -{ yylhsminor.yy664 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy664, TSDB_ALTER_TABLE_ADD_COLUMN, &yymsp[-1].minor.yy213, yymsp[0].minor.yy892); } - yymsp[-4].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy392, TSDB_ALTER_TABLE_ADD_COLUMN, &yymsp[-1].minor.yy369, yymsp[0].minor.yy864); } + yymsp[-4].minor.yy392 = yylhsminor.yy392; break; case 172: /* alter_table_clause ::= full_table_name DROP COLUMN column_name */ -{ yylhsminor.yy664 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy664, TSDB_ALTER_TABLE_DROP_COLUMN, &yymsp[0].minor.yy213); } - yymsp[-3].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy392, TSDB_ALTER_TABLE_DROP_COLUMN, &yymsp[0].minor.yy369); } + yymsp[-3].minor.yy392 = yylhsminor.yy392; break; case 173: /* alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ -{ yylhsminor.yy664 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy664, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, &yymsp[-1].minor.yy213, yymsp[0].minor.yy892); } - yymsp[-4].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy392, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, &yymsp[-1].minor.yy369, yymsp[0].minor.yy864); } + yymsp[-4].minor.yy392 = yylhsminor.yy392; break; case 174: /* alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ -{ yylhsminor.yy664 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy664, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &yymsp[-1].minor.yy213, &yymsp[0].minor.yy213); } - yymsp[-4].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy392, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &yymsp[-1].minor.yy369, &yymsp[0].minor.yy369); } + yymsp[-4].minor.yy392 = yylhsminor.yy392; break; case 175: /* alter_table_clause ::= full_table_name ADD TAG column_name type_name */ -{ yylhsminor.yy664 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy664, TSDB_ALTER_TABLE_ADD_TAG, &yymsp[-1].minor.yy213, yymsp[0].minor.yy892); } - yymsp[-4].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy392, TSDB_ALTER_TABLE_ADD_TAG, &yymsp[-1].minor.yy369, yymsp[0].minor.yy864); } + yymsp[-4].minor.yy392 = yylhsminor.yy392; break; case 176: /* alter_table_clause ::= full_table_name DROP TAG column_name */ -{ yylhsminor.yy664 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy664, TSDB_ALTER_TABLE_DROP_TAG, &yymsp[0].minor.yy213); } - yymsp[-3].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy392, TSDB_ALTER_TABLE_DROP_TAG, &yymsp[0].minor.yy369); } + yymsp[-3].minor.yy392 = yylhsminor.yy392; break; case 177: /* alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ -{ yylhsminor.yy664 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy664, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &yymsp[-1].minor.yy213, yymsp[0].minor.yy892); } - yymsp[-4].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy392, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &yymsp[-1].minor.yy369, yymsp[0].minor.yy864); } + yymsp[-4].minor.yy392 = yylhsminor.yy392; break; case 178: /* alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ -{ yylhsminor.yy664 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy664, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &yymsp[-1].minor.yy213, &yymsp[0].minor.yy213); } - yymsp[-4].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy392, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &yymsp[-1].minor.yy369, &yymsp[0].minor.yy369); } + yymsp[-4].minor.yy392 = yylhsminor.yy392; break; case 179: /* alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ -{ yylhsminor.yy664 = createAlterTableSetTag(pCxt, yymsp[-5].minor.yy664, &yymsp[-2].minor.yy213, yymsp[0].minor.yy664); } - yymsp[-5].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createAlterTableSetTag(pCxt, yymsp[-5].minor.yy392, &yymsp[-2].minor.yy369, yymsp[0].minor.yy392); } + yymsp[-5].minor.yy392 = yylhsminor.yy392; break; case 181: /* multi_create_clause ::= multi_create_clause create_subtable_clause */ case 502: /* when_then_list ::= when_then_list when_then_expr */ yytestcase(yyruleno==502); -{ yylhsminor.yy1006 = addNodeToList(pCxt, yymsp[-1].minor.yy1006, yymsp[0].minor.yy664); } - yymsp[-1].minor.yy1006 = yylhsminor.yy1006; +{ yylhsminor.yy184 = addNodeToList(pCxt, yymsp[-1].minor.yy184, yymsp[0].minor.yy392); } + yymsp[-1].minor.yy184 = yylhsminor.yy184; break; case 182: /* 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 */ -{ yylhsminor.yy664 = createCreateSubTableClause(pCxt, yymsp[-9].minor.yy885, yymsp[-8].minor.yy664, yymsp[-6].minor.yy664, yymsp[-5].minor.yy1006, yymsp[-2].minor.yy1006, yymsp[0].minor.yy664); } - yymsp[-9].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createCreateSubTableClause(pCxt, yymsp[-9].minor.yy377, yymsp[-8].minor.yy392, yymsp[-6].minor.yy392, yymsp[-5].minor.yy184, yymsp[-2].minor.yy184, yymsp[0].minor.yy392); } + yymsp[-9].minor.yy392 = yylhsminor.yy392; break; case 185: /* drop_table_clause ::= exists_opt full_table_name */ -{ yylhsminor.yy664 = createDropTableClause(pCxt, yymsp[-1].minor.yy885, yymsp[0].minor.yy664); } - yymsp[-1].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createDropTableClause(pCxt, yymsp[-1].minor.yy377, yymsp[0].minor.yy392); } + yymsp[-1].minor.yy392 = yylhsminor.yy392; break; case 187: /* specific_cols_opt ::= NK_LP col_name_list NK_RP */ case 367: /* col_list_opt ::= NK_LP col_name_list NK_RP */ yytestcase(yyruleno==367); -{ yymsp[-2].minor.yy1006 = yymsp[-1].minor.yy1006; } +{ yymsp[-2].minor.yy184 = yymsp[-1].minor.yy184; } break; case 188: /* full_table_name ::= table_name */ -{ yylhsminor.yy664 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy213, NULL); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy369, NULL); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 189: /* full_table_name ::= db_name NK_DOT table_name */ -{ yylhsminor.yy664 = createRealTableNode(pCxt, &yymsp[-2].minor.yy213, &yymsp[0].minor.yy213, NULL); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRealTableNode(pCxt, &yymsp[-2].minor.yy369, &yymsp[0].minor.yy369, NULL); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 192: /* column_def ::= column_name type_name */ -{ yylhsminor.yy664 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy213, yymsp[0].minor.yy892, NULL); } - yymsp[-1].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy369, yymsp[0].minor.yy864, NULL); } + yymsp[-1].minor.yy392 = yylhsminor.yy392; break; case 193: /* type_name ::= BOOL */ -{ yymsp[0].minor.yy892 = createDataType(TSDB_DATA_TYPE_BOOL); } +{ yymsp[0].minor.yy864 = createDataType(TSDB_DATA_TYPE_BOOL); } break; case 194: /* type_name ::= TINYINT */ -{ yymsp[0].minor.yy892 = createDataType(TSDB_DATA_TYPE_TINYINT); } +{ yymsp[0].minor.yy864 = createDataType(TSDB_DATA_TYPE_TINYINT); } break; case 195: /* type_name ::= SMALLINT */ -{ yymsp[0].minor.yy892 = createDataType(TSDB_DATA_TYPE_SMALLINT); } +{ yymsp[0].minor.yy864 = createDataType(TSDB_DATA_TYPE_SMALLINT); } break; case 196: /* type_name ::= INT */ case 197: /* type_name ::= INTEGER */ yytestcase(yyruleno==197); -{ yymsp[0].minor.yy892 = createDataType(TSDB_DATA_TYPE_INT); } +{ yymsp[0].minor.yy864 = createDataType(TSDB_DATA_TYPE_INT); } break; case 198: /* type_name ::= BIGINT */ -{ yymsp[0].minor.yy892 = createDataType(TSDB_DATA_TYPE_BIGINT); } +{ yymsp[0].minor.yy864 = createDataType(TSDB_DATA_TYPE_BIGINT); } break; case 199: /* type_name ::= FLOAT */ -{ yymsp[0].minor.yy892 = createDataType(TSDB_DATA_TYPE_FLOAT); } +{ yymsp[0].minor.yy864 = createDataType(TSDB_DATA_TYPE_FLOAT); } break; case 200: /* type_name ::= DOUBLE */ -{ yymsp[0].minor.yy892 = createDataType(TSDB_DATA_TYPE_DOUBLE); } +{ yymsp[0].minor.yy864 = createDataType(TSDB_DATA_TYPE_DOUBLE); } break; case 201: /* type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy892 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy0); } +{ yymsp[-3].minor.yy864 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy0); } break; case 202: /* type_name ::= TIMESTAMP */ -{ yymsp[0].minor.yy892 = createDataType(TSDB_DATA_TYPE_TIMESTAMP); } +{ yymsp[0].minor.yy864 = createDataType(TSDB_DATA_TYPE_TIMESTAMP); } break; case 203: /* type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy892 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, &yymsp[-1].minor.yy0); } +{ yymsp[-3].minor.yy864 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, &yymsp[-1].minor.yy0); } break; case 204: /* type_name ::= TINYINT UNSIGNED */ -{ yymsp[-1].minor.yy892 = createDataType(TSDB_DATA_TYPE_UTINYINT); } +{ yymsp[-1].minor.yy864 = createDataType(TSDB_DATA_TYPE_UTINYINT); } break; case 205: /* type_name ::= SMALLINT UNSIGNED */ -{ yymsp[-1].minor.yy892 = createDataType(TSDB_DATA_TYPE_USMALLINT); } +{ yymsp[-1].minor.yy864 = createDataType(TSDB_DATA_TYPE_USMALLINT); } break; case 206: /* type_name ::= INT UNSIGNED */ -{ yymsp[-1].minor.yy892 = createDataType(TSDB_DATA_TYPE_UINT); } +{ yymsp[-1].minor.yy864 = createDataType(TSDB_DATA_TYPE_UINT); } break; case 207: /* type_name ::= BIGINT UNSIGNED */ -{ yymsp[-1].minor.yy892 = createDataType(TSDB_DATA_TYPE_UBIGINT); } +{ yymsp[-1].minor.yy864 = createDataType(TSDB_DATA_TYPE_UBIGINT); } break; case 208: /* type_name ::= JSON */ -{ yymsp[0].minor.yy892 = createDataType(TSDB_DATA_TYPE_JSON); } +{ yymsp[0].minor.yy864 = createDataType(TSDB_DATA_TYPE_JSON); } break; case 209: /* type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy892 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, &yymsp[-1].minor.yy0); } +{ yymsp[-3].minor.yy864 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, &yymsp[-1].minor.yy0); } break; case 210: /* type_name ::= MEDIUMBLOB */ -{ yymsp[0].minor.yy892 = createDataType(TSDB_DATA_TYPE_MEDIUMBLOB); } +{ yymsp[0].minor.yy864 = createDataType(TSDB_DATA_TYPE_MEDIUMBLOB); } break; case 211: /* type_name ::= BLOB */ -{ yymsp[0].minor.yy892 = createDataType(TSDB_DATA_TYPE_BLOB); } +{ yymsp[0].minor.yy864 = createDataType(TSDB_DATA_TYPE_BLOB); } break; case 212: /* type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy892 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, &yymsp[-1].minor.yy0); } +{ yymsp[-3].minor.yy864 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, &yymsp[-1].minor.yy0); } break; case 213: /* type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy892 = createVarLenDataType(TSDB_DATA_TYPE_GEOMETRY, &yymsp[-1].minor.yy0); } +{ yymsp[-3].minor.yy864 = createVarLenDataType(TSDB_DATA_TYPE_GEOMETRY, &yymsp[-1].minor.yy0); } break; case 214: /* type_name ::= DECIMAL */ -{ yymsp[0].minor.yy892 = createDataType(TSDB_DATA_TYPE_DECIMAL); } +{ yymsp[0].minor.yy864 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; case 215: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy892 = createDataType(TSDB_DATA_TYPE_DECIMAL); } +{ yymsp[-3].minor.yy864 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; case 216: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ -{ yymsp[-5].minor.yy892 = createDataType(TSDB_DATA_TYPE_DECIMAL); } +{ yymsp[-5].minor.yy864 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; case 219: /* tags_def ::= TAGS NK_LP column_def_list NK_RP */ case 370: /* tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP */ yytestcase(yyruleno==370); -{ yymsp[-3].minor.yy1006 = yymsp[-1].minor.yy1006; } +{ yymsp[-3].minor.yy184 = yymsp[-1].minor.yy184; } break; case 220: /* table_options ::= */ -{ yymsp[1].minor.yy664 = createDefaultTableOptions(pCxt); } +{ yymsp[1].minor.yy392 = createDefaultTableOptions(pCxt); } break; case 221: /* table_options ::= table_options COMMENT NK_STRING */ -{ yylhsminor.yy664 = setTableOption(pCxt, yymsp[-2].minor.yy664, TABLE_OPTION_COMMENT, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setTableOption(pCxt, yymsp[-2].minor.yy392, TABLE_OPTION_COMMENT, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 222: /* table_options ::= table_options MAX_DELAY duration_list */ -{ yylhsminor.yy664 = setTableOption(pCxt, yymsp[-2].minor.yy664, TABLE_OPTION_MAXDELAY, yymsp[0].minor.yy1006); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setTableOption(pCxt, yymsp[-2].minor.yy392, TABLE_OPTION_MAXDELAY, yymsp[0].minor.yy184); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 223: /* table_options ::= table_options WATERMARK duration_list */ -{ yylhsminor.yy664 = setTableOption(pCxt, yymsp[-2].minor.yy664, TABLE_OPTION_WATERMARK, yymsp[0].minor.yy1006); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setTableOption(pCxt, yymsp[-2].minor.yy392, TABLE_OPTION_WATERMARK, yymsp[0].minor.yy184); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 224: /* table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ -{ yylhsminor.yy664 = setTableOption(pCxt, yymsp[-4].minor.yy664, TABLE_OPTION_ROLLUP, yymsp[-1].minor.yy1006); } - yymsp[-4].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setTableOption(pCxt, yymsp[-4].minor.yy392, TABLE_OPTION_ROLLUP, yymsp[-1].minor.yy184); } + yymsp[-4].minor.yy392 = yylhsminor.yy392; break; case 225: /* table_options ::= table_options TTL NK_INTEGER */ -{ yylhsminor.yy664 = setTableOption(pCxt, yymsp[-2].minor.yy664, TABLE_OPTION_TTL, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setTableOption(pCxt, yymsp[-2].minor.yy392, TABLE_OPTION_TTL, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 226: /* table_options ::= table_options SMA NK_LP col_name_list NK_RP */ -{ yylhsminor.yy664 = setTableOption(pCxt, yymsp[-4].minor.yy664, TABLE_OPTION_SMA, yymsp[-1].minor.yy1006); } - yymsp[-4].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setTableOption(pCxt, yymsp[-4].minor.yy392, TABLE_OPTION_SMA, yymsp[-1].minor.yy184); } + yymsp[-4].minor.yy392 = yylhsminor.yy392; break; case 227: /* table_options ::= table_options DELETE_MARK duration_list */ -{ yylhsminor.yy664 = setTableOption(pCxt, yymsp[-2].minor.yy664, TABLE_OPTION_DELETE_MARK, yymsp[0].minor.yy1006); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setTableOption(pCxt, yymsp[-2].minor.yy392, TABLE_OPTION_DELETE_MARK, yymsp[0].minor.yy184); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 228: /* alter_table_options ::= alter_table_option */ -{ yylhsminor.yy664 = createAlterTableOptions(pCxt); yylhsminor.yy664 = setTableOption(pCxt, yylhsminor.yy664, yymsp[0].minor.yy549.type, &yymsp[0].minor.yy549.val); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createAlterTableOptions(pCxt); yylhsminor.yy392 = setTableOption(pCxt, yylhsminor.yy392, yymsp[0].minor.yy845.type, &yymsp[0].minor.yy845.val); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 229: /* alter_table_options ::= alter_table_options alter_table_option */ -{ yylhsminor.yy664 = setTableOption(pCxt, yymsp[-1].minor.yy664, yymsp[0].minor.yy549.type, &yymsp[0].minor.yy549.val); } - yymsp[-1].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setTableOption(pCxt, yymsp[-1].minor.yy392, yymsp[0].minor.yy845.type, &yymsp[0].minor.yy845.val); } + yymsp[-1].minor.yy392 = yylhsminor.yy392; break; case 230: /* alter_table_option ::= COMMENT NK_STRING */ -{ yymsp[-1].minor.yy549.type = TABLE_OPTION_COMMENT; yymsp[-1].minor.yy549.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy845.type = TABLE_OPTION_COMMENT; yymsp[-1].minor.yy845.val = yymsp[0].minor.yy0; } break; case 231: /* alter_table_option ::= TTL NK_INTEGER */ -{ yymsp[-1].minor.yy549.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy549.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy845.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy845.val = yymsp[0].minor.yy0; } break; case 232: /* duration_list ::= duration_literal */ case 456: /* expression_list ::= expr_or_subquery */ yytestcase(yyruleno==456); -{ yylhsminor.yy1006 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy664)); } - yymsp[0].minor.yy1006 = yylhsminor.yy1006; +{ yylhsminor.yy184 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy392)); } + yymsp[0].minor.yy184 = yylhsminor.yy184; break; case 233: /* duration_list ::= duration_list NK_COMMA duration_literal */ case 457: /* expression_list ::= expression_list NK_COMMA expr_or_subquery */ yytestcase(yyruleno==457); -{ yylhsminor.yy1006 = addNodeToList(pCxt, yymsp[-2].minor.yy1006, releaseRawExprNode(pCxt, yymsp[0].minor.yy664)); } - yymsp[-2].minor.yy1006 = yylhsminor.yy1006; +{ yylhsminor.yy184 = addNodeToList(pCxt, yymsp[-2].minor.yy184, releaseRawExprNode(pCxt, yymsp[0].minor.yy392)); } + yymsp[-2].minor.yy184 = yylhsminor.yy184; break; case 236: /* rollup_func_name ::= function_name */ -{ yylhsminor.yy664 = createFunctionNode(pCxt, &yymsp[0].minor.yy213, NULL); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createFunctionNode(pCxt, &yymsp[0].minor.yy369, NULL); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 237: /* rollup_func_name ::= FIRST */ case 238: /* rollup_func_name ::= LAST */ yytestcase(yyruleno==238); case 304: /* tag_item ::= QTAGS */ yytestcase(yyruleno==304); -{ yylhsminor.yy664 = createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 241: /* col_name ::= column_name */ case 305: /* tag_item ::= column_name */ yytestcase(yyruleno==305); -{ yylhsminor.yy664 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy213); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy369); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 242: /* cmd ::= SHOW DNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DNODES_STMT); } @@ -5693,19 +5666,19 @@ static YYACTIONTYPE yy_reduce( case 245: /* cmd ::= SHOW db_kind_opt DATABASES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DATABASES_STMT); - setShowKind(pCxt, pCxt->pRootNode, yymsp[-1].minor.yy217); + setShowKind(pCxt, pCxt->pRootNode, yymsp[-1].minor.yy849); } break; case 246: /* cmd ::= SHOW table_kind_db_name_cond_opt TABLES like_pattern_opt */ { - pCxt->pRootNode = createShowTablesStmt(pCxt, yymsp[-2].minor.yy943, yymsp[0].minor.yy664, OP_TYPE_LIKE); + pCxt->pRootNode = createShowTablesStmt(pCxt, yymsp[-2].minor.yy397, yymsp[0].minor.yy392, OP_TYPE_LIKE); } break; case 247: /* cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_STABLES_STMT, yymsp[-2].minor.yy664, yymsp[0].minor.yy664, OP_TYPE_LIKE); } +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_STABLES_STMT, yymsp[-2].minor.yy392, yymsp[0].minor.yy392, OP_TYPE_LIKE); } break; case 248: /* cmd ::= SHOW db_name_cond_opt VGROUPS */ -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, yymsp[-1].minor.yy664, NULL, OP_TYPE_LIKE); } +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, yymsp[-1].minor.yy392, NULL, OP_TYPE_LIKE); } break; case 249: /* cmd ::= SHOW MNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_MNODES_STMT); } @@ -5717,10 +5690,10 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_FUNCTIONS_STMT); } break; case 252: /* cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, yymsp[0].minor.yy664, yymsp[-1].minor.yy664, OP_TYPE_EQUAL); } +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, yymsp[0].minor.yy392, yymsp[-1].minor.yy392, OP_TYPE_EQUAL); } break; case 253: /* cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */ -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy213), createIdentifierValueNode(pCxt, &yymsp[0].minor.yy213), OP_TYPE_EQUAL); } +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy369), createIdentifierValueNode(pCxt, &yymsp[0].minor.yy369), OP_TYPE_EQUAL); } break; case 254: /* cmd ::= SHOW STREAMS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_STREAMS_STMT); } @@ -5739,13 +5712,13 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_LICENCES_STMT); } break; case 260: /* cmd ::= SHOW CREATE DATABASE db_name */ -{ pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &yymsp[0].minor.yy213); } +{ pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &yymsp[0].minor.yy369); } break; case 261: /* cmd ::= SHOW CREATE TABLE full_table_name */ -{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, yymsp[0].minor.yy664); } +{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, yymsp[0].minor.yy392); } break; case 262: /* cmd ::= SHOW CREATE STABLE full_table_name */ -{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, yymsp[0].minor.yy664); } +{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, yymsp[0].minor.yy392); } break; case 263: /* cmd ::= SHOW QUERIES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QUERIES_STMT); } @@ -5764,7 +5737,7 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT); } break; case 269: /* cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */ -{ pCxt->pRootNode = createShowDnodeVariablesStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[-2].minor.yy0), yymsp[0].minor.yy664); } +{ pCxt->pRootNode = createShowDnodeVariablesStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[-2].minor.yy0), yymsp[0].minor.yy392); } break; case 270: /* cmd ::= SHOW BNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_BNODES_STMT); } @@ -5779,7 +5752,7 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TRANSACTIONS_STMT); } break; case 274: /* cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ -{ pCxt->pRootNode = createShowTableDistributedStmt(pCxt, yymsp[0].minor.yy664); } +{ pCxt->pRootNode = createShowTableDistributedStmt(pCxt, yymsp[0].minor.yy392); } break; case 275: /* cmd ::= SHOW CONSUMERS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CONSUMERS_STMT); } @@ -5788,16 +5761,16 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT); } break; case 277: /* cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, yymsp[0].minor.yy664, yymsp[-1].minor.yy664, OP_TYPE_EQUAL); } +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, yymsp[0].minor.yy392, yymsp[-1].minor.yy392, OP_TYPE_EQUAL); } break; case 278: /* cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */ -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy213), createIdentifierValueNode(pCxt, &yymsp[0].minor.yy213), OP_TYPE_EQUAL); } +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy369), createIdentifierValueNode(pCxt, &yymsp[0].minor.yy369), OP_TYPE_EQUAL); } break; case 279: /* cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */ -{ pCxt->pRootNode = createShowTableTagsStmt(pCxt, yymsp[-1].minor.yy664, yymsp[0].minor.yy664, yymsp[-3].minor.yy1006); } +{ pCxt->pRootNode = createShowTableTagsStmt(pCxt, yymsp[-1].minor.yy392, yymsp[0].minor.yy392, yymsp[-3].minor.yy184); } break; case 280: /* cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */ -{ pCxt->pRootNode = createShowTableTagsStmt(pCxt, createIdentifierValueNode(pCxt, &yymsp[0].minor.yy213), createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy213), yymsp[-4].minor.yy1006); } +{ pCxt->pRootNode = createShowTableTagsStmt(pCxt, createIdentifierValueNode(pCxt, &yymsp[0].minor.yy369), createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy369), yymsp[-4].minor.yy184); } break; case 281: /* cmd ::= SHOW VNODES ON DNODE NK_INTEGER */ { pCxt->pRootNode = createShowVnodesStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0), NULL); } @@ -5806,244 +5779,244 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createShowVnodesStmt(pCxt, NULL, NULL); } break; case 283: /* cmd ::= SHOW db_name_cond_opt ALIVE */ -{ pCxt->pRootNode = createShowAliveStmt(pCxt, yymsp[-1].minor.yy664, QUERY_NODE_SHOW_DB_ALIVE_STMT); } +{ pCxt->pRootNode = createShowAliveStmt(pCxt, yymsp[-1].minor.yy392, QUERY_NODE_SHOW_DB_ALIVE_STMT); } break; case 284: /* cmd ::= SHOW CLUSTER ALIVE */ { pCxt->pRootNode = createShowAliveStmt(pCxt, NULL, QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT); } break; case 285: /* cmd ::= SHOW db_name_cond_opt VIEWS */ -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VIEWS_STMT, yymsp[-1].minor.yy664, NULL, OP_TYPE_LIKE); } +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VIEWS_STMT, yymsp[-1].minor.yy392, NULL, OP_TYPE_LIKE); } break; case 286: /* cmd ::= SHOW CREATE VIEW full_table_name */ -{ pCxt->pRootNode = createShowCreateViewStmt(pCxt, QUERY_NODE_SHOW_CREATE_VIEW_STMT, yymsp[0].minor.yy664); } +{ pCxt->pRootNode = createShowCreateViewStmt(pCxt, QUERY_NODE_SHOW_CREATE_VIEW_STMT, yymsp[0].minor.yy392); } break; case 287: /* table_kind_db_name_cond_opt ::= */ -{ yymsp[1].minor.yy943.kind = SHOW_KIND_ALL; yymsp[1].minor.yy943.dbName = nil_token; } +{ yymsp[1].minor.yy397.kind = SHOW_KIND_ALL; yymsp[1].minor.yy397.dbName = nil_token; } break; case 288: /* table_kind_db_name_cond_opt ::= table_kind */ -{ yylhsminor.yy943.kind = yymsp[0].minor.yy217; yylhsminor.yy943.dbName = nil_token; } - yymsp[0].minor.yy943 = yylhsminor.yy943; +{ yylhsminor.yy397.kind = yymsp[0].minor.yy849; yylhsminor.yy397.dbName = nil_token; } + yymsp[0].minor.yy397 = yylhsminor.yy397; break; case 289: /* table_kind_db_name_cond_opt ::= db_name NK_DOT */ -{ yylhsminor.yy943.kind = SHOW_KIND_ALL; yylhsminor.yy943.dbName = yymsp[-1].minor.yy213; } - yymsp[-1].minor.yy943 = yylhsminor.yy943; +{ yylhsminor.yy397.kind = SHOW_KIND_ALL; yylhsminor.yy397.dbName = yymsp[-1].minor.yy369; } + yymsp[-1].minor.yy397 = yylhsminor.yy397; break; case 290: /* table_kind_db_name_cond_opt ::= table_kind db_name NK_DOT */ -{ yylhsminor.yy943.kind = yymsp[-2].minor.yy217; yylhsminor.yy943.dbName = yymsp[-1].minor.yy213; } - yymsp[-2].minor.yy943 = yylhsminor.yy943; +{ yylhsminor.yy397.kind = yymsp[-2].minor.yy849; yylhsminor.yy397.dbName = yymsp[-1].minor.yy369; } + yymsp[-2].minor.yy397 = yylhsminor.yy397; break; case 291: /* table_kind ::= NORMAL */ -{ yymsp[0].minor.yy217 = SHOW_KIND_TABLES_NORMAL; } +{ yymsp[0].minor.yy849 = SHOW_KIND_TABLES_NORMAL; } break; case 292: /* table_kind ::= CHILD */ -{ yymsp[0].minor.yy217 = SHOW_KIND_TABLES_CHILD; } +{ yymsp[0].minor.yy849 = SHOW_KIND_TABLES_CHILD; } break; case 293: /* db_name_cond_opt ::= */ case 298: /* from_db_opt ::= */ yytestcase(yyruleno==298); -{ yymsp[1].minor.yy664 = createDefaultDatabaseCondValue(pCxt); } +{ yymsp[1].minor.yy392 = createDefaultDatabaseCondValue(pCxt); } break; case 294: /* db_name_cond_opt ::= db_name NK_DOT */ -{ yylhsminor.yy664 = createIdentifierValueNode(pCxt, &yymsp[-1].minor.yy213); } - yymsp[-1].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createIdentifierValueNode(pCxt, &yymsp[-1].minor.yy369); } + yymsp[-1].minor.yy392 = yylhsminor.yy392; break; case 296: /* like_pattern_opt ::= LIKE NK_STRING */ -{ yymsp[-1].minor.yy664 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } +{ yymsp[-1].minor.yy392 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } break; case 297: /* table_name_cond ::= table_name */ -{ yylhsminor.yy664 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy213); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy369); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 299: /* from_db_opt ::= FROM db_name */ -{ yymsp[-1].minor.yy664 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy213); } +{ yymsp[-1].minor.yy392 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy369); } break; case 303: /* tag_item ::= TBNAME */ -{ yylhsminor.yy664 = setProjectionAlias(pCxt, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL), &yymsp[0].minor.yy0); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setProjectionAlias(pCxt, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL), &yymsp[0].minor.yy0); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 306: /* tag_item ::= column_name column_alias */ -{ yylhsminor.yy664 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-1].minor.yy213), &yymsp[0].minor.yy213); } - yymsp[-1].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-1].minor.yy369), &yymsp[0].minor.yy369); } + yymsp[-1].minor.yy392 = yylhsminor.yy392; break; case 307: /* tag_item ::= column_name AS column_alias */ -{ yylhsminor.yy664 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-2].minor.yy213), &yymsp[0].minor.yy213); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-2].minor.yy369), &yymsp[0].minor.yy369); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 308: /* db_kind_opt ::= */ -{ yymsp[1].minor.yy217 = SHOW_KIND_ALL; } +{ yymsp[1].minor.yy849 = SHOW_KIND_ALL; } break; case 309: /* db_kind_opt ::= USER */ -{ yymsp[0].minor.yy217 = SHOW_KIND_DATABASES_USER; } +{ yymsp[0].minor.yy849 = SHOW_KIND_DATABASES_USER; } break; case 310: /* db_kind_opt ::= SYSTEM */ -{ yymsp[0].minor.yy217 = SHOW_KIND_DATABASES_SYSTEM; } +{ yymsp[0].minor.yy849 = SHOW_KIND_DATABASES_SYSTEM; } break; case 311: /* cmd ::= CREATE SMA INDEX not_exists_opt col_name ON full_table_name index_options */ -{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_SMA, yymsp[-4].minor.yy885, yymsp[-3].minor.yy664, yymsp[-1].minor.yy664, NULL, yymsp[0].minor.yy664); } +{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_SMA, yymsp[-4].minor.yy377, yymsp[-3].minor.yy392, yymsp[-1].minor.yy392, NULL, yymsp[0].minor.yy392); } break; case 312: /* cmd ::= CREATE INDEX not_exists_opt col_name ON full_table_name NK_LP col_name_list NK_RP */ -{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_NORMAL, yymsp[-6].minor.yy885, yymsp[-5].minor.yy664, yymsp[-3].minor.yy664, yymsp[-1].minor.yy1006, NULL); } +{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_NORMAL, yymsp[-6].minor.yy377, yymsp[-5].minor.yy392, yymsp[-3].minor.yy392, yymsp[-1].minor.yy184, NULL); } break; case 313: /* cmd ::= DROP INDEX exists_opt full_index_name */ -{ pCxt->pRootNode = createDropIndexStmt(pCxt, yymsp[-1].minor.yy885, yymsp[0].minor.yy664); } +{ pCxt->pRootNode = createDropIndexStmt(pCxt, yymsp[-1].minor.yy377, yymsp[0].minor.yy392); } break; case 314: /* full_index_name ::= index_name */ -{ yylhsminor.yy664 = createRealTableNodeForIndexName(pCxt, NULL, &yymsp[0].minor.yy213); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRealTableNodeForIndexName(pCxt, NULL, &yymsp[0].minor.yy369); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 315: /* full_index_name ::= db_name NK_DOT index_name */ -{ yylhsminor.yy664 = createRealTableNodeForIndexName(pCxt, &yymsp[-2].minor.yy213, &yymsp[0].minor.yy213); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRealTableNodeForIndexName(pCxt, &yymsp[-2].minor.yy369, &yymsp[0].minor.yy369); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 316: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ -{ yymsp[-9].minor.yy664 = createIndexOption(pCxt, yymsp[-7].minor.yy1006, releaseRawExprNode(pCxt, yymsp[-3].minor.yy664), NULL, yymsp[-1].minor.yy664, yymsp[0].minor.yy664); } +{ yymsp[-9].minor.yy392 = createIndexOption(pCxt, yymsp[-7].minor.yy184, releaseRawExprNode(pCxt, yymsp[-3].minor.yy392), NULL, yymsp[-1].minor.yy392, yymsp[0].minor.yy392); } break; case 317: /* 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 */ -{ yymsp[-11].minor.yy664 = createIndexOption(pCxt, yymsp[-9].minor.yy1006, releaseRawExprNode(pCxt, yymsp[-5].minor.yy664), releaseRawExprNode(pCxt, yymsp[-3].minor.yy664), yymsp[-1].minor.yy664, yymsp[0].minor.yy664); } +{ yymsp[-11].minor.yy392 = createIndexOption(pCxt, yymsp[-9].minor.yy184, releaseRawExprNode(pCxt, yymsp[-5].minor.yy392), releaseRawExprNode(pCxt, yymsp[-3].minor.yy392), yymsp[-1].minor.yy392, yymsp[0].minor.yy392); } break; case 320: /* func ::= sma_func_name NK_LP expression_list NK_RP */ -{ yylhsminor.yy664 = createFunctionNode(pCxt, &yymsp[-3].minor.yy213, yymsp[-1].minor.yy1006); } - yymsp[-3].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createFunctionNode(pCxt, &yymsp[-3].minor.yy369, yymsp[-1].minor.yy184); } + yymsp[-3].minor.yy392 = yylhsminor.yy392; break; case 321: /* sma_func_name ::= function_name */ case 545: /* alias_opt ::= table_alias */ yytestcase(yyruleno==545); -{ yylhsminor.yy213 = yymsp[0].minor.yy213; } - yymsp[0].minor.yy213 = yylhsminor.yy213; +{ yylhsminor.yy369 = yymsp[0].minor.yy369; } + yymsp[0].minor.yy369 = yylhsminor.yy369; break; case 326: /* sma_stream_opt ::= */ case 371: /* stream_options ::= */ yytestcase(yyruleno==371); -{ yymsp[1].minor.yy664 = createStreamOptions(pCxt); } +{ yymsp[1].minor.yy392 = createStreamOptions(pCxt); } break; case 327: /* sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */ -{ ((SStreamOptions*)yymsp[-2].minor.yy664)->pWatermark = releaseRawExprNode(pCxt, yymsp[0].minor.yy664); yylhsminor.yy664 = yymsp[-2].minor.yy664; } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ ((SStreamOptions*)yymsp[-2].minor.yy392)->pWatermark = releaseRawExprNode(pCxt, yymsp[0].minor.yy392); yylhsminor.yy392 = yymsp[-2].minor.yy392; } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 328: /* sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */ -{ ((SStreamOptions*)yymsp[-2].minor.yy664)->pDelay = releaseRawExprNode(pCxt, yymsp[0].minor.yy664); yylhsminor.yy664 = yymsp[-2].minor.yy664; } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ ((SStreamOptions*)yymsp[-2].minor.yy392)->pDelay = releaseRawExprNode(pCxt, yymsp[0].minor.yy392); yylhsminor.yy392 = yymsp[-2].minor.yy392; } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 329: /* sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */ -{ ((SStreamOptions*)yymsp[-2].minor.yy664)->pDeleteMark = releaseRawExprNode(pCxt, yymsp[0].minor.yy664); yylhsminor.yy664 = yymsp[-2].minor.yy664; } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ ((SStreamOptions*)yymsp[-2].minor.yy392)->pDeleteMark = releaseRawExprNode(pCxt, yymsp[0].minor.yy392); yylhsminor.yy392 = yymsp[-2].minor.yy392; } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 330: /* with_meta ::= AS */ -{ yymsp[0].minor.yy316 = 0; } +{ yymsp[0].minor.yy20 = 0; } break; case 331: /* with_meta ::= WITH META AS */ -{ yymsp[-2].minor.yy316 = 1; } +{ yymsp[-2].minor.yy20 = 1; } break; case 332: /* with_meta ::= ONLY META AS */ -{ yymsp[-2].minor.yy316 = 2; } +{ yymsp[-2].minor.yy20 = 2; } break; case 333: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */ -{ pCxt->pRootNode = createCreateTopicStmtUseQuery(pCxt, yymsp[-3].minor.yy885, &yymsp[-2].minor.yy213, yymsp[0].minor.yy664); } +{ pCxt->pRootNode = createCreateTopicStmtUseQuery(pCxt, yymsp[-3].minor.yy377, &yymsp[-2].minor.yy369, yymsp[0].minor.yy392); } break; case 334: /* cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */ -{ pCxt->pRootNode = createCreateTopicStmtUseDb(pCxt, yymsp[-4].minor.yy885, &yymsp[-3].minor.yy213, &yymsp[0].minor.yy213, yymsp[-2].minor.yy316); } +{ pCxt->pRootNode = createCreateTopicStmtUseDb(pCxt, yymsp[-4].minor.yy377, &yymsp[-3].minor.yy369, &yymsp[0].minor.yy369, yymsp[-2].minor.yy20); } break; case 335: /* cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */ -{ pCxt->pRootNode = createCreateTopicStmtUseTable(pCxt, yymsp[-5].minor.yy885, &yymsp[-4].minor.yy213, yymsp[-1].minor.yy664, yymsp[-3].minor.yy316, yymsp[0].minor.yy664); } +{ pCxt->pRootNode = createCreateTopicStmtUseTable(pCxt, yymsp[-5].minor.yy377, &yymsp[-4].minor.yy369, yymsp[-1].minor.yy392, yymsp[-3].minor.yy20, yymsp[0].minor.yy392); } break; case 336: /* cmd ::= DROP TOPIC exists_opt topic_name */ -{ pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy885, &yymsp[0].minor.yy213); } +{ pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy377, &yymsp[0].minor.yy369); } break; case 337: /* cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ -{ pCxt->pRootNode = createDropCGroupStmt(pCxt, yymsp[-3].minor.yy885, &yymsp[-2].minor.yy213, &yymsp[0].minor.yy213); } +{ pCxt->pRootNode = createDropCGroupStmt(pCxt, yymsp[-3].minor.yy377, &yymsp[-2].minor.yy369, &yymsp[0].minor.yy369); } break; case 338: /* cmd ::= DESC full_table_name */ case 339: /* cmd ::= DESCRIBE full_table_name */ yytestcase(yyruleno==339); -{ pCxt->pRootNode = createDescribeStmt(pCxt, yymsp[0].minor.yy664); } +{ pCxt->pRootNode = createDescribeStmt(pCxt, yymsp[0].minor.yy392); } break; case 340: /* cmd ::= RESET QUERY CACHE */ { pCxt->pRootNode = createResetQueryCacheStmt(pCxt); } break; case 341: /* cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */ case 342: /* cmd ::= EXPLAIN analyze_opt explain_options insert_query */ yytestcase(yyruleno==342); -{ pCxt->pRootNode = createExplainStmt(pCxt, yymsp[-2].minor.yy885, yymsp[-1].minor.yy664, yymsp[0].minor.yy664); } +{ pCxt->pRootNode = createExplainStmt(pCxt, yymsp[-2].minor.yy377, yymsp[-1].minor.yy392, yymsp[0].minor.yy392); } break; case 345: /* explain_options ::= */ -{ yymsp[1].minor.yy664 = createDefaultExplainOptions(pCxt); } +{ yymsp[1].minor.yy392 = createDefaultExplainOptions(pCxt); } break; case 346: /* explain_options ::= explain_options VERBOSE NK_BOOL */ -{ yylhsminor.yy664 = setExplainVerbose(pCxt, yymsp[-2].minor.yy664, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setExplainVerbose(pCxt, yymsp[-2].minor.yy392, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 347: /* explain_options ::= explain_options RATIO NK_FLOAT */ -{ yylhsminor.yy664 = setExplainRatio(pCxt, yymsp[-2].minor.yy664, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setExplainRatio(pCxt, yymsp[-2].minor.yy392, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 348: /* cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */ -{ pCxt->pRootNode = createCreateFunctionStmt(pCxt, yymsp[-7].minor.yy885, yymsp[-9].minor.yy885, &yymsp[-6].minor.yy213, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy892, yymsp[-1].minor.yy316, &yymsp[0].minor.yy213, yymsp[-10].minor.yy885); } +{ pCxt->pRootNode = createCreateFunctionStmt(pCxt, yymsp[-7].minor.yy377, yymsp[-9].minor.yy377, &yymsp[-6].minor.yy369, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy864, yymsp[-1].minor.yy20, &yymsp[0].minor.yy369, yymsp[-10].minor.yy377); } break; case 349: /* cmd ::= DROP FUNCTION exists_opt function_name */ -{ pCxt->pRootNode = createDropFunctionStmt(pCxt, yymsp[-1].minor.yy885, &yymsp[0].minor.yy213); } +{ pCxt->pRootNode = createDropFunctionStmt(pCxt, yymsp[-1].minor.yy377, &yymsp[0].minor.yy369); } break; case 354: /* language_opt ::= */ case 392: /* on_vgroup_id ::= */ yytestcase(yyruleno==392); -{ yymsp[1].minor.yy213 = nil_token; } +{ yymsp[1].minor.yy369 = nil_token; } break; case 355: /* language_opt ::= LANGUAGE NK_STRING */ case 393: /* on_vgroup_id ::= ON NK_INTEGER */ yytestcase(yyruleno==393); -{ yymsp[-1].minor.yy213 = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy369 = yymsp[0].minor.yy0; } break; case 358: /* cmd ::= CREATE or_replace_opt VIEW full_view_name AS query_or_subquery */ -{ pCxt->pRootNode = createCreateViewStmt(pCxt, yymsp[-4].minor.yy885, yymsp[-2].minor.yy664, &yymsp[-1].minor.yy0, yymsp[0].minor.yy664); } +{ pCxt->pRootNode = createCreateViewStmt(pCxt, yymsp[-4].minor.yy377, yymsp[-2].minor.yy392, &yymsp[-1].minor.yy0, yymsp[0].minor.yy392); } break; case 359: /* cmd ::= DROP VIEW exists_opt full_view_name */ -{ pCxt->pRootNode = createDropViewStmt(pCxt, yymsp[-1].minor.yy885, yymsp[0].minor.yy664); } +{ pCxt->pRootNode = createDropViewStmt(pCxt, yymsp[-1].minor.yy377, yymsp[0].minor.yy392); } break; case 360: /* full_view_name ::= view_name */ -{ yylhsminor.yy664 = createViewNode(pCxt, NULL, &yymsp[0].minor.yy213); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createViewNode(pCxt, NULL, &yymsp[0].minor.yy369); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 361: /* full_view_name ::= db_name NK_DOT view_name */ -{ yylhsminor.yy664 = createViewNode(pCxt, &yymsp[-2].minor.yy213, &yymsp[0].minor.yy213); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createViewNode(pCxt, &yymsp[-2].minor.yy369, &yymsp[0].minor.yy369); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 362: /* 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 */ -{ pCxt->pRootNode = createCreateStreamStmt(pCxt, yymsp[-9].minor.yy885, &yymsp[-8].minor.yy213, yymsp[-5].minor.yy664, yymsp[-7].minor.yy664, yymsp[-3].minor.yy1006, yymsp[-2].minor.yy664, yymsp[0].minor.yy664, yymsp[-4].minor.yy1006); } +{ pCxt->pRootNode = createCreateStreamStmt(pCxt, yymsp[-9].minor.yy377, &yymsp[-8].minor.yy369, yymsp[-5].minor.yy392, yymsp[-7].minor.yy392, yymsp[-3].minor.yy184, yymsp[-2].minor.yy392, yymsp[0].minor.yy392, yymsp[-4].minor.yy184); } break; case 363: /* cmd ::= DROP STREAM exists_opt stream_name */ -{ pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy885, &yymsp[0].minor.yy213); } +{ pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy377, &yymsp[0].minor.yy369); } break; case 364: /* cmd ::= PAUSE STREAM exists_opt stream_name */ -{ pCxt->pRootNode = createPauseStreamStmt(pCxt, yymsp[-1].minor.yy885, &yymsp[0].minor.yy213); } +{ pCxt->pRootNode = createPauseStreamStmt(pCxt, yymsp[-1].minor.yy377, &yymsp[0].minor.yy369); } break; case 365: /* cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */ -{ pCxt->pRootNode = createResumeStreamStmt(pCxt, yymsp[-2].minor.yy885, yymsp[-1].minor.yy885, &yymsp[0].minor.yy213); } +{ pCxt->pRootNode = createResumeStreamStmt(pCxt, yymsp[-2].minor.yy377, yymsp[-1].minor.yy377, &yymsp[0].minor.yy369); } break; case 372: /* stream_options ::= stream_options TRIGGER AT_ONCE */ case 373: /* stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ yytestcase(yyruleno==373); -{ yylhsminor.yy664 = setStreamOptions(pCxt, yymsp[-2].minor.yy664, SOPT_TRIGGER_TYPE_SET, &yymsp[0].minor.yy0, NULL); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setStreamOptions(pCxt, yymsp[-2].minor.yy392, SOPT_TRIGGER_TYPE_SET, &yymsp[0].minor.yy0, NULL); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 374: /* stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ -{ yylhsminor.yy664 = setStreamOptions(pCxt, yymsp[-3].minor.yy664, SOPT_TRIGGER_TYPE_SET, &yymsp[-1].minor.yy0, releaseRawExprNode(pCxt, yymsp[0].minor.yy664)); } - yymsp[-3].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setStreamOptions(pCxt, yymsp[-3].minor.yy392, SOPT_TRIGGER_TYPE_SET, &yymsp[-1].minor.yy0, releaseRawExprNode(pCxt, yymsp[0].minor.yy392)); } + yymsp[-3].minor.yy392 = yylhsminor.yy392; break; case 375: /* stream_options ::= stream_options WATERMARK duration_literal */ -{ yylhsminor.yy664 = setStreamOptions(pCxt, yymsp[-2].minor.yy664, SOPT_WATERMARK_SET, NULL, releaseRawExprNode(pCxt, yymsp[0].minor.yy664)); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setStreamOptions(pCxt, yymsp[-2].minor.yy392, SOPT_WATERMARK_SET, NULL, releaseRawExprNode(pCxt, yymsp[0].minor.yy392)); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 376: /* stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ -{ yylhsminor.yy664 = setStreamOptions(pCxt, yymsp[-3].minor.yy664, SOPT_IGNORE_EXPIRED_SET, &yymsp[0].minor.yy0, NULL); } - yymsp[-3].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setStreamOptions(pCxt, yymsp[-3].minor.yy392, SOPT_IGNORE_EXPIRED_SET, &yymsp[0].minor.yy0, NULL); } + yymsp[-3].minor.yy392 = yylhsminor.yy392; break; case 377: /* stream_options ::= stream_options FILL_HISTORY NK_INTEGER */ -{ yylhsminor.yy664 = setStreamOptions(pCxt, yymsp[-2].minor.yy664, SOPT_FILL_HISTORY_SET, &yymsp[0].minor.yy0, NULL); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setStreamOptions(pCxt, yymsp[-2].minor.yy392, SOPT_FILL_HISTORY_SET, &yymsp[0].minor.yy0, NULL); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 378: /* stream_options ::= stream_options DELETE_MARK duration_literal */ -{ yylhsminor.yy664 = setStreamOptions(pCxt, yymsp[-2].minor.yy664, SOPT_DELETE_MARK_SET, NULL, releaseRawExprNode(pCxt, yymsp[0].minor.yy664)); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setStreamOptions(pCxt, yymsp[-2].minor.yy392, SOPT_DELETE_MARK_SET, NULL, releaseRawExprNode(pCxt, yymsp[0].minor.yy392)); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 379: /* stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */ -{ yylhsminor.yy664 = setStreamOptions(pCxt, yymsp[-3].minor.yy664, SOPT_IGNORE_UPDATE_SET, &yymsp[0].minor.yy0, NULL); } - yymsp[-3].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = setStreamOptions(pCxt, yymsp[-3].minor.yy392, SOPT_IGNORE_UPDATE_SET, &yymsp[0].minor.yy0, NULL); } + yymsp[-3].minor.yy392 = yylhsminor.yy392; break; case 381: /* subtable_opt ::= SUBTABLE NK_LP expression NK_RP */ - case 599: /* sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP */ yytestcase(yyruleno==599); - case 623: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==623); -{ yymsp[-3].minor.yy664 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy664); } + case 598: /* sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP */ yytestcase(yyruleno==598); + case 622: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==622); +{ yymsp[-3].minor.yy392 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy392); } break; case 384: /* cmd ::= KILL CONNECTION NK_INTEGER */ { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_CONNECTION_STMT, &yymsp[0].minor.yy0); } @@ -6058,48 +6031,48 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createBalanceVgroupStmt(pCxt); } break; case 388: /* cmd ::= BALANCE VGROUP LEADER on_vgroup_id */ -{ pCxt->pRootNode = createBalanceVgroupLeaderStmt(pCxt, &yymsp[0].minor.yy213); } +{ pCxt->pRootNode = createBalanceVgroupLeaderStmt(pCxt, &yymsp[0].minor.yy369); } break; case 389: /* cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ { pCxt->pRootNode = createMergeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } break; case 390: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ -{ pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy1006); } +{ pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy184); } break; case 391: /* cmd ::= SPLIT VGROUP NK_INTEGER */ { pCxt->pRootNode = createSplitVgroupStmt(pCxt, &yymsp[0].minor.yy0); } break; case 394: /* dnode_list ::= DNODE NK_INTEGER */ -{ yymsp[-1].minor.yy1006 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } +{ yymsp[-1].minor.yy184 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } break; case 396: /* cmd ::= DELETE FROM full_table_name where_clause_opt */ -{ pCxt->pRootNode = createDeleteStmt(pCxt, yymsp[-1].minor.yy664, yymsp[0].minor.yy664); } +{ pCxt->pRootNode = createDeleteStmt(pCxt, yymsp[-1].minor.yy392, yymsp[0].minor.yy392); } break; case 399: /* insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */ -{ yymsp[-6].minor.yy664 = createInsertStmt(pCxt, yymsp[-4].minor.yy664, yymsp[-2].minor.yy1006, yymsp[0].minor.yy664); } +{ yymsp[-6].minor.yy392 = createInsertStmt(pCxt, yymsp[-4].minor.yy392, yymsp[-2].minor.yy184, yymsp[0].minor.yy392); } break; case 400: /* insert_query ::= INSERT INTO full_table_name query_or_subquery */ -{ yymsp[-3].minor.yy664 = createInsertStmt(pCxt, yymsp[-1].minor.yy664, NULL, yymsp[0].minor.yy664); } +{ yymsp[-3].minor.yy392 = createInsertStmt(pCxt, yymsp[-1].minor.yy392, NULL, yymsp[0].minor.yy392); } break; case 401: /* literal ::= NK_INTEGER */ -{ yylhsminor.yy664 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 402: /* literal ::= NK_FLOAT */ -{ yylhsminor.yy664 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 403: /* literal ::= NK_STRING */ -{ yylhsminor.yy664 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 404: /* literal ::= NK_BOOL */ -{ yylhsminor.yy664 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 405: /* literal ::= TIMESTAMP NK_STRING */ -{ yylhsminor.yy664 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); } - yymsp[-1].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); } + yymsp[-1].minor.yy392 = yylhsminor.yy392; break; case 406: /* literal ::= duration_literal */ case 416: /* signed_literal ::= signed */ yytestcase(yyruleno==416); @@ -6117,190 +6090,190 @@ static YYACTIONTYPE yy_reduce( case 538: /* table_reference ::= table_primary */ yytestcase(yyruleno==538); case 539: /* table_reference ::= joined_table */ yytestcase(yyruleno==539); case 543: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==543); - case 625: /* query_simple ::= query_specification */ yytestcase(yyruleno==625); - case 626: /* query_simple ::= union_query_expression */ yytestcase(yyruleno==626); - case 629: /* query_simple_or_subquery ::= query_simple */ yytestcase(yyruleno==629); - case 631: /* query_or_subquery ::= query_expression */ yytestcase(yyruleno==631); -{ yylhsminor.yy664 = yymsp[0].minor.yy664; } - yymsp[0].minor.yy664 = yylhsminor.yy664; + case 624: /* query_simple ::= query_specification */ yytestcase(yyruleno==624); + case 625: /* query_simple ::= union_query_expression */ yytestcase(yyruleno==625); + case 628: /* query_simple_or_subquery ::= query_simple */ yytestcase(yyruleno==628); + case 630: /* query_or_subquery ::= query_expression */ yytestcase(yyruleno==630); +{ yylhsminor.yy392 = yymsp[0].minor.yy392; } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 407: /* literal ::= NULL */ -{ yylhsminor.yy664 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 408: /* literal ::= NK_QUESTION */ -{ yylhsminor.yy664 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 409: /* duration_literal ::= NK_VARIABLE */ - case 600: /* interval_sliding_duration_literal ::= NK_VARIABLE */ yytestcase(yyruleno==600); - case 601: /* interval_sliding_duration_literal ::= NK_STRING */ yytestcase(yyruleno==601); - case 602: /* interval_sliding_duration_literal ::= NK_INTEGER */ yytestcase(yyruleno==602); -{ yylhsminor.yy664 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy664 = yylhsminor.yy664; + case 599: /* interval_sliding_duration_literal ::= NK_VARIABLE */ yytestcase(yyruleno==599); + case 600: /* interval_sliding_duration_literal ::= NK_STRING */ yytestcase(yyruleno==600); + case 601: /* interval_sliding_duration_literal ::= NK_INTEGER */ yytestcase(yyruleno==601); +{ yylhsminor.yy392 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 410: /* signed ::= NK_INTEGER */ -{ yylhsminor.yy664 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 411: /* signed ::= NK_PLUS NK_INTEGER */ -{ yymsp[-1].minor.yy664 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } +{ yymsp[-1].minor.yy392 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } break; case 412: /* signed ::= NK_MINUS NK_INTEGER */ { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy664 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &t); + yylhsminor.yy392 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &t); } - yymsp[-1].minor.yy664 = yylhsminor.yy664; + yymsp[-1].minor.yy392 = yylhsminor.yy392; break; case 413: /* signed ::= NK_FLOAT */ -{ yylhsminor.yy664 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 414: /* signed ::= NK_PLUS NK_FLOAT */ -{ yymsp[-1].minor.yy664 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } +{ yymsp[-1].minor.yy392 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } break; case 415: /* signed ::= NK_MINUS NK_FLOAT */ { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy664 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t); + yylhsminor.yy392 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t); } - yymsp[-1].minor.yy664 = yylhsminor.yy664; + yymsp[-1].minor.yy392 = yylhsminor.yy392; break; case 417: /* signed_literal ::= NK_STRING */ -{ yylhsminor.yy664 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 418: /* signed_literal ::= NK_BOOL */ -{ yylhsminor.yy664 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 419: /* signed_literal ::= TIMESTAMP NK_STRING */ -{ yymsp[-1].minor.yy664 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } +{ yymsp[-1].minor.yy392 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } break; case 420: /* signed_literal ::= duration_literal */ case 422: /* signed_literal ::= literal_func */ yytestcase(yyruleno==422); case 497: /* star_func_para ::= expr_or_subquery */ yytestcase(yyruleno==497); - case 579: /* select_item ::= common_expression */ yytestcase(yyruleno==579); - case 589: /* partition_item ::= expr_or_subquery */ yytestcase(yyruleno==589); - case 630: /* query_simple_or_subquery ::= subquery */ yytestcase(yyruleno==630); - case 632: /* query_or_subquery ::= subquery */ yytestcase(yyruleno==632); - case 645: /* search_condition ::= common_expression */ yytestcase(yyruleno==645); -{ yylhsminor.yy664 = releaseRawExprNode(pCxt, yymsp[0].minor.yy664); } - yymsp[0].minor.yy664 = yylhsminor.yy664; + case 578: /* select_item ::= common_expression */ yytestcase(yyruleno==578); + case 588: /* partition_item ::= expr_or_subquery */ yytestcase(yyruleno==588); + case 629: /* query_simple_or_subquery ::= subquery */ yytestcase(yyruleno==629); + case 631: /* query_or_subquery ::= subquery */ yytestcase(yyruleno==631); + case 644: /* search_condition ::= common_expression */ yytestcase(yyruleno==644); +{ yylhsminor.yy392 = releaseRawExprNode(pCxt, yymsp[0].minor.yy392); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 421: /* signed_literal ::= NULL */ -{ yylhsminor.yy664 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 423: /* signed_literal ::= NK_QUESTION */ -{ yylhsminor.yy664 = createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 441: /* expression ::= pseudo_column */ -{ yylhsminor.yy664 = yymsp[0].minor.yy664; setRawExprNodeIsPseudoColumn(pCxt, yylhsminor.yy664, true); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = yymsp[0].minor.yy392; setRawExprNodeIsPseudoColumn(pCxt, yylhsminor.yy392, true); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 445: /* expression ::= NK_LP expression NK_RP */ case 531: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==531); - case 644: /* subquery ::= NK_LP subquery NK_RP */ yytestcase(yyruleno==644); -{ yylhsminor.yy664 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy664)); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; + case 643: /* subquery ::= NK_LP subquery NK_RP */ yytestcase(yyruleno==643); +{ yylhsminor.yy392 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy392)); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 446: /* expression ::= NK_PLUS expr_or_subquery */ { - SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy664); - yylhsminor.yy664 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy664)); + SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy392); + yylhsminor.yy392 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy392)); } - yymsp[-1].minor.yy664 = yylhsminor.yy664; + yymsp[-1].minor.yy392 = yylhsminor.yy392; break; case 447: /* expression ::= NK_MINUS expr_or_subquery */ { - SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy664); - yylhsminor.yy664 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy664), NULL)); + SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy392); + yylhsminor.yy392 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy392), NULL)); } - yymsp[-1].minor.yy664 = yylhsminor.yy664; + yymsp[-1].minor.yy392 = yylhsminor.yy392; break; case 448: /* expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy664); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy664); - yylhsminor.yy664 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_ADD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy664), releaseRawExprNode(pCxt, yymsp[0].minor.yy664))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy392); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy392); + yylhsminor.yy392 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_ADD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy392), releaseRawExprNode(pCxt, yymsp[0].minor.yy392))); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 449: /* expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy664); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy664); - yylhsminor.yy664 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_SUB, releaseRawExprNode(pCxt, yymsp[-2].minor.yy664), releaseRawExprNode(pCxt, yymsp[0].minor.yy664))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy392); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy392); + yylhsminor.yy392 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_SUB, releaseRawExprNode(pCxt, yymsp[-2].minor.yy392), releaseRawExprNode(pCxt, yymsp[0].minor.yy392))); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 450: /* expression ::= expr_or_subquery NK_STAR expr_or_subquery */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy664); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy664); - yylhsminor.yy664 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MULTI, releaseRawExprNode(pCxt, yymsp[-2].minor.yy664), releaseRawExprNode(pCxt, yymsp[0].minor.yy664))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy392); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy392); + yylhsminor.yy392 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MULTI, releaseRawExprNode(pCxt, yymsp[-2].minor.yy392), releaseRawExprNode(pCxt, yymsp[0].minor.yy392))); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 451: /* expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy664); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy664); - yylhsminor.yy664 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_DIV, releaseRawExprNode(pCxt, yymsp[-2].minor.yy664), releaseRawExprNode(pCxt, yymsp[0].minor.yy664))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy392); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy392); + yylhsminor.yy392 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_DIV, releaseRawExprNode(pCxt, yymsp[-2].minor.yy392), releaseRawExprNode(pCxt, yymsp[0].minor.yy392))); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 452: /* expression ::= expr_or_subquery NK_REM expr_or_subquery */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy664); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy664); - yylhsminor.yy664 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_REM, releaseRawExprNode(pCxt, yymsp[-2].minor.yy664), releaseRawExprNode(pCxt, yymsp[0].minor.yy664))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy392); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy392); + yylhsminor.yy392 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_REM, releaseRawExprNode(pCxt, yymsp[-2].minor.yy392), releaseRawExprNode(pCxt, yymsp[0].minor.yy392))); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 453: /* expression ::= column_reference NK_ARROW NK_STRING */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy664); - yylhsminor.yy664 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy664), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy392); + yylhsminor.yy392 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy392), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0))); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 454: /* expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy664); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy664); - yylhsminor.yy664 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy664), releaseRawExprNode(pCxt, yymsp[0].minor.yy664))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy392); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy392); + yylhsminor.yy392 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy392), releaseRawExprNode(pCxt, yymsp[0].minor.yy392))); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 455: /* expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy664); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy664); - yylhsminor.yy664 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy664), releaseRawExprNode(pCxt, yymsp[0].minor.yy664))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy392); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy392); + yylhsminor.yy392 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy392), releaseRawExprNode(pCxt, yymsp[0].minor.yy392))); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 458: /* column_reference ::= column_name */ -{ yylhsminor.yy664 = createRawExprNode(pCxt, &yymsp[0].minor.yy213, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy213)); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRawExprNode(pCxt, &yymsp[0].minor.yy369, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy369)); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 459: /* column_reference ::= table_name NK_DOT column_name */ -{ yylhsminor.yy664 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy213, &yymsp[0].minor.yy213, createColumnNode(pCxt, &yymsp[-2].minor.yy213, &yymsp[0].minor.yy213)); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy369, &yymsp[0].minor.yy369, createColumnNode(pCxt, &yymsp[-2].minor.yy369, &yymsp[0].minor.yy369)); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 460: /* column_reference ::= NK_ALIAS */ -{ yylhsminor.yy664 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 461: /* column_reference ::= table_name NK_DOT NK_ALIAS */ -{ yylhsminor.yy664 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy213, &yymsp[0].minor.yy0, createColumnNode(pCxt, &yymsp[-2].minor.yy213, &yymsp[0].minor.yy0)); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy369, &yymsp[0].minor.yy0, createColumnNode(pCxt, &yymsp[-2].minor.yy369, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 462: /* pseudo_column ::= ROWTS */ case 463: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==463); @@ -6314,392 +6287,389 @@ static YYACTIONTYPE yy_reduce( case 472: /* pseudo_column ::= ISFILLED */ yytestcase(yyruleno==472); case 473: /* pseudo_column ::= QTAGS */ yytestcase(yyruleno==473); case 479: /* literal_func ::= NOW */ yytestcase(yyruleno==479); -{ yylhsminor.yy664 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); } - yymsp[0].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; case 464: /* pseudo_column ::= table_name NK_DOT TBNAME */ -{ yylhsminor.yy664 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy213, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy213)))); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy369, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy369)))); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 474: /* function_expression ::= function_name NK_LP expression_list NK_RP */ case 475: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==475); -{ yylhsminor.yy664 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy213, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy213, yymsp[-1].minor.yy1006)); } - yymsp[-3].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy369, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy369, yymsp[-1].minor.yy184)); } + yymsp[-3].minor.yy392 = yylhsminor.yy392; break; case 476: /* function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ -{ yylhsminor.yy664 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy664), yymsp[-1].minor.yy892)); } - yymsp[-5].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy392), yymsp[-1].minor.yy864)); } + yymsp[-5].minor.yy392 = yylhsminor.yy392; break; case 478: /* literal_func ::= noarg_func NK_LP NK_RP */ -{ yylhsminor.yy664 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy213, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy213, NULL)); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy369, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy369, NULL)); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 493: /* star_func_para_list ::= NK_STAR */ -{ yylhsminor.yy1006 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy1006 = yylhsminor.yy1006; +{ yylhsminor.yy184 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy184 = yylhsminor.yy184; break; case 498: /* star_func_para ::= table_name NK_DOT NK_STAR */ - case 582: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==582); -{ yylhsminor.yy664 = createColumnNode(pCxt, &yymsp[-2].minor.yy213, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; + case 581: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==581); +{ yylhsminor.yy392 = createColumnNode(pCxt, &yymsp[-2].minor.yy369, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 499: /* case_when_expression ::= CASE when_then_list case_when_else_opt END */ -{ yylhsminor.yy664 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, NULL, yymsp[-2].minor.yy1006, yymsp[-1].minor.yy664)); } - yymsp[-3].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, NULL, yymsp[-2].minor.yy184, yymsp[-1].minor.yy392)); } + yymsp[-3].minor.yy392 = yylhsminor.yy392; break; case 500: /* case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ -{ yylhsminor.yy664 = createRawExprNodeExt(pCxt, &yymsp[-4].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy664), yymsp[-2].minor.yy1006, yymsp[-1].minor.yy664)); } - yymsp[-4].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRawExprNodeExt(pCxt, &yymsp[-4].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy392), yymsp[-2].minor.yy184, yymsp[-1].minor.yy392)); } + yymsp[-4].minor.yy392 = yylhsminor.yy392; break; case 503: /* when_then_expr ::= WHEN common_expression THEN common_expression */ -{ yymsp[-3].minor.yy664 = createWhenThenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy664), releaseRawExprNode(pCxt, yymsp[0].minor.yy664)); } +{ yymsp[-3].minor.yy392 = createWhenThenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy392), releaseRawExprNode(pCxt, yymsp[0].minor.yy392)); } break; case 505: /* case_when_else_opt ::= ELSE common_expression */ -{ yymsp[-1].minor.yy664 = releaseRawExprNode(pCxt, yymsp[0].minor.yy664); } +{ yymsp[-1].minor.yy392 = releaseRawExprNode(pCxt, yymsp[0].minor.yy392); } break; case 506: /* predicate ::= expr_or_subquery compare_op expr_or_subquery */ case 511: /* predicate ::= expr_or_subquery in_op in_predicate_value */ yytestcase(yyruleno==511); { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy664); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy664); - yylhsminor.yy664 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, yymsp[-1].minor.yy484, releaseRawExprNode(pCxt, yymsp[-2].minor.yy664), releaseRawExprNode(pCxt, yymsp[0].minor.yy664))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy392); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy392); + yylhsminor.yy392 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, yymsp[-1].minor.yy220, releaseRawExprNode(pCxt, yymsp[-2].minor.yy392), releaseRawExprNode(pCxt, yymsp[0].minor.yy392))); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 507: /* predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy664); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy664); - yylhsminor.yy664 = createRawExprNodeExt(pCxt, &s, &e, createBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-4].minor.yy664), releaseRawExprNode(pCxt, yymsp[-2].minor.yy664), releaseRawExprNode(pCxt, yymsp[0].minor.yy664))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy392); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy392); + yylhsminor.yy392 = createRawExprNodeExt(pCxt, &s, &e, createBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-4].minor.yy392), releaseRawExprNode(pCxt, yymsp[-2].minor.yy392), releaseRawExprNode(pCxt, yymsp[0].minor.yy392))); } - yymsp[-4].minor.yy664 = yylhsminor.yy664; + yymsp[-4].minor.yy392 = yylhsminor.yy392; break; case 508: /* predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy664); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy664); - yylhsminor.yy664 = createRawExprNodeExt(pCxt, &s, &e, createNotBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy664), releaseRawExprNode(pCxt, yymsp[-2].minor.yy664), releaseRawExprNode(pCxt, yymsp[0].minor.yy664))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy392); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy392); + yylhsminor.yy392 = createRawExprNodeExt(pCxt, &s, &e, createNotBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy392), releaseRawExprNode(pCxt, yymsp[-2].minor.yy392), releaseRawExprNode(pCxt, yymsp[0].minor.yy392))); } - yymsp[-5].minor.yy664 = yylhsminor.yy664; + yymsp[-5].minor.yy392 = yylhsminor.yy392; break; case 509: /* predicate ::= expr_or_subquery IS NULL */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy664); - yylhsminor.yy664 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy664), NULL)); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy392); + yylhsminor.yy392 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy392), NULL)); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 510: /* predicate ::= expr_or_subquery IS NOT NULL */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy664); - yylhsminor.yy664 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy664), NULL)); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy392); + yylhsminor.yy392 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy392), NULL)); } - yymsp[-3].minor.yy664 = yylhsminor.yy664; + yymsp[-3].minor.yy392 = yylhsminor.yy392; break; case 512: /* compare_op ::= NK_LT */ -{ yymsp[0].minor.yy484 = OP_TYPE_LOWER_THAN; } +{ yymsp[0].minor.yy220 = OP_TYPE_LOWER_THAN; } break; case 513: /* compare_op ::= NK_GT */ -{ yymsp[0].minor.yy484 = OP_TYPE_GREATER_THAN; } +{ yymsp[0].minor.yy220 = OP_TYPE_GREATER_THAN; } break; case 514: /* compare_op ::= NK_LE */ -{ yymsp[0].minor.yy484 = OP_TYPE_LOWER_EQUAL; } +{ yymsp[0].minor.yy220 = OP_TYPE_LOWER_EQUAL; } break; case 515: /* compare_op ::= NK_GE */ -{ yymsp[0].minor.yy484 = OP_TYPE_GREATER_EQUAL; } +{ yymsp[0].minor.yy220 = OP_TYPE_GREATER_EQUAL; } break; case 516: /* compare_op ::= NK_NE */ -{ yymsp[0].minor.yy484 = OP_TYPE_NOT_EQUAL; } +{ yymsp[0].minor.yy220 = OP_TYPE_NOT_EQUAL; } break; case 517: /* compare_op ::= NK_EQ */ -{ yymsp[0].minor.yy484 = OP_TYPE_EQUAL; } +{ yymsp[0].minor.yy220 = OP_TYPE_EQUAL; } break; case 518: /* compare_op ::= LIKE */ -{ yymsp[0].minor.yy484 = OP_TYPE_LIKE; } +{ yymsp[0].minor.yy220 = OP_TYPE_LIKE; } break; case 519: /* compare_op ::= NOT LIKE */ -{ yymsp[-1].minor.yy484 = OP_TYPE_NOT_LIKE; } +{ yymsp[-1].minor.yy220 = OP_TYPE_NOT_LIKE; } break; case 520: /* compare_op ::= MATCH */ -{ yymsp[0].minor.yy484 = OP_TYPE_MATCH; } +{ yymsp[0].minor.yy220 = OP_TYPE_MATCH; } break; case 521: /* compare_op ::= NMATCH */ -{ yymsp[0].minor.yy484 = OP_TYPE_NMATCH; } +{ yymsp[0].minor.yy220 = OP_TYPE_NMATCH; } break; case 522: /* compare_op ::= CONTAINS */ -{ yymsp[0].minor.yy484 = OP_TYPE_JSON_CONTAINS; } +{ yymsp[0].minor.yy220 = OP_TYPE_JSON_CONTAINS; } break; case 523: /* in_op ::= IN */ -{ yymsp[0].minor.yy484 = OP_TYPE_IN; } +{ yymsp[0].minor.yy220 = OP_TYPE_IN; } break; case 524: /* in_op ::= NOT IN */ -{ yymsp[-1].minor.yy484 = OP_TYPE_NOT_IN; } +{ yymsp[-1].minor.yy220 = OP_TYPE_NOT_IN; } break; case 525: /* in_predicate_value ::= NK_LP literal_list NK_RP */ -{ yylhsminor.yy664 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy1006)); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy184)); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 527: /* boolean_value_expression ::= NOT boolean_primary */ { - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy664); - yylhsminor.yy664 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy664), NULL)); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy392); + yylhsminor.yy392 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy392), NULL)); } - yymsp[-1].minor.yy664 = yylhsminor.yy664; + yymsp[-1].minor.yy392 = yylhsminor.yy392; break; case 528: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy664); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy664); - yylhsminor.yy664 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy664), releaseRawExprNode(pCxt, yymsp[0].minor.yy664))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy392); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy392); + yylhsminor.yy392 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy392), releaseRawExprNode(pCxt, yymsp[0].minor.yy392))); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 529: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy664); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy664); - yylhsminor.yy664 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy664), releaseRawExprNode(pCxt, yymsp[0].minor.yy664))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy392); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy392); + yylhsminor.yy392 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy392), releaseRawExprNode(pCxt, yymsp[0].minor.yy392))); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 537: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */ -{ yylhsminor.yy664 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, JOIN_STYPE_NONE, yymsp[-2].minor.yy664, yymsp[0].minor.yy664, NULL); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, JOIN_STYPE_NONE, yymsp[-2].minor.yy392, yymsp[0].minor.yy392, NULL); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; case 540: /* table_primary ::= table_name alias_opt */ -{ yylhsminor.yy664 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy213, &yymsp[0].minor.yy213); } - yymsp[-1].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy369, &yymsp[0].minor.yy369); } + yymsp[-1].minor.yy392 = yylhsminor.yy392; break; case 541: /* table_primary ::= db_name NK_DOT table_name alias_opt */ -{ yylhsminor.yy664 = createRealTableNode(pCxt, &yymsp[-3].minor.yy213, &yymsp[-1].minor.yy213, &yymsp[0].minor.yy213); } - yymsp[-3].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createRealTableNode(pCxt, &yymsp[-3].minor.yy369, &yymsp[-1].minor.yy369, &yymsp[0].minor.yy369); } + yymsp[-3].minor.yy392 = yylhsminor.yy392; break; case 542: /* table_primary ::= subquery alias_opt */ -{ yylhsminor.yy664 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy664), &yymsp[0].minor.yy213); } - yymsp[-1].minor.yy664 = yylhsminor.yy664; +{ yylhsminor.yy392 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy392), &yymsp[0].minor.yy369); } + yymsp[-1].minor.yy392 = yylhsminor.yy392; break; case 544: /* alias_opt ::= */ -{ yymsp[1].minor.yy213 = nil_token; } +{ yymsp[1].minor.yy369 = nil_token; } break; case 546: /* alias_opt ::= AS table_alias */ -{ yymsp[-1].minor.yy213 = yymsp[0].minor.yy213; } +{ yymsp[-1].minor.yy369 = yymsp[0].minor.yy369; } break; case 547: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */ case 548: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==548); -{ yymsp[-2].minor.yy664 = yymsp[-1].minor.yy664; } +{ yymsp[-2].minor.yy392 = yymsp[-1].minor.yy392; } break; case 549: /* joined_table ::= table_reference join_type join_subtype JOIN table_reference ON search_condition window_offset_clause_opt jlimit_clause_opt */ { - yylhsminor.yy664 = createJoinTableNode(pCxt, yymsp[-7].minor.yy310, yymsp[-6].minor.yy972, yymsp[-8].minor.yy664, yymsp[-4].minor.yy664, yymsp[-2].minor.yy664); - yylhsminor.yy664 = addWindowOffsetClause(pCxt, yylhsminor.yy664, yymsp[-1].minor.yy664); - yylhsminor.yy664 = addJLimitClause(pCxt, yylhsminor.yy664, yymsp[0].minor.yy664); + yylhsminor.yy392 = createJoinTableNode(pCxt, yymsp[-7].minor.yy932, yymsp[-6].minor.yy454, yymsp[-8].minor.yy392, yymsp[-4].minor.yy392, yymsp[-2].minor.yy392); + yylhsminor.yy392 = addWindowOffsetClause(pCxt, yylhsminor.yy392, yymsp[-1].minor.yy392); + yylhsminor.yy392 = addJLimitClause(pCxt, yylhsminor.yy392, yymsp[0].minor.yy392); } - yymsp[-8].minor.yy664 = yylhsminor.yy664; + yymsp[-8].minor.yy392 = yylhsminor.yy392; break; case 550: /* join_type ::= */ -{ yymsp[1].minor.yy310 = JOIN_TYPE_INNER; } +{ yymsp[1].minor.yy932 = JOIN_TYPE_INNER; } break; case 551: /* join_type ::= INNER */ -{ yymsp[0].minor.yy310 = JOIN_TYPE_INNER; } +{ yymsp[0].minor.yy932 = JOIN_TYPE_INNER; } break; case 552: /* join_type ::= LEFT */ -{ yymsp[0].minor.yy310 = JOIN_TYPE_LEFT; } +{ yymsp[0].minor.yy932 = JOIN_TYPE_LEFT; } break; case 553: /* join_type ::= RIGHT */ -{ yymsp[0].minor.yy310 = JOIN_TYPE_RIGHT; } +{ yymsp[0].minor.yy932 = JOIN_TYPE_RIGHT; } break; case 554: /* join_type ::= FULL */ -{ yymsp[0].minor.yy310 = JOIN_TYPE_FULL; } +{ yymsp[0].minor.yy932 = JOIN_TYPE_FULL; } break; case 555: /* join_subtype ::= */ -{ yymsp[1].minor.yy972 = JOIN_STYPE_NONE; } +{ yymsp[1].minor.yy454 = JOIN_STYPE_NONE; } break; case 556: /* join_subtype ::= OUTER */ -{ yymsp[0].minor.yy972 = JOIN_STYPE_OUTER; } +{ yymsp[0].minor.yy454 = JOIN_STYPE_OUTER; } break; case 557: /* join_subtype ::= SEMI */ -{ yymsp[0].minor.yy972 = JOIN_STYPE_SEMI; } +{ yymsp[0].minor.yy454 = JOIN_STYPE_SEMI; } break; case 558: /* join_subtype ::= ANTI */ -{ yymsp[0].minor.yy972 = JOIN_STYPE_ANTI; } +{ yymsp[0].minor.yy454 = JOIN_STYPE_ANTI; } break; - case 559: /* join_subtype ::= ANY */ -{ yymsp[0].minor.yy972 = JOIN_STYPE_ANY; } + case 559: /* join_subtype ::= ASOF */ +{ yymsp[0].minor.yy454 = JOIN_STYPE_ASOF; } break; - case 560: /* join_subtype ::= ASOF */ -{ yymsp[0].minor.yy972 = JOIN_STYPE_ASOF; } + case 560: /* join_subtype ::= WINDOW */ +{ yymsp[0].minor.yy454 = JOIN_STYPE_WIN; } break; - case 561: /* join_subtype ::= WINDOW */ -{ yymsp[0].minor.yy972 = JOIN_STYPE_WIN; } + case 562: /* window_offset_clause_opt ::= WINDOW_OFFSET NK_LP window_offset_literal NK_COMMA window_offset_literal NK_RP */ +{ yymsp[-5].minor.yy392 = createWindowOffsetNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy392), releaseRawExprNode(pCxt, yymsp[-1].minor.yy392)); } break; - case 563: /* window_offset_clause_opt ::= WINDOW_OFFSET NK_LP window_offset_literal NK_COMMA window_offset_literal NK_RP */ -{ yymsp[-5].minor.yy664 = createWindowOffsetNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy664), releaseRawExprNode(pCxt, yymsp[-1].minor.yy664)); } + case 563: /* window_offset_literal ::= NK_VARIABLE */ +{ yylhsminor.yy392 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createTimeOffsetValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; - case 564: /* window_offset_literal ::= NK_VARIABLE */ -{ yylhsminor.yy664 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createTimeOffsetValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy664 = yylhsminor.yy664; - break; - case 565: /* window_offset_literal ::= NK_MINUS NK_VARIABLE */ + case 564: /* window_offset_literal ::= NK_MINUS NK_VARIABLE */ { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy664 = createRawExprNode(pCxt, &t, createTimeOffsetValueNode(pCxt, &t)); + yylhsminor.yy392 = createRawExprNode(pCxt, &t, createTimeOffsetValueNode(pCxt, &t)); } - yymsp[-1].minor.yy664 = yylhsminor.yy664; + yymsp[-1].minor.yy392 = yylhsminor.yy392; break; - case 567: /* jlimit_clause_opt ::= JLIMIT NK_INTEGER */ - case 636: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ yytestcase(yyruleno==636); - case 640: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==640); -{ yymsp[-1].minor.yy664 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); } + case 566: /* jlimit_clause_opt ::= JLIMIT NK_INTEGER */ + case 635: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ yytestcase(yyruleno==635); + case 639: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==639); +{ yymsp[-1].minor.yy392 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); } break; - case 568: /* query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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 */ + case 567: /* query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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[-13].minor.yy664 = createSelectStmt(pCxt, yymsp[-11].minor.yy885, yymsp[-9].minor.yy1006, yymsp[-8].minor.yy664, yymsp[-12].minor.yy1006); - yymsp[-13].minor.yy664 = setSelectStmtTagMode(pCxt, yymsp[-13].minor.yy664, yymsp[-10].minor.yy885); - yymsp[-13].minor.yy664 = addWhereClause(pCxt, yymsp[-13].minor.yy664, yymsp[-7].minor.yy664); - yymsp[-13].minor.yy664 = addPartitionByClause(pCxt, yymsp[-13].minor.yy664, yymsp[-6].minor.yy1006); - yymsp[-13].minor.yy664 = addWindowClauseClause(pCxt, yymsp[-13].minor.yy664, yymsp[-2].minor.yy664); - yymsp[-13].minor.yy664 = addGroupByClause(pCxt, yymsp[-13].minor.yy664, yymsp[-1].minor.yy1006); - yymsp[-13].minor.yy664 = addHavingClause(pCxt, yymsp[-13].minor.yy664, yymsp[0].minor.yy664); - yymsp[-13].minor.yy664 = addRangeClause(pCxt, yymsp[-13].minor.yy664, yymsp[-5].minor.yy664); - yymsp[-13].minor.yy664 = addEveryClause(pCxt, yymsp[-13].minor.yy664, yymsp[-4].minor.yy664); - yymsp[-13].minor.yy664 = addFillClause(pCxt, yymsp[-13].minor.yy664, yymsp[-3].minor.yy664); + yymsp[-13].minor.yy392 = createSelectStmt(pCxt, yymsp[-11].minor.yy377, yymsp[-9].minor.yy184, yymsp[-8].minor.yy392, yymsp[-12].minor.yy184); + yymsp[-13].minor.yy392 = setSelectStmtTagMode(pCxt, yymsp[-13].minor.yy392, yymsp[-10].minor.yy377); + yymsp[-13].minor.yy392 = addWhereClause(pCxt, yymsp[-13].minor.yy392, yymsp[-7].minor.yy392); + yymsp[-13].minor.yy392 = addPartitionByClause(pCxt, yymsp[-13].minor.yy392, yymsp[-6].minor.yy184); + yymsp[-13].minor.yy392 = addWindowClauseClause(pCxt, yymsp[-13].minor.yy392, yymsp[-2].minor.yy392); + yymsp[-13].minor.yy392 = addGroupByClause(pCxt, yymsp[-13].minor.yy392, yymsp[-1].minor.yy184); + yymsp[-13].minor.yy392 = addHavingClause(pCxt, yymsp[-13].minor.yy392, yymsp[0].minor.yy392); + yymsp[-13].minor.yy392 = addRangeClause(pCxt, yymsp[-13].minor.yy392, yymsp[-5].minor.yy392); + yymsp[-13].minor.yy392 = addEveryClause(pCxt, yymsp[-13].minor.yy392, yymsp[-4].minor.yy392); + yymsp[-13].minor.yy392 = addFillClause(pCxt, yymsp[-13].minor.yy392, yymsp[-3].minor.yy392); } break; - case 569: /* hint_list ::= */ -{ yymsp[1].minor.yy1006 = createHintNodeList(pCxt, NULL); } + case 568: /* hint_list ::= */ +{ yymsp[1].minor.yy184 = createHintNodeList(pCxt, NULL); } break; - case 570: /* hint_list ::= NK_HINT */ -{ yylhsminor.yy1006 = createHintNodeList(pCxt, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy1006 = yylhsminor.yy1006; + case 569: /* hint_list ::= NK_HINT */ +{ yylhsminor.yy184 = createHintNodeList(pCxt, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy184 = yylhsminor.yy184; break; - case 575: /* set_quantifier_opt ::= ALL */ -{ yymsp[0].minor.yy885 = false; } + case 574: /* set_quantifier_opt ::= ALL */ +{ yymsp[0].minor.yy377 = false; } break; - case 578: /* select_item ::= NK_STAR */ -{ yylhsminor.yy664 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy664 = yylhsminor.yy664; + case 577: /* select_item ::= NK_STAR */ +{ yylhsminor.yy392 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy392 = yylhsminor.yy392; break; - case 580: /* select_item ::= common_expression column_alias */ - case 590: /* partition_item ::= expr_or_subquery column_alias */ yytestcase(yyruleno==590); -{ yylhsminor.yy664 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy664), &yymsp[0].minor.yy213); } - yymsp[-1].minor.yy664 = yylhsminor.yy664; + case 579: /* select_item ::= common_expression column_alias */ + case 589: /* partition_item ::= expr_or_subquery column_alias */ yytestcase(yyruleno==589); +{ yylhsminor.yy392 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy392), &yymsp[0].minor.yy369); } + yymsp[-1].minor.yy392 = yylhsminor.yy392; break; - case 581: /* select_item ::= common_expression AS column_alias */ - case 591: /* partition_item ::= expr_or_subquery AS column_alias */ yytestcase(yyruleno==591); -{ yylhsminor.yy664 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy664), &yymsp[0].minor.yy213); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; + case 580: /* select_item ::= common_expression AS column_alias */ + case 590: /* partition_item ::= expr_or_subquery AS column_alias */ yytestcase(yyruleno==590); +{ yylhsminor.yy392 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy392), &yymsp[0].minor.yy369); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; - case 586: /* partition_by_clause_opt ::= PARTITION BY partition_list */ - case 614: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==614); - case 634: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==634); -{ yymsp[-2].minor.yy1006 = yymsp[0].minor.yy1006; } + case 585: /* partition_by_clause_opt ::= PARTITION BY partition_list */ + case 613: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==613); + case 633: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==633); +{ yymsp[-2].minor.yy184 = yymsp[0].minor.yy184; } break; - case 593: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP */ -{ yymsp[-5].minor.yy664 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy664), releaseRawExprNode(pCxt, yymsp[-1].minor.yy664)); } + case 592: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP */ +{ yymsp[-5].minor.yy392 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy392), releaseRawExprNode(pCxt, yymsp[-1].minor.yy392)); } break; - case 594: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ -{ yymsp[-3].minor.yy664 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy664)); } + case 593: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ +{ yymsp[-3].minor.yy392 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy392)); } break; - case 595: /* twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ -{ yymsp[-5].minor.yy664 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy664), NULL, yymsp[-1].minor.yy664, yymsp[0].minor.yy664); } + case 594: /* twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ +{ yymsp[-5].minor.yy392 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy392), NULL, yymsp[-1].minor.yy392, yymsp[0].minor.yy392); } break; - case 596: /* twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ -{ yymsp[-7].minor.yy664 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy664), releaseRawExprNode(pCxt, yymsp[-3].minor.yy664), yymsp[-1].minor.yy664, yymsp[0].minor.yy664); } + case 595: /* twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ +{ yymsp[-7].minor.yy392 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy392), releaseRawExprNode(pCxt, yymsp[-3].minor.yy392), yymsp[-1].minor.yy392, yymsp[0].minor.yy392); } break; - case 597: /* twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ -{ yymsp[-6].minor.yy664 = createEventWindowNode(pCxt, yymsp[-3].minor.yy664, yymsp[0].minor.yy664); } + case 596: /* twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ +{ yymsp[-6].minor.yy392 = createEventWindowNode(pCxt, yymsp[-3].minor.yy392, yymsp[0].minor.yy392); } break; - case 604: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ -{ yymsp[-3].minor.yy664 = createFillNode(pCxt, yymsp[-1].minor.yy992, NULL); } + case 603: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ +{ yymsp[-3].minor.yy392 = createFillNode(pCxt, yymsp[-1].minor.yy374, NULL); } break; - case 605: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ -{ yymsp[-5].minor.yy664 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy1006)); } + case 604: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ +{ yymsp[-5].minor.yy392 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy184)); } break; - case 606: /* fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ -{ yymsp[-5].minor.yy664 = createFillNode(pCxt, FILL_MODE_VALUE_F, createNodeListNode(pCxt, yymsp[-1].minor.yy1006)); } + case 605: /* fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ +{ yymsp[-5].minor.yy392 = createFillNode(pCxt, FILL_MODE_VALUE_F, createNodeListNode(pCxt, yymsp[-1].minor.yy184)); } break; - case 607: /* fill_mode ::= NONE */ -{ yymsp[0].minor.yy992 = FILL_MODE_NONE; } + case 606: /* fill_mode ::= NONE */ +{ yymsp[0].minor.yy374 = FILL_MODE_NONE; } break; - case 608: /* fill_mode ::= PREV */ -{ yymsp[0].minor.yy992 = FILL_MODE_PREV; } + case 607: /* fill_mode ::= PREV */ +{ yymsp[0].minor.yy374 = FILL_MODE_PREV; } break; - case 609: /* fill_mode ::= NULL */ -{ yymsp[0].minor.yy992 = FILL_MODE_NULL; } + case 608: /* fill_mode ::= NULL */ +{ yymsp[0].minor.yy374 = FILL_MODE_NULL; } break; - case 610: /* fill_mode ::= NULL_F */ -{ yymsp[0].minor.yy992 = FILL_MODE_NULL_F; } + case 609: /* fill_mode ::= NULL_F */ +{ yymsp[0].minor.yy374 = FILL_MODE_NULL_F; } break; - case 611: /* fill_mode ::= LINEAR */ -{ yymsp[0].minor.yy992 = FILL_MODE_LINEAR; } + case 610: /* fill_mode ::= LINEAR */ +{ yymsp[0].minor.yy374 = FILL_MODE_LINEAR; } break; - case 612: /* fill_mode ::= NEXT */ -{ yymsp[0].minor.yy992 = FILL_MODE_NEXT; } + case 611: /* fill_mode ::= NEXT */ +{ yymsp[0].minor.yy374 = FILL_MODE_NEXT; } break; - case 615: /* group_by_list ::= expr_or_subquery */ -{ yylhsminor.yy1006 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy664))); } - yymsp[0].minor.yy1006 = yylhsminor.yy1006; + case 614: /* group_by_list ::= expr_or_subquery */ +{ yylhsminor.yy184 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy392))); } + yymsp[0].minor.yy184 = yylhsminor.yy184; break; - case 616: /* group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ -{ yylhsminor.yy1006 = addNodeToList(pCxt, yymsp[-2].minor.yy1006, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy664))); } - yymsp[-2].minor.yy1006 = yylhsminor.yy1006; + case 615: /* group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ +{ yylhsminor.yy184 = addNodeToList(pCxt, yymsp[-2].minor.yy184, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy392))); } + yymsp[-2].minor.yy184 = yylhsminor.yy184; break; - case 620: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ -{ yymsp[-5].minor.yy664 = createInterpTimeRange(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy664), releaseRawExprNode(pCxt, yymsp[-1].minor.yy664)); } + case 619: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ +{ yymsp[-5].minor.yy392 = createInterpTimeRange(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy392), releaseRawExprNode(pCxt, yymsp[-1].minor.yy392)); } break; - case 621: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ -{ yymsp[-3].minor.yy664 = createInterpTimePoint(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy664)); } + case 620: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ +{ yymsp[-3].minor.yy392 = createInterpTimePoint(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy392)); } break; - case 624: /* query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ + case 623: /* query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ { - yylhsminor.yy664 = addOrderByClause(pCxt, yymsp[-3].minor.yy664, yymsp[-2].minor.yy1006); - yylhsminor.yy664 = addSlimitClause(pCxt, yylhsminor.yy664, yymsp[-1].minor.yy664); - yylhsminor.yy664 = addLimitClause(pCxt, yylhsminor.yy664, yymsp[0].minor.yy664); + yylhsminor.yy392 = addOrderByClause(pCxt, yymsp[-3].minor.yy392, yymsp[-2].minor.yy184); + yylhsminor.yy392 = addSlimitClause(pCxt, yylhsminor.yy392, yymsp[-1].minor.yy392); + yylhsminor.yy392 = addLimitClause(pCxt, yylhsminor.yy392, yymsp[0].minor.yy392); } - yymsp[-3].minor.yy664 = yylhsminor.yy664; + yymsp[-3].minor.yy392 = yylhsminor.yy392; break; - case 627: /* union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ -{ yylhsminor.yy664 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy664, yymsp[0].minor.yy664); } - yymsp[-3].minor.yy664 = yylhsminor.yy664; + case 626: /* union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ +{ yylhsminor.yy392 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy392, yymsp[0].minor.yy392); } + yymsp[-3].minor.yy392 = yylhsminor.yy392; break; - case 628: /* union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ -{ yylhsminor.yy664 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy664, yymsp[0].minor.yy664); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; + case 627: /* union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ +{ yylhsminor.yy392 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy392, yymsp[0].minor.yy392); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; - case 637: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - case 641: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==641); -{ yymsp[-3].minor.yy664 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } + case 636: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + case 640: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==640); +{ yymsp[-3].minor.yy392 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } break; - case 638: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - case 642: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==642); -{ yymsp[-3].minor.yy664 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); } + case 637: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + case 641: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==641); +{ yymsp[-3].minor.yy392 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); } break; - case 643: /* subquery ::= NK_LP query_expression NK_RP */ -{ yylhsminor.yy664 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy664); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; + case 642: /* subquery ::= NK_LP query_expression NK_RP */ +{ yylhsminor.yy392 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy392); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; - case 648: /* sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ -{ yylhsminor.yy664 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy664), yymsp[-1].minor.yy798, yymsp[0].minor.yy371); } - yymsp[-2].minor.yy664 = yylhsminor.yy664; + case 647: /* sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ +{ yylhsminor.yy392 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy392), yymsp[-1].minor.yy578, yymsp[0].minor.yy217); } + yymsp[-2].minor.yy392 = yylhsminor.yy392; break; - case 649: /* ordering_specification_opt ::= */ -{ yymsp[1].minor.yy798 = ORDER_ASC; } + case 648: /* ordering_specification_opt ::= */ +{ yymsp[1].minor.yy578 = ORDER_ASC; } break; - case 650: /* ordering_specification_opt ::= ASC */ -{ yymsp[0].minor.yy798 = ORDER_ASC; } + case 649: /* ordering_specification_opt ::= ASC */ +{ yymsp[0].minor.yy578 = ORDER_ASC; } break; - case 651: /* ordering_specification_opt ::= DESC */ -{ yymsp[0].minor.yy798 = ORDER_DESC; } + case 650: /* ordering_specification_opt ::= DESC */ +{ yymsp[0].minor.yy578 = ORDER_DESC; } break; - case 652: /* null_ordering_opt ::= */ -{ yymsp[1].minor.yy371 = NULL_ORDER_DEFAULT; } + case 651: /* null_ordering_opt ::= */ +{ yymsp[1].minor.yy217 = NULL_ORDER_DEFAULT; } break; - case 653: /* null_ordering_opt ::= NULLS FIRST */ -{ yymsp[-1].minor.yy371 = NULL_ORDER_FIRST; } + case 652: /* null_ordering_opt ::= NULLS FIRST */ +{ yymsp[-1].minor.yy217 = NULL_ORDER_FIRST; } break; - case 654: /* null_ordering_opt ::= NULLS LAST */ -{ yymsp[-1].minor.yy371 = NULL_ORDER_LAST; } + case 653: /* null_ordering_opt ::= NULLS LAST */ +{ yymsp[-1].minor.yy217 = NULL_ORDER_LAST; } break; default: break; diff --git a/source/libs/planner/src/planOptimizer.c b/source/libs/planner/src/planOptimizer.c index f2599e364c..cf4db4cb70 100644 --- a/source/libs/planner/src/planOptimizer.c +++ b/source/libs/planner/src/planOptimizer.c @@ -85,6 +85,7 @@ typedef struct SJoinOptimizeOpt { typedef bool (*FMayBeOptimized)(SLogicNode* pNode); typedef bool (*FShouldBeOptimized)(SLogicNode* pNode, void* pInfo); +#if 0 static SJoinOptimizeOpt gJoinOpt[JOIN_TYPE_MAX_VALUE][JOIN_STYPE_MAX_VALUE] = { /* NONE OUTER SEMI ANTI ANY ASOF WINDOW */ /*INNER*/ {{PUSH_DOWN_ALL_COND}, {0}, {0}, {0}, {PUSH_DOWN_ALL_COND}, {0}, {0}}, @@ -92,6 +93,16 @@ static SJoinOptimizeOpt gJoinOpt[JOIN_TYPE_MAX_VALUE][JOIN_STYPE_MAX_VALUE] = { /*RIGHT*/ {{0}, {PUSH_DOWN_RIGHT_FLT}, {PUSH_DOWN_ALL_COND}, {PUSH_DOWN_RIGHT_FLT}, {PUSH_DOWN_RIGHT_FLT}, {PUSH_DOWN_RIGHT_FLT}, {PUSH_DOWN_RIGHT_FLT}}, /*FULL*/ {{0}, {0}, {0}, {0}, {0}, {0}, {0}}, }; +#else +static SJoinOptimizeOpt gJoinOpt[JOIN_TYPE_MAX_VALUE][JOIN_STYPE_MAX_VALUE] = { + /* NONE OUTER SEMI ANTI ASOF WINDOW */ +/*INNER*/ {{PUSH_DOWN_ALL_COND}, {0}, {0}, {0}, {0}, {0}}, +/*LEFT*/ {{0}, {PUSH_DOWN_LEFT_FLT}, {PUSH_DOWN_ALL_COND}, {PUSH_DOWN_LEFT_FLT}, {PUSH_DOWN_LEFT_FLT}, {PUSH_DOWN_LEFT_FLT}}, +/*RIGHT*/ {{0}, {PUSH_DOWN_RIGHT_FLT}, {PUSH_DOWN_ALL_COND}, {PUSH_DOWN_RIGHT_FLT}, {PUSH_DOWN_RIGHT_FLT}, {PUSH_DOWN_RIGHT_FLT}}, +/*FULL*/ {{0}, {0}, {0}, {0}, {0}, {0}}, +}; + +#endif static SLogicNode* optFindPossibleNode(SLogicNode* pNode, FMayBeOptimized func) { if (func(pNode)) {