From 05a0774b6d706833356031c498c5cef8779547a7 Mon Sep 17 00:00:00 2001 From: Liu Jicong Date: Fri, 27 May 2022 13:58:58 +0800 Subject: [PATCH 01/14] feat(tmq): add sub type --- include/common/tmsg.h | 25 +++++++++++++++---------- source/common/src/tmsg.c | 22 ++++++++++++++-------- source/dnode/mnode/impl/src/mndTopic.c | 8 ++++---- source/dnode/vnode/src/tq/tq.c | 4 ---- source/libs/parser/src/parTranslater.c | 8 ++++---- 5 files changed, 37 insertions(+), 30 deletions(-) diff --git a/include/common/tmsg.h b/include/common/tmsg.h index cc11254dcd..04c3a338b9 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -1473,15 +1473,25 @@ typedef struct { int64_t streamId; } SMVCreateStreamRsp, SMSCreateStreamRsp; +enum { + TOPIC_SUB_TYPE__DB = 1, + TOPIC_SUB_TYPE__TABLE, + TOPIC_SUB_TYPE__COLUMN, +}; + typedef struct { char name[TSDB_TOPIC_FNAME_LEN]; // accout.topic int8_t igExists; - int8_t withTbName; - int8_t withSchema; - int8_t withTag; + // int8_t withTbName; + // int8_t withSchema; + // int8_t withTag; + int8_t subType; char* sql; - char* ast; - char subscribeDbName[TSDB_DB_NAME_LEN]; + union { + char* ast; + char subDbName[TSDB_DB_NAME_LEN]; + char subStbName[TSDB_TABLE_FNAME_LEN]; + }; } SCMCreateTopicReq; int32_t tSerializeSCMCreateTopicReq(void* buf, int32_t bufLen, const SCMCreateTopicReq* pReq); @@ -2145,11 +2155,6 @@ static FORCE_INLINE void* taosDecodeSMqMsg(void* buf, SMqHbMsg* pMsg) { return buf; } -enum { - TOPIC_SUB_TYPE__DB = 1, - TOPIC_SUB_TYPE__TABLE, -}; - typedef struct { SMsgHead head; int64_t leftForVer; diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index 22ac412434..32f764022d 100644 --- a/source/common/src/tmsg.c +++ b/source/common/src/tmsg.c @@ -2677,10 +2677,12 @@ int32_t tSerializeSCMCreateTopicReq(void *buf, int32_t bufLen, const SCMCreateTo if (tStartEncode(&encoder) < 0) return -1; if (tEncodeCStr(&encoder, pReq->name) < 0) return -1; if (tEncodeI8(&encoder, pReq->igExists) < 0) return -1; - if (tEncodeI8(&encoder, pReq->withTbName) < 0) return -1; - if (tEncodeI8(&encoder, pReq->withSchema) < 0) return -1; - if (tEncodeI8(&encoder, pReq->withTag) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->subscribeDbName) < 0) return -1; + /*if (tEncodeI8(&encoder, pReq->withTbName) < 0) return -1;*/ + /*if (tEncodeI8(&encoder, pReq->withSchema) < 0) return -1;*/ + /*if (tEncodeI8(&encoder, pReq->withTag) < 0) return -1;*/ + if (tEncodeI8(&encoder, pReq->subType) < 0) return -1; + if (tEncodeCStr(&encoder, pReq->subDbName) < 0) return -1; + /*if (tEncodeCStr(&encoder, pReq->subStbName) < 0) return -1;*/ if (tEncodeI32(&encoder, sqlLen) < 0) return -1; if (tEncodeI32(&encoder, astLen) < 0) return -1; if (sqlLen > 0 && tEncodeCStr(&encoder, pReq->sql) < 0) return -1; @@ -2703,10 +2705,14 @@ int32_t tDeserializeSCMCreateTopicReq(void *buf, int32_t bufLen, SCMCreateTopicR if (tStartDecode(&decoder) < 0) return -1; if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1; if (tDecodeI8(&decoder, &pReq->igExists) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->withTbName) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->withSchema) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->withTag) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->subscribeDbName) < 0) return -1; + /*if (tDecodeI8(&decoder, &pReq->withTbName) < 0) return -1;*/ + /*if (tDecodeI8(&decoder, &pReq->withSchema) < 0) return -1;*/ + /*if (tDecodeI8(&decoder, &pReq->withTag) < 0) return -1;*/ + if (tDecodeI8(&decoder, &pReq->subType) < 0) return -1; + if (tDecodeCStrTo(&decoder, pReq->subDbName) < 0) return -1; + /*if (pReq->subType == TOPIC_SUB_TYPE__TABLE) {*/ + /*if (tDecodeCStrTo(&decoder, pReq->subStbName) < 0) return -1;*/ + /*}*/ if (tDecodeI32(&decoder, &sqlLen) < 0) return -1; if (tDecodeI32(&decoder, &astLen) < 0) return -1; diff --git a/source/dnode/mnode/impl/src/mndTopic.c b/source/dnode/mnode/impl/src/mndTopic.c index 2048c79847..89f4bfc779 100644 --- a/source/dnode/mnode/impl/src/mndTopic.c +++ b/source/dnode/mnode/impl/src/mndTopic.c @@ -307,7 +307,7 @@ static SDDropTopicReq *mndBuildDropTopicMsg(SMnode *pMnode, SVgObj *pVgroup, SMq } static int32_t mndCheckCreateTopicReq(SCMCreateTopicReq *pCreate) { - if (pCreate->name[0] == 0 || pCreate->sql == NULL || pCreate->sql[0] == 0 || pCreate->subscribeDbName[0] == 0) { + if (pCreate->name[0] == 0 || pCreate->sql == NULL || pCreate->sql[0] == 0 || pCreate->subDbName[0] == 0) { terrno = TSDB_CODE_MND_INVALID_TOPIC; return -1; } @@ -333,8 +333,8 @@ static int32_t mndCreateTopic(SMnode *pMnode, SRpcMsg *pReq, SCMCreateTopicReq * topicObj.ast = strdup(pCreate->ast); topicObj.astLen = strlen(pCreate->ast) + 1; topicObj.subType = TOPIC_SUB_TYPE__TABLE; - topicObj.withTbName = pCreate->withTbName; - topicObj.withSchema = pCreate->withSchema; + /*topicObj.withTbName = pCreate->withTbName;*/ + /*topicObj.withSchema = pCreate->withSchema;*/ SNode *pAst = NULL; if (nodesStringToNode(pCreate->ast, &pAst) != 0) { @@ -441,7 +441,7 @@ static int32_t mndProcessCreateTopicReq(SRpcMsg *pReq) { goto CREATE_TOPIC_OVER; } - pDb = mndAcquireDb(pMnode, createTopicReq.subscribeDbName); + pDb = mndAcquireDb(pMnode, createTopicReq.subDbName); if (pDb == NULL) { terrno = TSDB_CODE_MND_DB_NOT_SELECTED; goto CREATE_TOPIC_OVER; diff --git a/source/dnode/vnode/src/tq/tq.c b/source/dnode/vnode/src/tq/tq.c index 9941b00ff7..93ff049b3e 100644 --- a/source/dnode/vnode/src/tq/tq.c +++ b/source/dnode/vnode/src/tq/tq.c @@ -122,10 +122,6 @@ STQ* tqOpen(const char* path, SVnode* pVnode, SWal* pWal) { ASSERT(0); } - /*if (tdbBegin(pTq->pMetaStore, &txn) < 0) {*/ - /*ASSERT(0);*/ - /*}*/ - TBC* pCur; if (tdbTbcOpen(pTq->pExecStore, &pCur, &txn) < 0) { ASSERT(0); diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index 73abe6cd9d..467df44b7c 100644 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -3239,9 +3239,9 @@ static int32_t buildCreateTopicReq(STranslateContext* pCxt, SCreateTopicStmt* pS tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->topicName, strlen(pStmt->topicName)); tNameGetFullDbName(&name, pReq->name); pReq->igExists = pStmt->ignoreExists; - pReq->withTbName = pStmt->pOptions->withTable; - pReq->withSchema = pStmt->pOptions->withSchema; - pReq->withTag = pStmt->pOptions->withTag; + /*pReq->withTbName = pStmt->pOptions->withTable;*/ + /*pReq->withSchema = pStmt->pOptions->withSchema;*/ + /*pReq->withTag = pStmt->pOptions->withTag;*/ pReq->sql = strdup(pCxt->pParseCxt->pSql); if (NULL == pReq->sql) { @@ -3262,7 +3262,7 @@ static int32_t buildCreateTopicReq(STranslateContext* pCxt, SCreateTopicStmt* pS dbName = pStmt->subscribeDbName; } tNameSetDbName(&name, pCxt->pParseCxt->acctId, dbName, strlen(dbName)); - tNameGetFullDbName(&name, pReq->subscribeDbName); + tNameGetFullDbName(&name, pReq->subDbName); return code; } From 9342ef3ef76c28e8c6912c3bdc35dd0d349c7469 Mon Sep 17 00:00:00 2001 From: Liu Jicong Date: Fri, 27 May 2022 15:40:31 +0800 Subject: [PATCH 02/14] feat(tmq): add sub type --- include/common/tmsg.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/common/tmsg.h b/include/common/tmsg.h index 04c3a338b9..4fa3fa003c 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -1483,8 +1483,8 @@ typedef struct { char name[TSDB_TOPIC_FNAME_LEN]; // accout.topic int8_t igExists; // int8_t withTbName; - // int8_t withSchema; - // int8_t withTag; + // int8_t withSchema; + // int8_t withTag; int8_t subType; char* sql; union { From fdd00a658269a6a9b2736d29d2fc57e5f01d9f3f Mon Sep 17 00:00:00 2001 From: Xiaoyu Wang Date: Mon, 30 May 2022 11:59:23 +0800 Subject: [PATCH 03/14] feat: sql command 'create topic as {database | stable| query}' --- include/common/tmsg.h | 5 +- include/common/ttokendef.h | 182 +- include/libs/nodes/cmdnodes.h | 19 +- include/libs/nodes/nodes.h | 1 - source/common/src/tmsg.c | 56 +- source/libs/nodes/src/nodesCodeFuncs.c | 10 +- source/libs/nodes/src/nodesUtilFuncs.c | 2 - source/libs/parser/inc/parAst.h | 2 +- source/libs/parser/inc/sql.y | 13 +- source/libs/parser/src/parAstCreater.c | 24 +- source/libs/parser/src/parTokenizer.c | 2 - source/libs/parser/src/parTranslater.c | 20 +- source/libs/parser/src/sql.c | 4648 +++++++++---------- source/libs/parser/test/parInitialCTest.cpp | 55 +- 14 files changed, 2521 insertions(+), 2518 deletions(-) diff --git a/include/common/tmsg.h b/include/common/tmsg.h index 4fa3fa003c..6d6cb6a101 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -1482,14 +1482,11 @@ enum { typedef struct { char name[TSDB_TOPIC_FNAME_LEN]; // accout.topic int8_t igExists; - // int8_t withTbName; - // int8_t withSchema; - // int8_t withTag; int8_t subType; char* sql; union { char* ast; - char subDbName[TSDB_DB_NAME_LEN]; + char subDbName[TSDB_DB_FNAME_LEN]; char subStbName[TSDB_TABLE_FNAME_LEN]; }; } SCMCreateTopicReq; diff --git a/include/common/ttokendef.h b/include/common/ttokendef.h index 2fc524eeac..41c8111eea 100644 --- a/include/common/ttokendef.h +++ b/include/common/ttokendef.h @@ -163,98 +163,96 @@ #define TK_TOPIC 145 #define TK_AS 146 #define TK_CGROUP 147 -#define TK_WITH 148 -#define TK_SCHEMA 149 -#define TK_DESC 150 -#define TK_DESCRIBE 151 -#define TK_RESET 152 -#define TK_QUERY 153 -#define TK_CACHE 154 -#define TK_EXPLAIN 155 -#define TK_ANALYZE 156 -#define TK_VERBOSE 157 -#define TK_NK_BOOL 158 -#define TK_RATIO 159 -#define TK_COMPACT 160 -#define TK_VNODES 161 -#define TK_IN 162 -#define TK_OUTPUTTYPE 163 -#define TK_AGGREGATE 164 -#define TK_BUFSIZE 165 -#define TK_STREAM 166 -#define TK_INTO 167 -#define TK_TRIGGER 168 -#define TK_AT_ONCE 169 -#define TK_WINDOW_CLOSE 170 -#define TK_WATERMARK 171 -#define TK_KILL 172 -#define TK_CONNECTION 173 -#define TK_TRANSACTION 174 -#define TK_MERGE 175 -#define TK_VGROUP 176 -#define TK_REDISTRIBUTE 177 -#define TK_SPLIT 178 -#define TK_SYNCDB 179 -#define TK_NULL 180 -#define TK_NK_QUESTION 181 -#define TK_NK_ARROW 182 -#define TK_ROWTS 183 -#define TK_TBNAME 184 -#define TK_QSTARTTS 185 -#define TK_QENDTS 186 -#define TK_WSTARTTS 187 -#define TK_WENDTS 188 -#define TK_WDURATION 189 -#define TK_CAST 190 -#define TK_NOW 191 -#define TK_TODAY 192 -#define TK_TIMEZONE 193 -#define TK_COUNT 194 -#define TK_FIRST 195 -#define TK_LAST 196 -#define TK_LAST_ROW 197 -#define TK_BETWEEN 198 -#define TK_IS 199 -#define TK_NK_LT 200 -#define TK_NK_GT 201 -#define TK_NK_LE 202 -#define TK_NK_GE 203 -#define TK_NK_NE 204 -#define TK_MATCH 205 -#define TK_NMATCH 206 -#define TK_CONTAINS 207 -#define TK_JOIN 208 -#define TK_INNER 209 -#define TK_SELECT 210 -#define TK_DISTINCT 211 -#define TK_WHERE 212 -#define TK_PARTITION 213 -#define TK_BY 214 -#define TK_SESSION 215 -#define TK_STATE_WINDOW 216 -#define TK_SLIDING 217 -#define TK_FILL 218 -#define TK_VALUE 219 -#define TK_NONE 220 -#define TK_PREV 221 -#define TK_LINEAR 222 -#define TK_NEXT 223 -#define TK_GROUP 224 -#define TK_HAVING 225 -#define TK_ORDER 226 -#define TK_SLIMIT 227 -#define TK_SOFFSET 228 -#define TK_LIMIT 229 -#define TK_OFFSET 230 -#define TK_ASC 231 -#define TK_NULLS 232 -#define TK_ID 233 -#define TK_NK_BITNOT 234 -#define TK_INSERT 235 -#define TK_VALUES 236 -#define TK_IMPORT 237 -#define TK_NK_SEMI 238 -#define TK_FILE 239 +#define TK_DESC 148 +#define TK_DESCRIBE 149 +#define TK_RESET 150 +#define TK_QUERY 151 +#define TK_CACHE 152 +#define TK_EXPLAIN 153 +#define TK_ANALYZE 154 +#define TK_VERBOSE 155 +#define TK_NK_BOOL 156 +#define TK_RATIO 157 +#define TK_COMPACT 158 +#define TK_VNODES 159 +#define TK_IN 160 +#define TK_OUTPUTTYPE 161 +#define TK_AGGREGATE 162 +#define TK_BUFSIZE 163 +#define TK_STREAM 164 +#define TK_INTO 165 +#define TK_TRIGGER 166 +#define TK_AT_ONCE 167 +#define TK_WINDOW_CLOSE 168 +#define TK_WATERMARK 169 +#define TK_KILL 170 +#define TK_CONNECTION 171 +#define TK_TRANSACTION 172 +#define TK_MERGE 173 +#define TK_VGROUP 174 +#define TK_REDISTRIBUTE 175 +#define TK_SPLIT 176 +#define TK_SYNCDB 177 +#define TK_NULL 178 +#define TK_NK_QUESTION 179 +#define TK_NK_ARROW 180 +#define TK_ROWTS 181 +#define TK_TBNAME 182 +#define TK_QSTARTTS 183 +#define TK_QENDTS 184 +#define TK_WSTARTTS 185 +#define TK_WENDTS 186 +#define TK_WDURATION 187 +#define TK_CAST 188 +#define TK_NOW 189 +#define TK_TODAY 190 +#define TK_TIMEZONE 191 +#define TK_COUNT 192 +#define TK_FIRST 193 +#define TK_LAST 194 +#define TK_LAST_ROW 195 +#define TK_BETWEEN 196 +#define TK_IS 197 +#define TK_NK_LT 198 +#define TK_NK_GT 199 +#define TK_NK_LE 200 +#define TK_NK_GE 201 +#define TK_NK_NE 202 +#define TK_MATCH 203 +#define TK_NMATCH 204 +#define TK_CONTAINS 205 +#define TK_JOIN 206 +#define TK_INNER 207 +#define TK_SELECT 208 +#define TK_DISTINCT 209 +#define TK_WHERE 210 +#define TK_PARTITION 211 +#define TK_BY 212 +#define TK_SESSION 213 +#define TK_STATE_WINDOW 214 +#define TK_SLIDING 215 +#define TK_FILL 216 +#define TK_VALUE 217 +#define TK_NONE 218 +#define TK_PREV 219 +#define TK_LINEAR 220 +#define TK_NEXT 221 +#define TK_GROUP 222 +#define TK_HAVING 223 +#define TK_ORDER 224 +#define TK_SLIMIT 225 +#define TK_SOFFSET 226 +#define TK_LIMIT 227 +#define TK_OFFSET 228 +#define TK_ASC 229 +#define TK_NULLS 230 +#define TK_ID 231 +#define TK_NK_BITNOT 232 +#define TK_INSERT 233 +#define TK_VALUES 234 +#define TK_IMPORT 235 +#define TK_NK_SEMI 236 +#define TK_FILE 237 #define TK_NK_SPACE 300 #define TK_NK_COMMENT 301 diff --git a/include/libs/nodes/cmdnodes.h b/include/libs/nodes/cmdnodes.h index 7bd3a40c71..f84eef6baf 100644 --- a/include/libs/nodes/cmdnodes.h +++ b/include/libs/nodes/cmdnodes.h @@ -239,20 +239,13 @@ typedef struct SDropComponentNodeStmt { int32_t dnodeId; } SDropComponentNodeStmt; -typedef struct STopicOptions { - ENodeType type; - bool withTable; - bool withSchema; - bool withTag; -} STopicOptions; - typedef struct SCreateTopicStmt { - ENodeType type; - char topicName[TSDB_TABLE_NAME_LEN]; - char subscribeDbName[TSDB_DB_NAME_LEN]; - bool ignoreExists; - SNode* pQuery; - STopicOptions* pOptions; + ENodeType type; + char topicName[TSDB_TABLE_NAME_LEN]; + char subDbName[TSDB_DB_NAME_LEN]; + char subSTbName[TSDB_TABLE_NAME_LEN]; + bool ignoreExists; + SNode* pQuery; } SCreateTopicStmt; typedef struct SDropTopicStmt { diff --git a/include/libs/nodes/nodes.h b/include/libs/nodes/nodes.h index 3860266725..d960ccbd65 100644 --- a/include/libs/nodes/nodes.h +++ b/include/libs/nodes/nodes.h @@ -95,7 +95,6 @@ typedef enum ENodeType { QUERY_NODE_INDEX_OPTIONS, QUERY_NODE_EXPLAIN_OPTIONS, QUERY_NODE_STREAM_OPTIONS, - QUERY_NODE_TOPIC_OPTIONS, QUERY_NODE_LEFT_VALUE, // Statement nodes are used in parser and planner module. diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index 32f764022d..300fb735ec 100644 --- a/source/common/src/tmsg.c +++ b/source/common/src/tmsg.c @@ -2666,27 +2666,23 @@ int32_t tDeserializeSMDropCgroupReq(void *buf, int32_t bufLen, SMDropCgroupReq * } int32_t tSerializeSCMCreateTopicReq(void *buf, int32_t bufLen, const SCMCreateTopicReq *pReq) { - int32_t sqlLen = 0; - int32_t astLen = 0; - if (pReq->sql != NULL) sqlLen = (int32_t)strlen(pReq->sql); - if (pReq->ast != NULL) astLen = (int32_t)strlen(pReq->ast); - SEncoder encoder = {0}; tEncoderInit(&encoder, buf, bufLen); if (tStartEncode(&encoder) < 0) return -1; if (tEncodeCStr(&encoder, pReq->name) < 0) return -1; if (tEncodeI8(&encoder, pReq->igExists) < 0) return -1; - /*if (tEncodeI8(&encoder, pReq->withTbName) < 0) return -1;*/ - /*if (tEncodeI8(&encoder, pReq->withSchema) < 0) return -1;*/ - /*if (tEncodeI8(&encoder, pReq->withTag) < 0) return -1;*/ if (tEncodeI8(&encoder, pReq->subType) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->subDbName) < 0) return -1; - /*if (tEncodeCStr(&encoder, pReq->subStbName) < 0) return -1;*/ - if (tEncodeI32(&encoder, sqlLen) < 0) return -1; - if (tEncodeI32(&encoder, astLen) < 0) return -1; - if (sqlLen > 0 && tEncodeCStr(&encoder, pReq->sql) < 0) return -1; - if (astLen > 0 && tEncodeCStr(&encoder, pReq->ast) < 0) return -1; + if (TOPIC_SUB_TYPE__DB == pReq->subType) { + if (tEncodeCStr(&encoder, pReq->subDbName) < 0) return -1; + } else if (TOPIC_SUB_TYPE__TABLE == pReq->subType) { + if (tEncodeCStr(&encoder, pReq->subStbName) < 0) return -1; + } else { + if (tEncodeI32(&encoder, strlen(pReq->ast)) < 0) return -1; + if (tEncodeCStr(&encoder, pReq->ast) < 0) return -1; + } + if (tEncodeI32(&encoder, strlen(pReq->sql)) < 0) return -1; + if (tEncodeCStr(&encoder, pReq->sql) < 0) return -1; tEndEncode(&encoder); @@ -2705,30 +2701,26 @@ int32_t tDeserializeSCMCreateTopicReq(void *buf, int32_t bufLen, SCMCreateTopicR if (tStartDecode(&decoder) < 0) return -1; if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1; if (tDecodeI8(&decoder, &pReq->igExists) < 0) return -1; - /*if (tDecodeI8(&decoder, &pReq->withTbName) < 0) return -1;*/ - /*if (tDecodeI8(&decoder, &pReq->withSchema) < 0) return -1;*/ - /*if (tDecodeI8(&decoder, &pReq->withTag) < 0) return -1;*/ if (tDecodeI8(&decoder, &pReq->subType) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->subDbName) < 0) return -1; - /*if (pReq->subType == TOPIC_SUB_TYPE__TABLE) {*/ - /*if (tDecodeCStrTo(&decoder, pReq->subStbName) < 0) return -1;*/ - /*}*/ + if (TOPIC_SUB_TYPE__DB == pReq->subType) { + if (tDecodeCStrTo(&decoder, pReq->subDbName) < 0) return -1; + } else if (TOPIC_SUB_TYPE__TABLE == pReq->subType) { + if (tDecodeCStrTo(&decoder, pReq->subStbName) < 0) return -1; + } else { + if (tDecodeI32(&decoder, &astLen) < 0) return -1; + if (astLen > 0) { + pReq->ast = taosMemoryCalloc(1, astLen + 1); + if (pReq->ast == NULL) return -1; + if (tDecodeCStrTo(&decoder, pReq->ast) < 0) return -1; + } + } if (tDecodeI32(&decoder, &sqlLen) < 0) return -1; - if (tDecodeI32(&decoder, &astLen) < 0) return -1; - if (sqlLen > 0) { pReq->sql = taosMemoryCalloc(1, sqlLen + 1); if (pReq->sql == NULL) return -1; if (tDecodeCStrTo(&decoder, pReq->sql) < 0) return -1; } - if (astLen > 0) { - pReq->ast = taosMemoryCalloc(1, astLen + 1); - if (pReq->ast == NULL) return -1; - if (tDecodeCStrTo(&decoder, pReq->ast) < 0) return -1; - } else { - } - tEndDecode(&decoder); tDecoderClear(&decoder); @@ -2737,7 +2729,9 @@ int32_t tDeserializeSCMCreateTopicReq(void *buf, int32_t bufLen, SCMCreateTopicR void tFreeSCMCreateTopicReq(SCMCreateTopicReq *pReq) { taosMemoryFreeClear(pReq->sql); - taosMemoryFreeClear(pReq->ast); + if (TOPIC_SUB_TYPE__COLUMN == pReq->subType) { + taosMemoryFreeClear(pReq->ast); + } } int32_t tSerializeSCMCreateTopicRsp(void *buf, int32_t bufLen, const SCMCreateTopicRsp *pRsp) { diff --git a/source/libs/nodes/src/nodesCodeFuncs.c b/source/libs/nodes/src/nodesCodeFuncs.c index 8887b9841a..b188f96126 100644 --- a/source/libs/nodes/src/nodesCodeFuncs.c +++ b/source/libs/nodes/src/nodesCodeFuncs.c @@ -2534,7 +2534,7 @@ static const char* jkSessionWindowTsPrimaryKey = "TsPrimaryKey"; static const char* jkSessionWindowGap = "Gap"; static int32_t sessionWindowNodeToJson(const void* pObj, SJson* pJson) { - const SSessionWindowNode * pNode = (const SSessionWindowNode*)pObj; + const SSessionWindowNode* pNode = (const SSessionWindowNode*)pObj; int32_t code = tjsonAddObject(pJson, jkSessionWindowTsPrimaryKey, nodeToJson, pNode->pCol); if (TSDB_CODE_SUCCESS == code) { @@ -2546,9 +2546,9 @@ static int32_t sessionWindowNodeToJson(const void* pObj, SJson* pJson) { static int32_t jsonToSessionWindowNode(const SJson* pJson, void* pObj) { SSessionWindowNode* pNode = (SSessionWindowNode*)pObj; - int32_t code = jsonToNodeObject(pJson, jkSessionWindowTsPrimaryKey, (SNode **)&pNode->pCol); + int32_t code = jsonToNodeObject(pJson, jkSessionWindowTsPrimaryKey, (SNode**)&pNode->pCol); if (TSDB_CODE_SUCCESS == code) { - code = jsonToNodeObject(pJson, jkSessionWindowGap, (SNode **)&pNode->pGap); + code = jsonToNodeObject(pJson, jkSessionWindowGap, (SNode**)&pNode->pGap); } return code; } @@ -2987,7 +2987,7 @@ static int32_t createTopicStmtToJson(const void* pObj, SJson* pJson) { int32_t code = tjsonAddStringToObject(pJson, jkCreateTopicStmtTopicName, pNode->topicName); if (TSDB_CODE_SUCCESS == code) { - code = tjsonAddStringToObject(pJson, jkCreateTopicStmtSubscribeDbName, pNode->subscribeDbName); + code = tjsonAddStringToObject(pJson, jkCreateTopicStmtSubscribeDbName, pNode->subDbName); } if (TSDB_CODE_SUCCESS == code) { code = tjsonAddBoolToObject(pJson, jkCreateTopicStmtIgnoreExists, pNode->ignoreExists); @@ -3004,7 +3004,7 @@ static int32_t jsonToCreateTopicStmt(const SJson* pJson, void* pObj) { int32_t code = tjsonGetStringValue(pJson, jkCreateTopicStmtTopicName, pNode->topicName); if (TSDB_CODE_SUCCESS == code) { - code = tjsonGetStringValue(pJson, jkCreateTopicStmtSubscribeDbName, pNode->subscribeDbName); + code = tjsonGetStringValue(pJson, jkCreateTopicStmtSubscribeDbName, pNode->subDbName); } if (TSDB_CODE_SUCCESS == code) { code = tjsonGetBoolValue(pJson, jkCreateTopicStmtIgnoreExists, &pNode->ignoreExists); diff --git a/source/libs/nodes/src/nodesUtilFuncs.c b/source/libs/nodes/src/nodesUtilFuncs.c index e28844f2e1..d29e89d266 100644 --- a/source/libs/nodes/src/nodesUtilFuncs.c +++ b/source/libs/nodes/src/nodesUtilFuncs.c @@ -86,8 +86,6 @@ SNodeptr nodesMakeNode(ENodeType type) { return makeNode(type, sizeof(SExplainOptions)); case QUERY_NODE_STREAM_OPTIONS: return makeNode(type, sizeof(SStreamOptions)); - case QUERY_NODE_TOPIC_OPTIONS: - return makeNode(type, sizeof(STopicOptions)); case QUERY_NODE_LEFT_VALUE: return makeNode(type, sizeof(SLeftValueNode)); case QUERY_NODE_SET_OPERATOR: diff --git a/source/libs/parser/inc/parAst.h b/source/libs/parser/inc/parAst.h index a1c304118b..70fb1a82ef 100644 --- a/source/libs/parser/inc/parAst.h +++ b/source/libs/parser/inc/parAst.h @@ -168,7 +168,7 @@ SNode* createCreateComponentNodeStmt(SAstCreateContext* pCxt, ENodeType type, co SNode* createDropComponentNodeStmt(SAstCreateContext* pCxt, ENodeType type, const SToken* pDnodeId); SNode* createTopicOptions(SAstCreateContext* pCxt); SNode* createCreateTopicStmt(SAstCreateContext* pCxt, bool ignoreExists, const SToken* pTopicName, SNode* pQuery, - const SToken* pSubscribeDbName, SNode* pOptions); + const SToken* pSubDbName, SNode* pRealTable); SNode* createDropTopicStmt(SAstCreateContext* pCxt, bool ignoreNotExists, const SToken* pTopicName); SNode* createDropCGroupStmt(SAstCreateContext* pCxt, bool ignoreNotExists, const SToken* pCGroupId, const SToken* pTopicName); diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y index 1fb60f83a5..61c9d00ae1 100644 --- a/source/libs/parser/inc/sql.y +++ b/source/libs/parser/inc/sql.y @@ -403,18 +403,13 @@ func_list(A) ::= func_list(B) NK_COMMA func(C). func(A) ::= function_name(B) NK_LP expression_list(C) NK_RP. { A = createFunctionNode(pCxt, &B, C); } /************************************************ create/drop topic ***************************************************/ -cmd ::= CREATE TOPIC not_exists_opt(A) - topic_name(B) topic_options(D) AS query_expression(C). { pCxt->pRootNode = createCreateTopicStmt(pCxt, A, &B, C, NULL, D); } -cmd ::= CREATE TOPIC not_exists_opt(A) - topic_name(B) topic_options(D) AS db_name(C). { pCxt->pRootNode = createCreateTopicStmt(pCxt, A, &B, NULL, &C, D); } +cmd ::= CREATE TOPIC not_exists_opt(A) topic_name(B) AS query_expression(C). { pCxt->pRootNode = createCreateTopicStmt(pCxt, A, &B, C, NULL, NULL); } +cmd ::= CREATE TOPIC not_exists_opt(A) topic_name(B) AS DATABASE db_name(C). { pCxt->pRootNode = createCreateTopicStmt(pCxt, A, &B, NULL, &C, NULL); } +cmd ::= CREATE TOPIC not_exists_opt(A) topic_name(B) + AS STABLE full_table_name(C). { pCxt->pRootNode = createCreateTopicStmt(pCxt, A, &B, NULL, NULL, C); } cmd ::= DROP TOPIC exists_opt(A) topic_name(B). { pCxt->pRootNode = createDropTopicStmt(pCxt, A, &B); } cmd ::= DROP CGROUP exists_opt(A) cgroup_name(B) ON topic_name(C). { pCxt->pRootNode = createDropCGroupStmt(pCxt, A, &B, &C); } -topic_options(A) ::= . { A = createTopicOptions(pCxt); } -topic_options(A) ::= topic_options(B) WITH TABLE. { ((STopicOptions*)B)->withTable = true; A = B; } -topic_options(A) ::= topic_options(B) WITH SCHEMA. { ((STopicOptions*)B)->withSchema = true; A = B; } -topic_options(A) ::= topic_options(B) WITH TAG. { ((STopicOptions*)B)->withTag = true; A = B; } - /************************************************ desc/describe *******************************************************/ cmd ::= DESC full_table_name(A). { pCxt->pRootNode = createDescribeStmt(pCxt, A); } cmd ::= DESCRIBE full_table_name(A). { pCxt->pRootNode = createDescribeStmt(pCxt, A); } diff --git a/source/libs/parser/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c index 6b4c5f0ce5..dc8c54ac78 100644 --- a/source/libs/parser/src/parAstCreater.c +++ b/source/libs/parser/src/parAstCreater.c @@ -1265,28 +1265,22 @@ SNode* createDropComponentNodeStmt(SAstCreateContext* pCxt, ENodeType type, cons return (SNode*)pStmt; } -SNode* createTopicOptions(SAstCreateContext* pCxt) { - CHECK_PARSER_STATUS(pCxt); - STopicOptions* pOptions = nodesMakeNode(QUERY_NODE_TOPIC_OPTIONS); - CHECK_OUT_OF_MEM(pOptions); - pOptions->withTable = false; - pOptions->withSchema = false; - pOptions->withTag = false; - return (SNode*)pOptions; -} - SNode* createCreateTopicStmt(SAstCreateContext* pCxt, bool ignoreExists, const SToken* pTopicName, SNode* pQuery, - const SToken* pSubscribeDbName, SNode* pOptions) { + const SToken* pSubDbName, SNode* pRealTable) { CHECK_PARSER_STATUS(pCxt); SCreateTopicStmt* pStmt = nodesMakeNode(QUERY_NODE_CREATE_TOPIC_STMT); CHECK_OUT_OF_MEM(pStmt); strncpy(pStmt->topicName, pTopicName->z, pTopicName->n); pStmt->ignoreExists = ignoreExists; - pStmt->pQuery = pQuery; - if (NULL != pSubscribeDbName) { - strncpy(pStmt->subscribeDbName, pSubscribeDbName->z, pSubscribeDbName->n); + if (NULL != pRealTable) { + strcpy(pStmt->subDbName, ((SRealTableNode*)pRealTable)->table.dbName); + strcpy(pStmt->subSTbName, ((SRealTableNode*)pRealTable)->table.tableName); + nodesDestroyNode(pRealTable); + } else if (NULL != pSubDbName) { + strncpy(pStmt->subDbName, pSubDbName->z, pSubDbName->n); + } else { + pStmt->pQuery = pQuery; } - pStmt->pOptions = (STopicOptions*)pOptions; return (SNode*)pStmt; } diff --git a/source/libs/parser/src/parTokenizer.c b/source/libs/parser/src/parTokenizer.c index 540de2d639..b6f9ba138d 100644 --- a/source/libs/parser/src/parTokenizer.c +++ b/source/libs/parser/src/parTokenizer.c @@ -156,7 +156,6 @@ static SKeyword keywordTable[] = { {"RETENTIONS", TK_RETENTIONS}, {"REVOKE", TK_REVOKE}, {"ROLLUP", TK_ROLLUP}, - {"SCHEMA", TK_SCHEMA}, {"SCHEMALESS", TK_SCHEMALESS}, {"SCORES", TK_SCORES}, {"SELECT", TK_SELECT}, @@ -214,7 +213,6 @@ static SKeyword keywordTable[] = { {"WATERMARK", TK_WATERMARK}, {"WHERE", TK_WHERE}, {"WINDOW_CLOSE", TK_WINDOW_CLOSE}, - {"WITH", TK_WITH}, {"WRITE", TK_WRITE}, {"_C0", TK_ROWTS}, {"_QENDTS", TK_QENDTS}, diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index 467df44b7c..bca1cfbecb 100644 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -3239,9 +3239,6 @@ static int32_t buildCreateTopicReq(STranslateContext* pCxt, SCreateTopicStmt* pS tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->topicName, strlen(pStmt->topicName)); tNameGetFullDbName(&name, pReq->name); pReq->igExists = pStmt->ignoreExists; - /*pReq->withTbName = pStmt->pOptions->withTable;*/ - /*pReq->withSchema = pStmt->pOptions->withSchema;*/ - /*pReq->withTag = pStmt->pOptions->withTag;*/ pReq->sql = strdup(pCxt->pParseCxt->pSql); if (NULL == pReq->sql) { @@ -3250,19 +3247,22 @@ static int32_t buildCreateTopicReq(STranslateContext* pCxt, SCreateTopicStmt* pS int32_t code = TSDB_CODE_SUCCESS; - const char* dbName; - if (NULL != pStmt->pQuery) { - dbName = ((SRealTableNode*)(((SSelectStmt*)pStmt->pQuery)->pFromTable))->table.dbName; + if ('\0' != pStmt->subSTbName[0]) { + pReq->subType = TOPIC_SUB_TYPE__TABLE; + toName(pCxt->pParseCxt->acctId, pStmt->subDbName, pStmt->subSTbName, &name); + tNameExtractFullName(&name, pReq->subStbName); + } else if ('\0' != pStmt->subDbName[0]) { + pReq->subType = TOPIC_SUB_TYPE__DB; + tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->subDbName, strlen(pStmt->subDbName)); + tNameGetFullDbName(&name, pReq->subDbName); + } else { + pReq->subType = TOPIC_SUB_TYPE__COLUMN; pCxt->pParseCxt->topicQuery = true; code = translateQuery(pCxt, pStmt->pQuery); if (TSDB_CODE_SUCCESS == code) { code = nodesNodeToString(pStmt->pQuery, false, &pReq->ast, NULL); } - } else { - dbName = pStmt->subscribeDbName; } - tNameSetDbName(&name, pCxt->pParseCxt->acctId, dbName, strlen(dbName)); - tNameGetFullDbName(&name, pReq->subDbName); return code; } diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c index 262abac54b..76e461f2b8 100644 --- a/source/libs/parser/src/sql.c +++ b/source/libs/parser/src/sql.c @@ -100,25 +100,25 @@ #endif /************* Begin control #defines *****************************************/ #define YYCODETYPE unsigned short int -#define YYNOCODE 361 +#define YYNOCODE 358 #define YYACTIONTYPE unsigned short int #define ParseTOKENTYPE SToken typedef union { int yyinit; ParseTOKENTYPE yy0; - EFillMode yy18; - SAlterOption yy25; - SToken yy53; - EOperatorType yy136; - int32_t yy158; - ENullOrder yy185; - SNodeList* yy236; - EJoinType yy342; - EOrder yy430; - int64_t yy435; - SDataType yy450; - bool yy603; - SNode* yy636; + EOrder yy14; + ENullOrder yy17; + SNodeList* yy60; + SToken yy105; + int32_t yy140; + SNode* yy172; + EFillMode yy202; + SDataType yy248; + EOperatorType yy572; + int64_t yy593; + SAlterOption yy609; + bool yy617; + EJoinType yy636; } YYMINORTYPE; #ifndef YYSTACKDEPTH #define YYSTACKDEPTH 100 @@ -134,17 +134,17 @@ typedef union { #define ParseCTX_FETCH #define ParseCTX_STORE #define YYFALLBACK 1 -#define YYNSTATE 611 -#define YYNRULE 455 -#define YYNTOKEN 240 -#define YY_MAX_SHIFT 610 -#define YY_MIN_SHIFTREDUCE 901 -#define YY_MAX_SHIFTREDUCE 1355 -#define YY_ERROR_ACTION 1356 -#define YY_ACCEPT_ACTION 1357 -#define YY_NO_ACTION 1358 -#define YY_MIN_REDUCE 1359 -#define YY_MAX_REDUCE 1813 +#define YYNSTATE 612 +#define YYNRULE 452 +#define YYNTOKEN 238 +#define YY_MAX_SHIFT 611 +#define YY_MIN_SHIFTREDUCE 899 +#define YY_MAX_SHIFTREDUCE 1350 +#define YY_ERROR_ACTION 1351 +#define YY_ACCEPT_ACTION 1352 +#define YY_NO_ACTION 1353 +#define YY_MIN_REDUCE 1354 +#define YY_MAX_REDUCE 1805 /************* End control #defines *******************************************/ #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) @@ -211,604 +211,616 @@ typedef union { ** yy_default[] Default action for each state. ** *********** Begin parsing tables **********************************************/ -#define YY_ACTTAB_COUNT (2153) +#define YY_ACTTAB_COUNT (2214) static const YYACTIONTYPE yy_action[] = { - /* 0 */ 386, 1647, 387, 1391, 295, 394, 524, 387, 1391, 28, - /* 10 */ 226, 931, 35, 33, 130, 1676, 1371, 1660, 104, 1791, - /* 20 */ 304, 1644, 1169, 477, 523, 424, 36, 34, 32, 31, - /* 30 */ 30, 385, 1790, 62, 389, 1490, 1788, 1640, 1646, 36, - /* 40 */ 34, 32, 31, 30, 1535, 1676, 108, 1167, 527, 935, - /* 50 */ 936, 294, 1000, 508, 524, 1485, 1533, 154, 14, 476, - /* 60 */ 35, 33, 1296, 507, 1175, 24, 350, 1630, 304, 1002, - /* 70 */ 1169, 1418, 277, 488, 523, 36, 34, 32, 31, 30, - /* 80 */ 56, 1, 60, 1490, 1689, 59, 524, 80, 1661, 510, - /* 90 */ 1663, 1664, 506, 1359, 527, 1167, 1207, 1729, 104, 603, - /* 100 */ 602, 276, 1725, 607, 1258, 429, 14, 36, 34, 32, - /* 110 */ 31, 30, 1175, 1791, 1168, 1490, 140, 103, 102, 101, - /* 120 */ 100, 99, 98, 97, 96, 95, 147, 376, 1529, 2, - /* 130 */ 1788, 583, 582, 581, 319, 39, 580, 579, 578, 114, - /* 140 */ 573, 572, 571, 570, 569, 568, 567, 566, 121, 562, - /* 150 */ 511, 607, 1568, 307, 1259, 55, 1580, 55, 1170, 156, - /* 160 */ 94, 1791, 1168, 93, 92, 91, 90, 89, 88, 87, - /* 170 */ 86, 85, 158, 157, 146, 352, 1264, 1352, 1788, 393, - /* 180 */ 1173, 1174, 389, 1220, 1221, 1223, 1224, 1225, 1226, 1227, - /* 190 */ 503, 525, 1235, 1236, 1237, 1238, 1239, 1240, 1468, 36, - /* 200 */ 34, 32, 31, 30, 64, 292, 1170, 131, 191, 274, - /* 210 */ 148, 1447, 27, 302, 1253, 1254, 1255, 1256, 1257, 1261, - /* 220 */ 1262, 1263, 1421, 36, 34, 32, 31, 30, 1173, 1174, - /* 230 */ 484, 1220, 1221, 1223, 1224, 1225, 1226, 1227, 503, 525, - /* 240 */ 1235, 1236, 1237, 1238, 1239, 1240, 35, 33, 1467, 948, - /* 250 */ 70, 947, 438, 437, 304, 403, 1169, 436, 1351, 112, - /* 260 */ 109, 433, 308, 1791, 432, 431, 430, 35, 33, 1310, - /* 270 */ 128, 1483, 1660, 403, 523, 304, 1789, 1169, 949, 1492, - /* 280 */ 1788, 1167, 438, 437, 148, 1193, 148, 436, 62, 972, - /* 290 */ 109, 433, 14, 1207, 432, 431, 430, 110, 1175, 1360, - /* 300 */ 1676, 1303, 1167, 1382, 1660, 524, 973, 1193, 508, 524, - /* 310 */ 1486, 486, 142, 1736, 1737, 2, 1741, 351, 507, 1175, - /* 320 */ 94, 361, 1630, 93, 92, 91, 90, 89, 88, 87, - /* 330 */ 86, 85, 1676, 1381, 1490, 38, 8, 607, 1490, 1689, - /* 340 */ 487, 559, 82, 1661, 510, 1663, 1664, 506, 1168, 527, - /* 350 */ 507, 1191, 1729, 1630, 1630, 1535, 1728, 1725, 607, 128, - /* 360 */ 558, 557, 309, 556, 555, 554, 1380, 1533, 1493, 1168, - /* 370 */ 565, 1689, 1462, 1535, 81, 1661, 510, 1663, 1664, 506, - /* 380 */ 315, 527, 524, 1630, 1729, 1533, 1743, 26, 297, 1725, - /* 390 */ 141, 478, 1170, 54, 362, 435, 434, 36, 34, 32, - /* 400 */ 31, 30, 218, 36, 34, 32, 31, 30, 466, 1756, - /* 410 */ 1740, 1490, 55, 1170, 1173, 1174, 1630, 1220, 1221, 1223, - /* 420 */ 1224, 1225, 1226, 1227, 503, 525, 1235, 1236, 1237, 1238, - /* 430 */ 1239, 1240, 460, 577, 575, 1173, 1174, 1379, 1220, 1221, - /* 440 */ 1223, 1224, 1225, 1226, 1227, 503, 525, 1235, 1236, 1237, - /* 450 */ 1238, 1239, 1240, 35, 33, 1241, 1378, 443, 1195, 610, - /* 460 */ 316, 304, 1377, 1169, 148, 148, 249, 1571, 1573, 1520, - /* 470 */ 1246, 1222, 451, 243, 35, 33, 1193, 1481, 1376, 1660, - /* 480 */ 1647, 461, 304, 312, 1169, 105, 190, 1630, 1167, 524, - /* 490 */ 473, 599, 595, 591, 587, 242, 391, 1644, 446, 1357, - /* 500 */ 1644, 402, 1191, 440, 561, 1175, 1630, 1676, 189, 1167, - /* 510 */ 337, 484, 1630, 1640, 1646, 508, 1640, 1646, 1490, 484, - /* 520 */ 78, 1791, 9, 237, 527, 507, 1175, 527, 1630, 1630, - /* 530 */ 339, 335, 564, 51, 145, 488, 50, 127, 1788, 511, - /* 540 */ 112, 148, 576, 9, 607, 1581, 1689, 1194, 112, 80, - /* 550 */ 1661, 510, 1663, 1664, 506, 1168, 527, 520, 320, 1729, - /* 560 */ 1375, 479, 474, 276, 1725, 607, 36, 34, 32, 31, - /* 570 */ 30, 1648, 1130, 314, 1479, 1791, 1168, 428, 110, 553, - /* 580 */ 1132, 128, 465, 340, 217, 198, 110, 1465, 145, 55, - /* 590 */ 1492, 1644, 1788, 143, 1736, 1737, 77, 1741, 1791, 1170, - /* 600 */ 427, 144, 1736, 1737, 1146, 1741, 193, 1640, 1646, 113, - /* 610 */ 1630, 145, 277, 1572, 1573, 1788, 490, 1482, 527, 1295, - /* 620 */ 1170, 1173, 1174, 1374, 1220, 1221, 1223, 1224, 1225, 1226, - /* 630 */ 1227, 503, 525, 1235, 1236, 1237, 1238, 1239, 1240, 286, - /* 640 */ 1222, 1131, 1173, 1174, 1258, 1220, 1221, 1223, 1224, 1225, - /* 650 */ 1226, 1227, 503, 525, 1235, 1236, 1237, 1238, 1239, 1240, - /* 660 */ 35, 33, 273, 559, 1191, 345, 1320, 344, 304, 524, - /* 670 */ 1169, 369, 524, 1630, 381, 32, 31, 30, 1748, 1291, - /* 680 */ 559, 1487, 558, 557, 1610, 556, 555, 554, 287, 7, - /* 690 */ 285, 284, 382, 426, 1259, 1167, 947, 428, 1490, 558, - /* 700 */ 557, 1490, 556, 555, 554, 470, 1318, 1319, 1321, 1322, - /* 710 */ 1535, 317, 1175, 11, 10, 1373, 1264, 1743, 148, 128, - /* 720 */ 427, 422, 1534, 935, 936, 1743, 1154, 1155, 1492, 2, - /* 730 */ 1038, 550, 549, 548, 1042, 547, 1044, 1045, 546, 1047, - /* 740 */ 543, 1739, 1053, 540, 1055, 1056, 537, 534, 346, 1738, - /* 750 */ 1370, 607, 27, 302, 1253, 1254, 1255, 1256, 1257, 1261, - /* 760 */ 1262, 1263, 1168, 380, 1466, 1630, 375, 374, 373, 372, - /* 770 */ 371, 368, 367, 366, 365, 364, 360, 359, 358, 357, - /* 780 */ 356, 355, 354, 353, 524, 524, 129, 524, 1791, 1196, - /* 790 */ 492, 255, 1192, 1193, 1272, 1260, 521, 522, 1475, 239, - /* 800 */ 1630, 145, 1369, 253, 53, 1788, 1170, 52, 1368, 1367, - /* 810 */ 1366, 452, 1365, 1490, 1490, 1364, 1490, 1265, 524, 1363, - /* 820 */ 1660, 561, 1362, 47, 159, 275, 1294, 1477, 1173, 1174, - /* 830 */ 318, 1220, 1221, 1223, 1224, 1225, 1226, 1227, 503, 525, - /* 840 */ 1235, 1236, 1237, 1238, 1239, 1240, 495, 1490, 1676, 55, - /* 850 */ 1473, 1791, 1630, 25, 1619, 194, 487, 1408, 1630, 1630, - /* 860 */ 1630, 1291, 1630, 1403, 145, 1630, 507, 1401, 1788, 1630, - /* 870 */ 1630, 182, 1630, 184, 180, 186, 183, 188, 185, 439, - /* 880 */ 187, 1660, 500, 450, 502, 441, 79, 1689, 76, 444, - /* 890 */ 81, 1661, 510, 1663, 1664, 506, 448, 527, 72, 327, - /* 900 */ 1729, 11, 10, 552, 297, 1725, 141, 1372, 459, 1676, - /* 910 */ 1354, 1355, 1650, 1448, 1660, 202, 1178, 508, 58, 57, - /* 920 */ 349, 118, 46, 153, 471, 1757, 1177, 507, 343, 205, - /* 930 */ 221, 1630, 37, 37, 37, 453, 212, 1677, 1392, 228, - /* 940 */ 272, 421, 1676, 333, 1530, 329, 325, 150, 1689, 1652, - /* 950 */ 508, 81, 1661, 510, 1663, 1664, 506, 1222, 527, 1759, - /* 960 */ 507, 1729, 462, 1317, 1630, 297, 1725, 1804, 1191, 116, - /* 970 */ 207, 117, 485, 1266, 1228, 1124, 1763, 493, 148, 1660, - /* 980 */ 230, 1689, 220, 1181, 81, 1661, 510, 1663, 1664, 506, - /* 990 */ 223, 527, 118, 1180, 1729, 1660, 46, 532, 297, 1725, - /* 1000 */ 1804, 322, 117, 225, 1250, 3, 118, 1676, 326, 1786, - /* 1010 */ 516, 282, 236, 1000, 283, 508, 119, 117, 244, 155, - /* 1020 */ 1138, 363, 370, 1676, 1570, 507, 378, 1660, 377, 1630, - /* 1030 */ 379, 508, 383, 1031, 1197, 496, 384, 248, 1059, 392, - /* 1040 */ 1200, 507, 395, 1063, 162, 1630, 1689, 1070, 396, 82, - /* 1050 */ 1661, 510, 1663, 1664, 506, 1676, 527, 1068, 120, 1729, - /* 1060 */ 1199, 164, 1689, 508, 1726, 81, 1661, 510, 1663, 1664, - /* 1070 */ 506, 1201, 527, 507, 397, 1729, 398, 1630, 1660, 297, - /* 1080 */ 1725, 1804, 167, 488, 399, 169, 1198, 400, 401, 172, - /* 1090 */ 1747, 61, 404, 1660, 1689, 175, 423, 262, 1661, 510, - /* 1100 */ 1663, 1664, 506, 425, 527, 84, 1676, 1175, 1480, 179, - /* 1110 */ 1476, 291, 181, 1614, 508, 122, 123, 1478, 1474, 124, - /* 1120 */ 125, 1676, 245, 1791, 507, 192, 455, 195, 1630, 508, - /* 1130 */ 246, 197, 454, 464, 488, 463, 147, 200, 1196, 507, - /* 1140 */ 1788, 458, 472, 1630, 1660, 1689, 1770, 203, 262, 1661, - /* 1150 */ 510, 1663, 1664, 506, 514, 527, 6, 1750, 469, 1769, - /* 1160 */ 1689, 211, 481, 82, 1661, 510, 1663, 1664, 506, 206, - /* 1170 */ 527, 1760, 1676, 1729, 1791, 296, 475, 499, 1725, 1195, - /* 1180 */ 505, 468, 5, 1291, 111, 40, 497, 145, 1744, 1807, - /* 1190 */ 507, 1788, 298, 18, 1630, 512, 1660, 513, 494, 306, - /* 1200 */ 311, 310, 1579, 135, 1578, 1660, 214, 517, 518, 519, - /* 1210 */ 1183, 1689, 213, 1787, 270, 1661, 510, 1663, 1664, 506, - /* 1220 */ 504, 527, 501, 1701, 1676, 219, 232, 71, 491, 1710, - /* 1230 */ 234, 247, 508, 1676, 69, 1176, 250, 1491, 241, 222, - /* 1240 */ 606, 508, 507, 1463, 498, 48, 1630, 530, 224, 256, - /* 1250 */ 134, 507, 1175, 1660, 263, 1630, 257, 293, 467, 252, - /* 1260 */ 254, 1624, 1623, 1689, 321, 1620, 132, 1661, 510, 1663, - /* 1270 */ 1664, 506, 1689, 527, 323, 271, 1661, 510, 1663, 1664, - /* 1280 */ 506, 1676, 527, 324, 1163, 1660, 1164, 151, 1618, 508, - /* 1290 */ 328, 528, 330, 331, 1617, 332, 334, 1616, 336, 507, - /* 1300 */ 1615, 338, 1179, 1630, 1600, 152, 341, 1141, 342, 1140, - /* 1310 */ 489, 1805, 1594, 1676, 1593, 347, 348, 1660, 1592, 1591, - /* 1320 */ 1689, 508, 1107, 266, 1661, 510, 1663, 1664, 506, 1563, - /* 1330 */ 527, 507, 1562, 1561, 1560, 1630, 1559, 1558, 1557, 1556, - /* 1340 */ 1555, 1554, 1553, 1552, 1551, 1676, 1184, 1550, 1549, 1548, - /* 1350 */ 1547, 1546, 1689, 508, 1545, 132, 1661, 510, 1663, 1664, - /* 1360 */ 506, 480, 527, 507, 115, 1660, 1544, 1630, 1187, 1543, - /* 1370 */ 301, 1542, 1541, 1540, 1109, 1539, 1538, 1537, 1660, 525, - /* 1380 */ 1235, 1236, 1536, 1420, 1689, 1388, 160, 271, 1661, 510, - /* 1390 */ 1663, 1664, 506, 1676, 527, 938, 106, 138, 937, 388, - /* 1400 */ 1806, 505, 1387, 161, 390, 107, 1676, 1608, 1602, 1586, - /* 1410 */ 1585, 507, 1576, 1469, 508, 1630, 166, 171, 1660, 1419, - /* 1420 */ 966, 1417, 1415, 407, 507, 405, 1413, 411, 1630, 415, - /* 1430 */ 1411, 303, 1689, 419, 406, 270, 1661, 510, 1663, 1664, - /* 1440 */ 506, 409, 527, 410, 1702, 1689, 1676, 413, 271, 1661, - /* 1450 */ 510, 1663, 1664, 506, 508, 527, 414, 1400, 177, 1399, - /* 1460 */ 418, 417, 1386, 1471, 507, 1074, 1660, 1470, 1630, 1073, - /* 1470 */ 139, 305, 574, 576, 999, 1169, 420, 416, 412, 408, - /* 1480 */ 176, 45, 998, 178, 997, 1689, 996, 993, 271, 1661, - /* 1490 */ 510, 1663, 1664, 506, 1676, 527, 992, 991, 1409, 288, - /* 1500 */ 1167, 1404, 508, 289, 442, 63, 1402, 290, 174, 1385, - /* 1510 */ 447, 445, 507, 1384, 449, 83, 1630, 1175, 1607, 1148, - /* 1520 */ 49, 1601, 456, 1660, 1584, 126, 1583, 1575, 199, 65, - /* 1530 */ 196, 4, 133, 1689, 201, 37, 258, 1661, 510, 1663, - /* 1540 */ 1664, 506, 204, 527, 15, 457, 43, 1316, 1309, 208, - /* 1550 */ 22, 1676, 209, 23, 210, 66, 607, 1288, 1650, 508, - /* 1560 */ 1287, 216, 1345, 42, 136, 41, 173, 1168, 165, 507, - /* 1570 */ 170, 1660, 168, 1630, 17, 1340, 1339, 16, 13, 1334, - /* 1580 */ 10, 299, 1344, 1343, 300, 1251, 19, 137, 149, 1230, - /* 1590 */ 1689, 163, 1215, 265, 1661, 510, 1663, 1664, 506, 1676, - /* 1600 */ 527, 1660, 509, 1574, 29, 515, 12, 508, 1649, 233, - /* 1610 */ 72, 1170, 1229, 20, 235, 1185, 531, 507, 238, 21, - /* 1620 */ 229, 1630, 227, 529, 1314, 964, 313, 231, 67, 1676, - /* 1630 */ 68, 1660, 1692, 1173, 1174, 1232, 526, 508, 1689, 44, - /* 1640 */ 533, 267, 1661, 510, 1663, 1664, 506, 507, 527, 1060, - /* 1650 */ 1057, 1630, 535, 538, 536, 541, 544, 1054, 539, 1676, - /* 1660 */ 1037, 1052, 1048, 542, 1069, 1046, 545, 508, 1689, 551, - /* 1670 */ 1051, 259, 1661, 510, 1663, 1664, 506, 507, 527, 1660, - /* 1680 */ 73, 1630, 74, 75, 1066, 1065, 1050, 560, 1660, 1049, - /* 1690 */ 988, 1006, 563, 240, 986, 985, 984, 983, 1689, 981, - /* 1700 */ 1067, 268, 1661, 510, 1663, 1664, 506, 1676, 527, 982, - /* 1710 */ 1003, 980, 979, 1001, 976, 508, 1676, 975, 974, 971, - /* 1720 */ 970, 969, 1416, 584, 508, 507, 585, 586, 1414, 1630, - /* 1730 */ 588, 589, 590, 1412, 507, 592, 1660, 593, 1630, 594, - /* 1740 */ 1410, 596, 597, 598, 1398, 600, 1689, 601, 1397, 260, - /* 1750 */ 1661, 510, 1663, 1664, 506, 1689, 527, 1383, 269, 1661, - /* 1760 */ 510, 1663, 1664, 506, 1676, 527, 609, 604, 605, 1358, - /* 1770 */ 1358, 1171, 508, 251, 608, 1358, 1358, 1358, 1358, 1358, - /* 1780 */ 1358, 1358, 507, 1358, 1660, 1358, 1630, 1358, 1358, 1358, - /* 1790 */ 1358, 1358, 1358, 1358, 1358, 1660, 1358, 1358, 1358, 1358, - /* 1800 */ 1358, 1358, 1358, 1689, 1358, 1358, 261, 1661, 510, 1663, - /* 1810 */ 1664, 506, 1676, 527, 1660, 1358, 1358, 1358, 1358, 1358, - /* 1820 */ 508, 1358, 1358, 1676, 1358, 1358, 1358, 1358, 1358, 1358, - /* 1830 */ 507, 508, 1358, 1358, 1630, 1358, 1358, 1358, 1358, 1358, - /* 1840 */ 1358, 507, 1676, 1358, 1358, 1630, 1358, 1358, 1358, 1358, - /* 1850 */ 508, 1689, 1358, 1358, 1672, 1661, 510, 1663, 1664, 506, - /* 1860 */ 507, 527, 1689, 1358, 1630, 1671, 1661, 510, 1663, 1664, - /* 1870 */ 506, 1358, 527, 1660, 1358, 1358, 1358, 1358, 1358, 1358, - /* 1880 */ 1358, 1689, 1660, 1358, 1670, 1661, 510, 1663, 1664, 506, - /* 1890 */ 1358, 527, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, - /* 1900 */ 1358, 1676, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 508, - /* 1910 */ 1676, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 508, 507, - /* 1920 */ 1358, 1358, 1358, 1630, 1358, 1358, 1358, 1358, 507, 1358, - /* 1930 */ 1358, 1358, 1630, 1358, 1358, 1358, 1358, 1358, 1358, 1358, - /* 1940 */ 1689, 1358, 1660, 280, 1661, 510, 1663, 1664, 506, 1689, - /* 1950 */ 527, 1660, 279, 1661, 510, 1663, 1664, 506, 1358, 527, - /* 1960 */ 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, - /* 1970 */ 1676, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 508, 1676, - /* 1980 */ 1358, 1358, 1358, 1358, 1358, 1358, 1358, 508, 507, 1358, - /* 1990 */ 1358, 1358, 1630, 1358, 1358, 1358, 1358, 507, 1358, 1660, - /* 2000 */ 1358, 1630, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1689, - /* 2010 */ 484, 1358, 281, 1661, 510, 1663, 1664, 506, 1689, 527, - /* 2020 */ 1358, 278, 1661, 510, 1663, 1664, 506, 1676, 527, 1358, - /* 2030 */ 1358, 1358, 1358, 1358, 1358, 508, 1358, 1358, 1358, 112, - /* 2040 */ 1358, 1358, 1358, 1358, 1358, 507, 484, 1358, 1358, 1630, - /* 2050 */ 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 488, - /* 2060 */ 1358, 1358, 1358, 1358, 1358, 1358, 1689, 1358, 1358, 264, - /* 2070 */ 1661, 510, 1663, 1664, 506, 112, 527, 110, 1358, 1358, - /* 2080 */ 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, - /* 2090 */ 1358, 1358, 215, 1736, 483, 488, 482, 1358, 1358, 1791, - /* 2100 */ 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, - /* 2110 */ 1358, 1358, 147, 110, 1358, 1358, 1788, 1358, 1358, 1358, - /* 2120 */ 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 215, 1736, - /* 2130 */ 483, 1358, 482, 1358, 1358, 1791, 1358, 1358, 1358, 1358, - /* 2140 */ 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 145, 1358, - /* 2150 */ 1358, 1358, 1788, + /* 0 */ 132, 1783, 345, 1639, 1442, 1639, 294, 385, 311, 386, + /* 10 */ 1386, 78, 35, 33, 1782, 1474, 24, 1652, 1780, 131, + /* 20 */ 303, 1366, 1164, 1636, 114, 1636, 36, 34, 32, 31, + /* 30 */ 30, 393, 1477, 386, 1386, 1783, 1476, 1783, 1632, 1638, + /* 40 */ 1632, 1638, 1783, 524, 62, 1668, 929, 1162, 147, 528, + /* 50 */ 1781, 528, 1780, 488, 1780, 146, 1636, 109, 14, 1780, + /* 60 */ 35, 33, 1291, 508, 1170, 485, 1480, 1622, 303, 524, + /* 70 */ 1164, 1632, 1638, 1188, 36, 34, 32, 31, 30, 28, + /* 80 */ 228, 1, 528, 1681, 933, 934, 82, 1653, 511, 1655, + /* 90 */ 1656, 507, 402, 528, 113, 1162, 1721, 479, 1530, 1668, + /* 100 */ 296, 1717, 142, 608, 39, 293, 14, 478, 35, 33, + /* 110 */ 1528, 512, 1170, 489, 1163, 1377, 303, 1576, 1164, 461, + /* 120 */ 277, 1749, 36, 34, 32, 31, 30, 55, 56, 2, + /* 130 */ 95, 111, 485, 94, 93, 92, 91, 90, 89, 88, + /* 140 */ 87, 86, 477, 1162, 1202, 525, 217, 1728, 484, 55, + /* 150 */ 483, 608, 1253, 1783, 14, 384, 1165, 105, 388, 1783, + /* 160 */ 1170, 113, 1163, 351, 423, 1622, 148, 286, 277, 390, + /* 170 */ 1780, 451, 146, 1563, 1485, 1186, 1780, 2, 1168, 1169, + /* 180 */ 157, 1215, 1216, 1218, 1219, 1220, 1221, 1222, 504, 526, + /* 190 */ 1230, 1231, 1232, 1233, 1234, 1235, 1735, 275, 111, 608, + /* 200 */ 1253, 344, 1254, 343, 1165, 55, 392, 524, 149, 388, + /* 210 */ 1163, 1783, 487, 143, 1728, 1729, 287, 1733, 285, 284, + /* 220 */ 1732, 425, 1259, 198, 146, 427, 1168, 1169, 1780, 1215, + /* 230 */ 1216, 1218, 1219, 1220, 1221, 1222, 504, 526, 1230, 1231, + /* 240 */ 1232, 1233, 1234, 1235, 946, 141, 945, 1463, 426, 55, + /* 250 */ 1254, 65, 1165, 1376, 149, 1189, 1315, 1524, 27, 301, + /* 260 */ 1248, 1249, 1250, 1251, 1252, 1256, 1257, 1258, 38, 1187, + /* 270 */ 1259, 604, 603, 947, 1168, 1169, 149, 1215, 1216, 1218, + /* 280 */ 1219, 1220, 1221, 1222, 504, 526, 1230, 1231, 1232, 1233, + /* 290 */ 1234, 1235, 35, 33, 1354, 471, 1313, 1314, 1316, 1317, + /* 300 */ 303, 1190, 1164, 1622, 402, 155, 27, 301, 1248, 1249, + /* 310 */ 1250, 1251, 1252, 1256, 1257, 1258, 178, 525, 104, 103, + /* 320 */ 102, 101, 100, 99, 98, 97, 96, 1162, 140, 349, + /* 330 */ 60, 1652, 149, 59, 419, 415, 411, 407, 177, 1462, + /* 340 */ 35, 33, 1236, 307, 1170, 525, 1485, 562, 303, 554, + /* 350 */ 1164, 129, 36, 34, 32, 31, 30, 105, 26, 1668, + /* 360 */ 1487, 8, 496, 63, 428, 313, 175, 509, 36, 34, + /* 370 */ 32, 31, 30, 129, 1485, 1162, 149, 508, 315, 525, + /* 380 */ 1352, 1622, 1487, 608, 1375, 1566, 1568, 512, 35, 33, + /* 390 */ 306, 350, 1170, 1575, 1163, 149, 303, 1681, 1164, 375, + /* 400 */ 82, 1653, 511, 1655, 1656, 507, 525, 528, 1485, 9, + /* 410 */ 1721, 474, 316, 1298, 296, 1717, 1796, 485, 360, 1188, + /* 420 */ 129, 525, 1305, 1162, 174, 1755, 166, 219, 171, 1487, + /* 430 */ 169, 608, 560, 361, 1622, 1485, 1165, 566, 319, 1457, + /* 440 */ 1170, 1611, 1163, 1241, 159, 158, 113, 164, 525, 1188, + /* 450 */ 1485, 559, 558, 1374, 557, 556, 555, 9, 1168, 1169, + /* 460 */ 401, 1215, 1216, 1218, 1219, 1220, 1221, 1222, 504, 526, + /* 470 */ 1230, 1231, 1232, 1233, 1234, 1235, 336, 1485, 1783, 608, + /* 480 */ 480, 475, 1530, 111, 1165, 1373, 326, 130, 149, 308, + /* 490 */ 1163, 146, 256, 1470, 1528, 1780, 338, 334, 144, 1728, + /* 500 */ 1729, 945, 1733, 1622, 254, 53, 1168, 1169, 52, 1215, + /* 510 */ 1216, 1218, 1219, 1220, 1221, 1222, 504, 526, 1230, 1231, + /* 520 */ 1232, 1233, 1234, 1235, 560, 160, 421, 485, 437, 436, + /* 530 */ 64, 292, 1165, 435, 192, 1622, 110, 432, 1372, 493, + /* 540 */ 431, 430, 429, 559, 558, 565, 557, 556, 555, 497, + /* 550 */ 55, 32, 31, 30, 1168, 1169, 113, 1215, 1216, 1218, + /* 560 */ 1219, 1220, 1221, 1222, 504, 526, 1230, 1231, 1232, 1233, + /* 570 */ 1234, 1235, 35, 33, 274, 489, 1186, 525, 1530, 427, + /* 580 */ 303, 1217, 1164, 368, 1472, 314, 380, 80, 1622, 1482, + /* 590 */ 1528, 525, 1468, 111, 1640, 36, 34, 32, 31, 30, + /* 600 */ 54, 1371, 426, 1602, 381, 1460, 1485, 1162, 217, 1728, + /* 610 */ 484, 1217, 483, 1735, 1636, 1783, 1255, 58, 57, 348, + /* 620 */ 1485, 525, 154, 1370, 1170, 62, 1530, 342, 146, 1632, + /* 630 */ 1638, 998, 1780, 459, 11, 10, 1260, 1731, 1529, 273, + /* 640 */ 528, 2, 332, 1367, 328, 324, 151, 1481, 1000, 1369, + /* 650 */ 1485, 1622, 1036, 551, 550, 549, 1040, 548, 1042, 1043, + /* 660 */ 547, 1045, 544, 608, 1051, 541, 1053, 1054, 538, 535, + /* 670 */ 434, 433, 25, 1622, 1163, 379, 1355, 149, 374, 373, + /* 680 */ 372, 371, 370, 367, 366, 365, 364, 363, 359, 358, + /* 690 */ 357, 356, 355, 354, 353, 352, 1290, 95, 560, 1622, + /* 700 */ 94, 93, 92, 91, 90, 89, 88, 87, 86, 1416, + /* 710 */ 36, 34, 32, 31, 30, 1267, 1165, 559, 558, 501, + /* 720 */ 557, 556, 555, 1368, 494, 1365, 578, 576, 525, 1364, + /* 730 */ 1652, 1347, 1735, 36, 34, 32, 31, 30, 1168, 1169, + /* 740 */ 522, 1215, 1216, 1218, 1219, 1220, 1221, 1222, 504, 526, + /* 750 */ 1230, 1231, 1232, 1233, 1234, 1235, 1730, 1485, 1668, 525, + /* 760 */ 1363, 1652, 1461, 71, 1567, 1568, 509, 577, 1443, 437, + /* 770 */ 436, 523, 7, 1622, 435, 1622, 508, 110, 432, 1622, + /* 780 */ 1622, 431, 430, 429, 1478, 489, 1362, 1191, 1485, 1668, + /* 790 */ 36, 34, 32, 31, 30, 1188, 1681, 509, 1361, 81, + /* 800 */ 1653, 511, 1655, 1656, 507, 1360, 528, 508, 339, 1721, + /* 810 */ 1622, 1622, 1346, 276, 1717, 1652, 489, 525, 195, 562, + /* 820 */ 1359, 491, 1164, 250, 485, 1783, 1515, 1681, 1358, 241, + /* 830 */ 81, 1653, 511, 1655, 1656, 507, 1622, 528, 148, 1245, + /* 840 */ 1721, 129, 1780, 1668, 276, 1717, 1485, 1162, 1622, 458, + /* 850 */ 1488, 488, 1357, 113, 525, 1622, 1783, 223, 310, 309, + /* 860 */ 1202, 508, 1413, 503, 1170, 1622, 317, 128, 1178, 146, + /* 870 */ 1622, 933, 934, 1780, 1740, 1286, 183, 185, 1622, 181, + /* 880 */ 184, 1681, 1403, 1485, 82, 1653, 511, 1655, 1656, 507, + /* 890 */ 111, 528, 187, 1171, 1721, 186, 1149, 1150, 296, 1717, + /* 900 */ 142, 1289, 1622, 608, 438, 145, 1728, 1729, 189, 1733, + /* 910 */ 1170, 188, 220, 204, 1163, 553, 1652, 472, 467, 1748, + /* 920 */ 119, 452, 584, 583, 582, 318, 1398, 581, 580, 579, + /* 930 */ 115, 574, 573, 572, 571, 570, 569, 568, 567, 122, + /* 940 */ 563, 1396, 1286, 46, 1668, 449, 11, 10, 440, 529, + /* 950 */ 207, 1173, 509, 1349, 1350, 37, 1165, 1217, 447, 214, + /* 960 */ 1174, 463, 508, 443, 1172, 77, 1622, 1387, 37, 1642, + /* 970 */ 37, 230, 117, 118, 119, 73, 46, 1669, 1168, 1169, + /* 980 */ 1652, 533, 1681, 420, 1312, 82, 1653, 511, 1655, 1656, + /* 990 */ 507, 209, 528, 118, 1525, 1721, 1261, 119, 1751, 296, + /* 1000 */ 1717, 1796, 1179, 120, 118, 486, 1644, 222, 1668, 1223, + /* 1010 */ 1778, 1122, 232, 517, 238, 1029, 509, 249, 1176, 225, + /* 1020 */ 227, 3, 1057, 970, 1182, 1186, 508, 321, 325, 282, + /* 1030 */ 1622, 1175, 998, 362, 1061, 526, 1230, 1231, 1068, 1652, + /* 1040 */ 971, 283, 442, 1133, 1066, 121, 1681, 246, 156, 82, + /* 1050 */ 1653, 511, 1655, 1656, 507, 369, 528, 450, 1565, 1721, + /* 1060 */ 377, 382, 1192, 296, 1717, 1796, 376, 1668, 383, 391, + /* 1070 */ 378, 191, 1195, 394, 1739, 509, 395, 163, 1194, 396, + /* 1080 */ 165, 1196, 399, 445, 168, 508, 1652, 397, 439, 1622, + /* 1090 */ 398, 170, 1193, 190, 489, 173, 400, 61, 403, 422, + /* 1100 */ 176, 424, 1475, 180, 1471, 1681, 182, 85, 263, 1653, + /* 1110 */ 511, 1655, 1656, 507, 1668, 528, 291, 123, 51, 1170, + /* 1120 */ 124, 50, 509, 1473, 1469, 193, 125, 126, 453, 454, + /* 1130 */ 1606, 196, 508, 1652, 1783, 460, 1622, 199, 247, 457, + /* 1140 */ 464, 489, 202, 1191, 462, 1762, 1742, 148, 465, 1752, + /* 1150 */ 473, 1780, 1681, 515, 213, 263, 1653, 511, 1655, 1656, + /* 1160 */ 507, 1668, 528, 205, 1652, 1761, 470, 6, 208, 509, + /* 1170 */ 482, 469, 295, 112, 476, 1286, 5, 1190, 1736, 508, + /* 1180 */ 215, 1783, 40, 1622, 498, 297, 495, 1799, 216, 18, + /* 1190 */ 1702, 1574, 1668, 136, 146, 1779, 513, 514, 1780, 1681, + /* 1200 */ 509, 305, 83, 1653, 511, 1655, 1656, 507, 1573, 528, + /* 1210 */ 508, 518, 1721, 72, 1622, 221, 1720, 1717, 492, 224, + /* 1220 */ 234, 499, 1652, 226, 236, 519, 70, 520, 1486, 248, + /* 1230 */ 1681, 531, 251, 83, 1653, 511, 1655, 1656, 507, 1458, + /* 1240 */ 528, 243, 607, 1721, 253, 47, 255, 500, 1717, 257, + /* 1250 */ 1668, 264, 135, 1616, 258, 1615, 320, 1612, 506, 322, + /* 1260 */ 323, 1158, 327, 1159, 152, 1610, 329, 330, 508, 1609, + /* 1270 */ 331, 333, 1622, 1608, 335, 1607, 337, 1592, 153, 340, + /* 1280 */ 341, 1652, 1136, 1135, 1586, 1585, 346, 347, 1681, 1584, + /* 1290 */ 1583, 271, 1653, 511, 1655, 1656, 507, 505, 528, 502, + /* 1300 */ 1693, 1558, 1105, 1557, 1556, 1555, 1554, 1553, 1552, 1668, + /* 1310 */ 1551, 1550, 1549, 1548, 1547, 1546, 1545, 509, 1544, 1543, + /* 1320 */ 1542, 1541, 116, 1540, 1539, 1538, 1537, 508, 1536, 1535, + /* 1330 */ 1534, 1622, 1533, 1532, 1531, 1415, 1652, 1383, 161, 1107, + /* 1340 */ 139, 936, 1382, 1600, 387, 935, 107, 1681, 179, 404, + /* 1350 */ 133, 1653, 511, 1655, 1656, 507, 1594, 528, 1582, 1581, + /* 1360 */ 1571, 1464, 1414, 1412, 1668, 1410, 389, 1408, 1406, 1395, + /* 1370 */ 1394, 1381, 509, 1466, 162, 108, 167, 172, 45, 1465, + /* 1380 */ 49, 406, 508, 127, 456, 197, 1622, 410, 203, 1652, + /* 1390 */ 405, 414, 409, 408, 490, 1797, 1072, 413, 412, 1071, + /* 1400 */ 964, 418, 1681, 1404, 416, 83, 1653, 511, 1655, 1656, + /* 1410 */ 507, 417, 528, 1399, 611, 1721, 288, 1668, 289, 997, + /* 1420 */ 1718, 996, 995, 994, 575, 509, 441, 991, 245, 577, + /* 1430 */ 1397, 290, 1380, 446, 1379, 508, 448, 990, 989, 1622, + /* 1440 */ 106, 84, 468, 1599, 1652, 444, 600, 596, 592, 588, + /* 1450 */ 244, 1143, 1593, 455, 1580, 1681, 1652, 1579, 272, 1653, + /* 1460 */ 511, 1655, 1656, 507, 1578, 528, 1570, 66, 4, 37, + /* 1470 */ 201, 15, 1668, 212, 206, 79, 43, 211, 239, 1311, + /* 1480 */ 509, 134, 210, 22, 1668, 1642, 16, 1304, 67, 23, + /* 1490 */ 508, 218, 509, 41, 1622, 137, 42, 1283, 13, 48, + /* 1500 */ 1282, 1340, 508, 17, 1329, 1335, 1622, 1334, 298, 19, + /* 1510 */ 1681, 10, 521, 267, 1653, 511, 1655, 1656, 507, 1339, + /* 1520 */ 528, 1338, 1681, 29, 299, 133, 1653, 511, 1655, 1656, + /* 1530 */ 507, 1225, 528, 1652, 138, 1224, 150, 466, 1210, 1569, + /* 1540 */ 200, 229, 235, 516, 12, 1641, 20, 237, 21, 1180, + /* 1550 */ 231, 481, 1309, 1227, 233, 240, 68, 1141, 1035, 194, + /* 1560 */ 1246, 1668, 69, 1684, 510, 527, 44, 532, 1058, 509, + /* 1570 */ 1798, 73, 312, 1055, 534, 530, 536, 537, 539, 508, + /* 1580 */ 1052, 540, 542, 1622, 1046, 543, 300, 545, 1044, 1652, + /* 1590 */ 552, 546, 1050, 1049, 1048, 74, 75, 1067, 76, 1681, + /* 1600 */ 1047, 1064, 272, 1653, 511, 1655, 1656, 507, 1065, 528, + /* 1610 */ 1063, 962, 986, 561, 242, 1004, 564, 1668, 984, 983, + /* 1620 */ 979, 982, 981, 980, 978, 506, 977, 1001, 1652, 999, + /* 1630 */ 974, 973, 972, 969, 1411, 508, 968, 967, 585, 1622, + /* 1640 */ 586, 587, 1409, 589, 590, 591, 1407, 593, 594, 595, + /* 1650 */ 1405, 598, 597, 599, 1393, 1681, 1668, 1652, 271, 1653, + /* 1660 */ 511, 1655, 1656, 507, 509, 528, 601, 1694, 602, 1392, + /* 1670 */ 1378, 605, 606, 609, 508, 1166, 610, 252, 1622, 1353, + /* 1680 */ 1353, 302, 1353, 1353, 1353, 1668, 1652, 1353, 1353, 1353, + /* 1690 */ 1353, 1353, 1353, 509, 1681, 1353, 1353, 272, 1653, 511, + /* 1700 */ 1655, 1656, 507, 508, 528, 1353, 1353, 1622, 1353, 1353, + /* 1710 */ 304, 1353, 1353, 1353, 1668, 1353, 1353, 1652, 1353, 1353, + /* 1720 */ 1353, 1353, 509, 1681, 1353, 1353, 272, 1653, 511, 1655, + /* 1730 */ 1656, 507, 508, 528, 1353, 1353, 1622, 1353, 1353, 1353, + /* 1740 */ 1353, 1353, 1353, 1353, 1353, 1668, 1353, 1353, 1652, 1353, + /* 1750 */ 1353, 1353, 1681, 509, 1353, 259, 1653, 511, 1655, 1656, + /* 1760 */ 507, 1353, 528, 508, 1353, 1353, 1353, 1622, 1353, 1353, + /* 1770 */ 1353, 1353, 1353, 1353, 1353, 1353, 1668, 1353, 1353, 1652, + /* 1780 */ 1353, 1353, 1353, 1681, 509, 1353, 266, 1653, 511, 1655, + /* 1790 */ 1656, 507, 1353, 528, 508, 1353, 1353, 1353, 1622, 1353, + /* 1800 */ 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1668, 1353, 1353, + /* 1810 */ 1353, 1652, 1353, 1353, 1681, 509, 1353, 268, 1653, 511, + /* 1820 */ 1655, 1656, 507, 1353, 528, 508, 1353, 1353, 1652, 1622, + /* 1830 */ 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1668, + /* 1840 */ 1353, 1353, 1353, 1353, 1353, 1681, 1353, 509, 260, 1653, + /* 1850 */ 511, 1655, 1656, 507, 1353, 528, 1668, 508, 1353, 1353, + /* 1860 */ 1353, 1622, 1353, 1353, 509, 1353, 1353, 1652, 1353, 1353, + /* 1870 */ 1353, 1353, 1353, 1353, 508, 1353, 1353, 1681, 1622, 1353, + /* 1880 */ 269, 1653, 511, 1655, 1656, 507, 1353, 528, 1353, 1353, + /* 1890 */ 1353, 1353, 1353, 1353, 1681, 1668, 1353, 261, 1653, 511, + /* 1900 */ 1655, 1656, 507, 509, 528, 1353, 1652, 1353, 1353, 1353, + /* 1910 */ 1353, 1353, 1353, 508, 1353, 1353, 1353, 1622, 1353, 1353, + /* 1920 */ 1353, 1353, 1353, 1652, 1353, 1353, 1353, 1353, 1353, 1353, + /* 1930 */ 1353, 1353, 1353, 1681, 1668, 1652, 270, 1653, 511, 1655, + /* 1940 */ 1656, 507, 509, 528, 1353, 1353, 1353, 1353, 1353, 1353, + /* 1950 */ 1353, 1668, 508, 1353, 1353, 1353, 1622, 1353, 1353, 509, + /* 1960 */ 1353, 1353, 1353, 1668, 1353, 1353, 1353, 1353, 1353, 508, + /* 1970 */ 1353, 509, 1681, 1622, 1652, 262, 1653, 511, 1655, 1656, + /* 1980 */ 507, 508, 528, 1353, 1353, 1622, 1353, 1652, 1353, 1681, + /* 1990 */ 1353, 1353, 1664, 1653, 511, 1655, 1656, 507, 1353, 528, + /* 2000 */ 1353, 1681, 1668, 1353, 1663, 1653, 511, 1655, 1656, 507, + /* 2010 */ 509, 528, 1353, 1353, 1353, 1668, 1353, 1353, 1353, 1353, + /* 2020 */ 508, 1353, 1353, 509, 1622, 1353, 1652, 1353, 1353, 1353, + /* 2030 */ 1353, 1353, 1353, 508, 1353, 1353, 1353, 1622, 1353, 1353, + /* 2040 */ 1681, 1353, 1353, 1662, 1653, 511, 1655, 1656, 507, 1353, + /* 2050 */ 528, 1353, 1353, 1681, 1668, 1353, 280, 1653, 511, 1655, + /* 2060 */ 1656, 507, 509, 528, 1353, 1353, 1353, 1353, 1353, 1353, + /* 2070 */ 1353, 1353, 508, 1353, 1353, 1353, 1622, 1353, 1353, 1353, + /* 2080 */ 1353, 1652, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, + /* 2090 */ 1652, 1353, 1681, 1353, 1353, 279, 1653, 511, 1655, 1656, + /* 2100 */ 507, 1353, 528, 1353, 1353, 1353, 1353, 1353, 1353, 1668, + /* 2110 */ 1353, 1353, 1353, 1353, 1353, 1353, 1353, 509, 1668, 1353, + /* 2120 */ 1353, 1353, 1353, 1353, 1353, 1353, 509, 508, 1353, 1353, + /* 2130 */ 1353, 1622, 1353, 1353, 1353, 1353, 508, 1652, 1353, 1353, + /* 2140 */ 1622, 1353, 1353, 1353, 1353, 1353, 1353, 1681, 1353, 1353, + /* 2150 */ 281, 1653, 511, 1655, 1656, 507, 1681, 528, 1353, 278, + /* 2160 */ 1653, 511, 1655, 1656, 507, 1668, 528, 1353, 1353, 1353, + /* 2170 */ 1353, 1353, 1353, 509, 1353, 1353, 1353, 1353, 1353, 1353, + /* 2180 */ 1353, 1353, 1353, 508, 1353, 1353, 1353, 1622, 1353, 1353, + /* 2190 */ 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, + /* 2200 */ 1353, 1353, 1353, 1681, 1353, 1353, 265, 1653, 511, 1655, + /* 2210 */ 1656, 507, 1353, 528, }; static const YYCODETYPE yy_lookahead[] = { - /* 0 */ 246, 273, 248, 249, 276, 246, 250, 248, 249, 324, - /* 10 */ 325, 4, 12, 13, 242, 271, 244, 243, 262, 339, - /* 20 */ 20, 293, 22, 279, 20, 269, 12, 13, 14, 15, - /* 30 */ 16, 247, 352, 255, 250, 279, 356, 309, 310, 12, - /* 40 */ 13, 14, 15, 16, 271, 271, 268, 47, 320, 42, - /* 50 */ 43, 278, 47, 279, 250, 277, 283, 55, 58, 315, - /* 60 */ 12, 13, 14, 289, 64, 2, 262, 293, 20, 64, - /* 70 */ 22, 0, 58, 299, 20, 12, 13, 14, 15, 16, - /* 80 */ 4, 81, 80, 279, 310, 83, 250, 313, 314, 315, - /* 90 */ 316, 317, 318, 0, 320, 47, 82, 323, 262, 251, - /* 100 */ 252, 327, 328, 103, 90, 269, 58, 12, 13, 14, - /* 110 */ 15, 16, 64, 339, 114, 279, 270, 24, 25, 26, - /* 120 */ 27, 28, 29, 30, 31, 32, 352, 75, 282, 81, - /* 130 */ 356, 60, 61, 62, 63, 81, 65, 66, 67, 68, - /* 140 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, - /* 150 */ 289, 103, 279, 292, 140, 81, 295, 81, 158, 286, - /* 160 */ 21, 339, 114, 24, 25, 26, 27, 28, 29, 30, - /* 170 */ 31, 32, 120, 121, 352, 250, 162, 150, 356, 247, - /* 180 */ 180, 181, 250, 183, 184, 185, 186, 187, 188, 189, - /* 190 */ 190, 191, 192, 193, 194, 195, 196, 197, 0, 12, - /* 200 */ 13, 14, 15, 16, 167, 168, 158, 256, 171, 284, - /* 210 */ 210, 260, 198, 199, 200, 201, 202, 203, 204, 205, - /* 220 */ 206, 207, 0, 12, 13, 14, 15, 16, 180, 181, - /* 230 */ 250, 183, 184, 185, 186, 187, 188, 189, 190, 191, - /* 240 */ 192, 193, 194, 195, 196, 197, 12, 13, 0, 20, - /* 250 */ 253, 22, 60, 61, 20, 57, 22, 65, 231, 279, - /* 260 */ 68, 69, 263, 339, 72, 73, 74, 12, 13, 82, - /* 270 */ 271, 274, 243, 57, 20, 20, 352, 22, 49, 280, - /* 280 */ 356, 47, 60, 61, 210, 20, 210, 65, 255, 47, - /* 290 */ 68, 69, 58, 82, 72, 73, 74, 317, 64, 0, - /* 300 */ 271, 14, 47, 243, 243, 250, 64, 20, 279, 250, - /* 310 */ 277, 331, 332, 333, 334, 81, 336, 262, 289, 64, - /* 320 */ 21, 262, 293, 24, 25, 26, 27, 28, 29, 30, - /* 330 */ 31, 32, 271, 243, 279, 81, 81, 103, 279, 310, - /* 340 */ 279, 93, 313, 314, 315, 316, 317, 318, 114, 320, - /* 350 */ 289, 20, 323, 293, 293, 271, 327, 328, 103, 271, - /* 360 */ 112, 113, 278, 115, 116, 117, 243, 283, 280, 114, - /* 370 */ 259, 310, 261, 271, 313, 314, 315, 316, 317, 318, - /* 380 */ 278, 320, 250, 293, 323, 283, 311, 2, 327, 328, - /* 390 */ 329, 20, 158, 3, 262, 257, 258, 12, 13, 14, - /* 400 */ 15, 16, 341, 12, 13, 14, 15, 16, 347, 348, - /* 410 */ 335, 279, 81, 158, 180, 181, 293, 183, 184, 185, - /* 420 */ 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - /* 430 */ 196, 197, 250, 257, 258, 180, 181, 243, 183, 184, - /* 440 */ 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - /* 450 */ 195, 196, 197, 12, 13, 14, 243, 4, 20, 19, - /* 460 */ 281, 20, 243, 22, 210, 210, 264, 288, 289, 267, - /* 470 */ 14, 184, 19, 33, 12, 13, 20, 273, 243, 243, - /* 480 */ 273, 299, 20, 276, 22, 45, 33, 293, 47, 250, - /* 490 */ 144, 51, 52, 53, 54, 55, 14, 293, 45, 240, - /* 500 */ 293, 262, 20, 50, 57, 64, 293, 271, 55, 47, - /* 510 */ 153, 250, 293, 309, 310, 279, 309, 310, 279, 250, - /* 520 */ 80, 339, 81, 83, 320, 289, 64, 320, 293, 293, - /* 530 */ 173, 174, 64, 80, 352, 299, 83, 146, 356, 289, - /* 540 */ 279, 210, 41, 81, 103, 295, 310, 20, 279, 313, - /* 550 */ 314, 315, 316, 317, 318, 114, 320, 117, 299, 323, - /* 560 */ 243, 215, 216, 327, 328, 103, 12, 13, 14, 15, - /* 570 */ 16, 273, 80, 263, 272, 339, 114, 93, 317, 92, - /* 580 */ 88, 271, 142, 82, 146, 145, 317, 0, 352, 81, - /* 590 */ 280, 293, 356, 332, 333, 334, 253, 336, 339, 158, - /* 600 */ 116, 332, 333, 334, 164, 336, 166, 309, 310, 266, - /* 610 */ 293, 352, 58, 288, 289, 356, 226, 274, 320, 4, - /* 620 */ 158, 180, 181, 243, 183, 184, 185, 186, 187, 188, - /* 630 */ 189, 190, 191, 192, 193, 194, 195, 196, 197, 35, - /* 640 */ 184, 149, 180, 181, 90, 183, 184, 185, 186, 187, - /* 650 */ 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - /* 660 */ 12, 13, 18, 93, 20, 157, 180, 159, 20, 250, - /* 670 */ 22, 27, 250, 293, 30, 14, 15, 16, 208, 209, - /* 680 */ 93, 262, 112, 113, 262, 115, 116, 117, 84, 37, - /* 690 */ 86, 87, 48, 89, 140, 47, 22, 93, 279, 112, - /* 700 */ 113, 279, 115, 116, 117, 219, 220, 221, 222, 223, - /* 710 */ 271, 263, 64, 1, 2, 243, 162, 311, 210, 271, - /* 720 */ 116, 47, 283, 42, 43, 311, 169, 170, 280, 81, - /* 730 */ 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - /* 740 */ 104, 335, 106, 107, 108, 109, 110, 111, 299, 335, - /* 750 */ 243, 103, 198, 199, 200, 201, 202, 203, 204, 205, - /* 760 */ 206, 207, 114, 119, 0, 293, 122, 123, 124, 125, - /* 770 */ 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - /* 780 */ 136, 137, 138, 139, 250, 250, 18, 250, 339, 20, - /* 790 */ 41, 23, 20, 20, 82, 140, 262, 262, 272, 262, - /* 800 */ 293, 352, 243, 35, 36, 356, 158, 39, 243, 243, - /* 810 */ 243, 299, 243, 279, 279, 243, 279, 162, 250, 243, - /* 820 */ 243, 57, 243, 146, 56, 148, 211, 272, 180, 181, - /* 830 */ 262, 183, 184, 185, 186, 187, 188, 189, 190, 191, - /* 840 */ 192, 193, 194, 195, 196, 197, 41, 279, 271, 81, - /* 850 */ 272, 339, 293, 198, 0, 272, 279, 0, 293, 293, - /* 860 */ 293, 209, 293, 0, 352, 293, 289, 0, 356, 293, - /* 870 */ 293, 85, 293, 85, 88, 85, 88, 85, 88, 22, - /* 880 */ 88, 243, 58, 21, 272, 22, 118, 310, 81, 22, - /* 890 */ 313, 314, 315, 316, 317, 318, 34, 320, 91, 45, - /* 900 */ 323, 1, 2, 272, 327, 328, 329, 244, 303, 271, - /* 910 */ 195, 196, 44, 260, 243, 146, 47, 279, 150, 151, - /* 920 */ 152, 41, 41, 155, 350, 348, 47, 289, 160, 41, - /* 930 */ 359, 293, 41, 41, 41, 307, 344, 271, 249, 41, - /* 940 */ 172, 251, 271, 175, 282, 177, 178, 179, 310, 81, - /* 950 */ 279, 313, 314, 315, 316, 317, 318, 184, 320, 312, - /* 960 */ 289, 323, 82, 82, 293, 327, 328, 329, 20, 41, - /* 970 */ 82, 41, 337, 82, 82, 82, 338, 228, 210, 243, - /* 980 */ 82, 310, 353, 114, 313, 314, 315, 316, 317, 318, - /* 990 */ 353, 320, 41, 114, 323, 243, 41, 41, 327, 328, - /* 1000 */ 329, 250, 41, 353, 180, 340, 41, 271, 45, 338, - /* 1010 */ 82, 308, 82, 47, 257, 279, 41, 41, 301, 40, - /* 1020 */ 156, 250, 287, 271, 250, 289, 140, 243, 285, 293, - /* 1030 */ 285, 279, 250, 82, 20, 230, 245, 82, 82, 245, - /* 1040 */ 20, 289, 305, 82, 255, 293, 310, 82, 289, 313, - /* 1050 */ 314, 315, 316, 317, 318, 271, 320, 82, 82, 323, - /* 1060 */ 20, 255, 310, 279, 328, 313, 314, 315, 316, 317, - /* 1070 */ 318, 20, 320, 289, 297, 323, 300, 293, 243, 327, - /* 1080 */ 328, 329, 255, 299, 297, 255, 20, 279, 290, 255, - /* 1090 */ 338, 255, 250, 243, 310, 255, 245, 313, 314, 315, - /* 1100 */ 316, 317, 318, 271, 320, 250, 271, 64, 271, 271, - /* 1110 */ 271, 245, 271, 293, 279, 271, 271, 271, 271, 271, - /* 1120 */ 271, 271, 305, 339, 289, 253, 304, 253, 293, 279, - /* 1130 */ 297, 253, 165, 290, 299, 279, 352, 253, 20, 289, - /* 1140 */ 356, 289, 218, 293, 243, 310, 349, 294, 313, 314, - /* 1150 */ 315, 316, 317, 318, 217, 320, 225, 346, 293, 349, - /* 1160 */ 310, 345, 224, 313, 314, 315, 316, 317, 318, 294, - /* 1170 */ 320, 312, 271, 323, 339, 293, 293, 327, 328, 20, - /* 1180 */ 279, 213, 212, 209, 279, 40, 229, 352, 311, 360, - /* 1190 */ 289, 356, 232, 81, 293, 293, 243, 293, 227, 293, - /* 1200 */ 12, 13, 294, 343, 294, 243, 330, 143, 291, 290, - /* 1210 */ 22, 310, 342, 355, 313, 314, 315, 316, 317, 318, - /* 1220 */ 319, 320, 321, 322, 271, 354, 279, 81, 355, 326, - /* 1230 */ 253, 267, 279, 271, 253, 47, 250, 279, 253, 354, - /* 1240 */ 245, 279, 289, 261, 355, 302, 293, 275, 354, 265, - /* 1250 */ 306, 289, 64, 243, 265, 293, 265, 298, 296, 254, - /* 1260 */ 241, 0, 0, 310, 72, 0, 313, 314, 315, 316, - /* 1270 */ 317, 318, 310, 320, 47, 313, 314, 315, 316, 317, - /* 1280 */ 318, 271, 320, 176, 47, 243, 47, 47, 0, 279, - /* 1290 */ 176, 103, 47, 47, 0, 176, 47, 0, 47, 289, - /* 1300 */ 0, 47, 114, 293, 0, 81, 162, 114, 161, 158, - /* 1310 */ 357, 358, 0, 271, 0, 154, 153, 243, 0, 0, - /* 1320 */ 310, 279, 44, 313, 314, 315, 316, 317, 318, 0, - /* 1330 */ 320, 289, 0, 0, 0, 293, 0, 0, 0, 0, - /* 1340 */ 0, 0, 0, 0, 0, 271, 158, 0, 0, 0, - /* 1350 */ 0, 0, 310, 279, 0, 313, 314, 315, 316, 317, - /* 1360 */ 318, 351, 320, 289, 40, 243, 0, 293, 180, 0, - /* 1370 */ 296, 0, 0, 0, 22, 0, 0, 0, 243, 191, - /* 1380 */ 192, 193, 0, 0, 310, 0, 40, 313, 314, 315, - /* 1390 */ 316, 317, 318, 271, 320, 14, 37, 41, 14, 44, - /* 1400 */ 358, 279, 0, 38, 44, 37, 271, 0, 0, 0, - /* 1410 */ 0, 289, 0, 0, 279, 293, 37, 37, 243, 0, - /* 1420 */ 59, 0, 0, 37, 289, 47, 0, 37, 293, 37, - /* 1430 */ 0, 296, 310, 37, 45, 313, 314, 315, 316, 317, - /* 1440 */ 318, 47, 320, 45, 322, 310, 271, 47, 313, 314, - /* 1450 */ 315, 316, 317, 318, 279, 320, 45, 0, 33, 0, - /* 1460 */ 45, 47, 0, 0, 289, 47, 243, 0, 293, 22, - /* 1470 */ 45, 296, 41, 41, 47, 22, 51, 52, 53, 54, - /* 1480 */ 55, 90, 47, 88, 47, 310, 47, 47, 313, 314, - /* 1490 */ 315, 316, 317, 318, 271, 320, 47, 47, 0, 22, - /* 1500 */ 47, 0, 279, 22, 48, 80, 0, 22, 83, 0, - /* 1510 */ 22, 47, 289, 0, 22, 20, 293, 64, 0, 47, - /* 1520 */ 146, 0, 22, 243, 0, 163, 0, 0, 37, 81, - /* 1530 */ 143, 41, 81, 310, 141, 41, 313, 314, 315, 316, - /* 1540 */ 317, 318, 82, 320, 214, 146, 41, 82, 82, 81, - /* 1550 */ 81, 271, 41, 41, 44, 81, 103, 82, 44, 279, - /* 1560 */ 82, 44, 82, 41, 44, 208, 141, 114, 143, 289, - /* 1570 */ 145, 243, 147, 293, 41, 47, 47, 214, 214, 82, - /* 1580 */ 2, 47, 47, 47, 47, 180, 41, 44, 44, 82, - /* 1590 */ 310, 166, 22, 313, 314, 315, 316, 317, 318, 271, - /* 1600 */ 320, 243, 182, 0, 81, 144, 81, 279, 44, 37, - /* 1610 */ 91, 158, 82, 81, 141, 22, 47, 289, 44, 81, - /* 1620 */ 81, 293, 82, 92, 82, 59, 47, 81, 81, 271, - /* 1630 */ 81, 243, 81, 180, 181, 82, 81, 279, 310, 81, - /* 1640 */ 81, 313, 314, 315, 316, 317, 318, 289, 320, 82, - /* 1650 */ 82, 293, 47, 47, 81, 47, 47, 82, 81, 271, - /* 1660 */ 22, 105, 82, 81, 47, 82, 81, 279, 310, 93, - /* 1670 */ 105, 313, 314, 315, 316, 317, 318, 289, 320, 243, - /* 1680 */ 81, 293, 81, 81, 47, 22, 105, 58, 243, 105, - /* 1690 */ 47, 64, 79, 41, 47, 47, 47, 47, 310, 22, - /* 1700 */ 114, 313, 314, 315, 316, 317, 318, 271, 320, 47, - /* 1710 */ 64, 47, 47, 47, 47, 279, 271, 47, 47, 47, - /* 1720 */ 47, 47, 0, 47, 279, 289, 45, 37, 0, 293, - /* 1730 */ 47, 45, 37, 0, 289, 47, 243, 45, 293, 37, - /* 1740 */ 0, 47, 45, 37, 0, 47, 310, 46, 0, 313, - /* 1750 */ 314, 315, 316, 317, 318, 310, 320, 0, 313, 314, - /* 1760 */ 315, 316, 317, 318, 271, 320, 20, 22, 21, 361, - /* 1770 */ 361, 22, 279, 22, 21, 361, 361, 361, 361, 361, - /* 1780 */ 361, 361, 289, 361, 243, 361, 293, 361, 361, 361, - /* 1790 */ 361, 361, 361, 361, 361, 243, 361, 361, 361, 361, - /* 1800 */ 361, 361, 361, 310, 361, 361, 313, 314, 315, 316, - /* 1810 */ 317, 318, 271, 320, 243, 361, 361, 361, 361, 361, - /* 1820 */ 279, 361, 361, 271, 361, 361, 361, 361, 361, 361, - /* 1830 */ 289, 279, 361, 361, 293, 361, 361, 361, 361, 361, - /* 1840 */ 361, 289, 271, 361, 361, 293, 361, 361, 361, 361, - /* 1850 */ 279, 310, 361, 361, 313, 314, 315, 316, 317, 318, - /* 1860 */ 289, 320, 310, 361, 293, 313, 314, 315, 316, 317, - /* 1870 */ 318, 361, 320, 243, 361, 361, 361, 361, 361, 361, - /* 1880 */ 361, 310, 243, 361, 313, 314, 315, 316, 317, 318, - /* 1890 */ 361, 320, 361, 361, 361, 361, 361, 361, 361, 361, - /* 1900 */ 361, 271, 361, 361, 361, 361, 361, 361, 361, 279, - /* 1910 */ 271, 361, 361, 361, 361, 361, 361, 361, 279, 289, - /* 1920 */ 361, 361, 361, 293, 361, 361, 361, 361, 289, 361, - /* 1930 */ 361, 361, 293, 361, 361, 361, 361, 361, 361, 361, - /* 1940 */ 310, 361, 243, 313, 314, 315, 316, 317, 318, 310, - /* 1950 */ 320, 243, 313, 314, 315, 316, 317, 318, 361, 320, - /* 1960 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, - /* 1970 */ 271, 361, 361, 361, 361, 361, 361, 361, 279, 271, - /* 1980 */ 361, 361, 361, 361, 361, 361, 361, 279, 289, 361, - /* 1990 */ 361, 361, 293, 361, 361, 361, 361, 289, 361, 243, - /* 2000 */ 361, 293, 361, 361, 361, 361, 361, 361, 361, 310, - /* 2010 */ 250, 361, 313, 314, 315, 316, 317, 318, 310, 320, - /* 2020 */ 361, 313, 314, 315, 316, 317, 318, 271, 320, 361, - /* 2030 */ 361, 361, 361, 361, 361, 279, 361, 361, 361, 279, - /* 2040 */ 361, 361, 361, 361, 361, 289, 250, 361, 361, 293, - /* 2050 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 299, - /* 2060 */ 361, 361, 361, 361, 361, 361, 310, 361, 361, 313, - /* 2070 */ 314, 315, 316, 317, 318, 279, 320, 317, 361, 361, - /* 2080 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, - /* 2090 */ 361, 361, 332, 333, 334, 299, 336, 361, 361, 339, - /* 2100 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, - /* 2110 */ 361, 361, 352, 317, 361, 361, 356, 361, 361, 361, - /* 2120 */ 361, 361, 361, 361, 361, 361, 361, 361, 332, 333, - /* 2130 */ 334, 361, 336, 361, 361, 339, 361, 361, 361, 361, - /* 2140 */ 361, 361, 361, 361, 361, 361, 361, 361, 352, 361, - /* 2150 */ 361, 361, 356, + /* 0 */ 254, 336, 296, 271, 258, 271, 274, 244, 274, 246, + /* 10 */ 247, 251, 12, 13, 349, 270, 2, 241, 353, 240, + /* 20 */ 20, 242, 22, 291, 264, 291, 12, 13, 14, 15, + /* 30 */ 16, 244, 272, 246, 247, 336, 271, 336, 306, 307, + /* 40 */ 306, 307, 336, 20, 253, 269, 4, 47, 349, 317, + /* 50 */ 349, 317, 353, 277, 353, 349, 291, 266, 58, 353, + /* 60 */ 12, 13, 14, 287, 64, 248, 275, 291, 20, 20, + /* 70 */ 22, 306, 307, 20, 12, 13, 14, 15, 16, 321, + /* 80 */ 322, 81, 317, 307, 42, 43, 310, 311, 312, 313, + /* 90 */ 314, 315, 57, 317, 277, 47, 320, 20, 269, 269, + /* 100 */ 324, 325, 326, 103, 81, 276, 58, 277, 12, 13, + /* 110 */ 281, 287, 64, 296, 114, 241, 20, 293, 22, 296, + /* 120 */ 58, 345, 12, 13, 14, 15, 16, 81, 4, 81, + /* 130 */ 21, 314, 248, 24, 25, 26, 27, 28, 29, 30, + /* 140 */ 31, 32, 312, 47, 82, 248, 329, 330, 331, 81, + /* 150 */ 333, 103, 90, 336, 58, 245, 156, 260, 248, 336, + /* 160 */ 64, 277, 114, 248, 267, 291, 349, 35, 58, 14, + /* 170 */ 353, 296, 349, 277, 277, 20, 353, 81, 178, 179, + /* 180 */ 284, 181, 182, 183, 184, 185, 186, 187, 188, 189, + /* 190 */ 190, 191, 192, 193, 194, 195, 308, 282, 314, 103, + /* 200 */ 90, 155, 140, 157, 156, 81, 245, 20, 208, 248, + /* 210 */ 114, 336, 328, 329, 330, 331, 84, 333, 86, 87, + /* 220 */ 332, 89, 160, 55, 349, 93, 178, 179, 353, 181, + /* 230 */ 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + /* 240 */ 192, 193, 194, 195, 20, 268, 22, 0, 116, 81, + /* 250 */ 140, 83, 156, 241, 208, 20, 178, 280, 196, 197, + /* 260 */ 198, 199, 200, 201, 202, 203, 204, 205, 81, 20, + /* 270 */ 160, 249, 250, 49, 178, 179, 208, 181, 182, 183, + /* 280 */ 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + /* 290 */ 194, 195, 12, 13, 0, 217, 218, 219, 220, 221, + /* 300 */ 20, 20, 22, 291, 57, 55, 196, 197, 198, 199, + /* 310 */ 200, 201, 202, 203, 204, 205, 33, 248, 24, 25, + /* 320 */ 26, 27, 28, 29, 30, 31, 32, 47, 45, 260, + /* 330 */ 80, 241, 208, 83, 51, 52, 53, 54, 55, 0, + /* 340 */ 12, 13, 14, 261, 64, 248, 277, 57, 20, 92, + /* 350 */ 22, 269, 12, 13, 14, 15, 16, 260, 2, 269, + /* 360 */ 278, 81, 41, 80, 267, 261, 83, 277, 12, 13, + /* 370 */ 14, 15, 16, 269, 277, 47, 208, 287, 279, 248, + /* 380 */ 238, 291, 278, 103, 241, 286, 287, 287, 12, 13, + /* 390 */ 290, 260, 64, 293, 114, 208, 20, 307, 22, 75, + /* 400 */ 310, 311, 312, 313, 314, 315, 248, 317, 277, 81, + /* 410 */ 320, 144, 261, 14, 324, 325, 326, 248, 260, 20, + /* 420 */ 269, 248, 82, 47, 141, 335, 143, 146, 145, 278, + /* 430 */ 147, 103, 93, 260, 291, 277, 156, 257, 296, 259, + /* 440 */ 64, 0, 114, 14, 120, 121, 277, 164, 248, 20, + /* 450 */ 277, 112, 113, 241, 115, 116, 117, 81, 178, 179, + /* 460 */ 260, 181, 182, 183, 184, 185, 186, 187, 188, 189, + /* 470 */ 190, 191, 192, 193, 194, 195, 151, 277, 336, 103, + /* 480 */ 213, 214, 269, 314, 156, 241, 45, 18, 208, 276, + /* 490 */ 114, 349, 23, 270, 281, 353, 171, 172, 329, 330, + /* 500 */ 331, 22, 333, 291, 35, 36, 178, 179, 39, 181, + /* 510 */ 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + /* 520 */ 192, 193, 194, 195, 93, 56, 47, 248, 60, 61, + /* 530 */ 165, 166, 156, 65, 169, 291, 68, 69, 241, 41, + /* 540 */ 72, 73, 74, 112, 113, 64, 115, 116, 117, 228, + /* 550 */ 81, 14, 15, 16, 178, 179, 277, 181, 182, 183, + /* 560 */ 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + /* 570 */ 194, 195, 12, 13, 18, 296, 20, 248, 269, 93, + /* 580 */ 20, 182, 22, 27, 270, 276, 30, 118, 291, 260, + /* 590 */ 281, 248, 270, 314, 271, 12, 13, 14, 15, 16, + /* 600 */ 3, 241, 116, 260, 48, 0, 277, 47, 329, 330, + /* 610 */ 331, 182, 333, 308, 291, 336, 140, 148, 149, 150, + /* 620 */ 277, 248, 153, 241, 64, 253, 269, 158, 349, 306, + /* 630 */ 307, 47, 353, 260, 1, 2, 160, 332, 281, 170, + /* 640 */ 317, 81, 173, 242, 175, 176, 177, 275, 64, 241, + /* 650 */ 277, 291, 94, 95, 96, 97, 98, 99, 100, 101, + /* 660 */ 102, 103, 104, 103, 106, 107, 108, 109, 110, 111, + /* 670 */ 255, 256, 196, 291, 114, 119, 0, 208, 122, 123, + /* 680 */ 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + /* 690 */ 134, 135, 136, 137, 138, 139, 4, 21, 93, 291, + /* 700 */ 24, 25, 26, 27, 28, 29, 30, 31, 32, 0, + /* 710 */ 12, 13, 14, 15, 16, 82, 156, 112, 113, 58, + /* 720 */ 115, 116, 117, 241, 226, 241, 255, 256, 248, 241, + /* 730 */ 241, 148, 308, 12, 13, 14, 15, 16, 178, 179, + /* 740 */ 260, 181, 182, 183, 184, 185, 186, 187, 188, 189, + /* 750 */ 190, 191, 192, 193, 194, 195, 332, 277, 269, 248, + /* 760 */ 241, 241, 0, 251, 286, 287, 277, 41, 258, 60, + /* 770 */ 61, 260, 37, 291, 65, 291, 287, 68, 69, 291, + /* 780 */ 291, 72, 73, 74, 272, 296, 241, 20, 277, 269, + /* 790 */ 12, 13, 14, 15, 16, 20, 307, 277, 241, 310, + /* 800 */ 311, 312, 313, 314, 315, 241, 317, 287, 82, 320, + /* 810 */ 291, 291, 229, 324, 325, 241, 296, 248, 270, 57, + /* 820 */ 241, 224, 22, 262, 248, 336, 265, 307, 241, 260, + /* 830 */ 310, 311, 312, 313, 314, 315, 291, 317, 349, 178, + /* 840 */ 320, 269, 353, 269, 324, 325, 277, 47, 291, 300, + /* 850 */ 278, 277, 241, 277, 248, 291, 336, 356, 12, 13, + /* 860 */ 82, 287, 0, 270, 64, 291, 260, 146, 22, 349, + /* 870 */ 291, 42, 43, 353, 206, 207, 85, 85, 291, 88, + /* 880 */ 88, 307, 0, 277, 310, 311, 312, 313, 314, 315, + /* 890 */ 314, 317, 85, 47, 320, 88, 167, 168, 324, 325, + /* 900 */ 326, 209, 291, 103, 22, 329, 330, 331, 85, 333, + /* 910 */ 64, 88, 338, 146, 114, 270, 241, 347, 344, 345, + /* 920 */ 41, 304, 60, 61, 62, 63, 0, 65, 66, 67, + /* 930 */ 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + /* 940 */ 78, 0, 207, 41, 269, 21, 1, 2, 22, 103, + /* 950 */ 41, 47, 277, 193, 194, 41, 156, 182, 34, 341, + /* 960 */ 114, 82, 287, 22, 47, 81, 291, 247, 41, 44, + /* 970 */ 41, 41, 41, 41, 41, 91, 41, 269, 178, 179, + /* 980 */ 241, 41, 307, 249, 82, 310, 311, 312, 313, 314, + /* 990 */ 315, 82, 317, 41, 280, 320, 82, 41, 309, 324, + /* 1000 */ 325, 326, 156, 41, 41, 334, 81, 350, 269, 82, + /* 1010 */ 335, 82, 82, 82, 82, 82, 277, 82, 114, 350, + /* 1020 */ 350, 337, 82, 47, 178, 20, 287, 248, 45, 305, + /* 1030 */ 291, 114, 47, 248, 82, 189, 190, 191, 82, 241, + /* 1040 */ 64, 255, 4, 154, 82, 82, 307, 298, 40, 310, + /* 1050 */ 311, 312, 313, 314, 315, 285, 317, 19, 248, 320, + /* 1060 */ 140, 248, 20, 324, 325, 326, 283, 269, 243, 243, + /* 1070 */ 283, 33, 20, 302, 335, 277, 287, 253, 20, 295, + /* 1080 */ 253, 20, 277, 45, 253, 287, 241, 297, 50, 291, + /* 1090 */ 295, 253, 20, 55, 296, 253, 288, 253, 248, 243, + /* 1100 */ 253, 269, 269, 269, 269, 307, 269, 248, 310, 311, + /* 1110 */ 312, 313, 314, 315, 269, 317, 243, 269, 80, 64, + /* 1120 */ 269, 83, 277, 269, 269, 251, 269, 269, 163, 301, + /* 1130 */ 291, 251, 287, 241, 336, 248, 291, 251, 302, 287, + /* 1140 */ 277, 296, 251, 20, 295, 346, 343, 349, 288, 309, + /* 1150 */ 216, 353, 307, 215, 342, 310, 311, 312, 313, 314, + /* 1160 */ 315, 269, 317, 292, 241, 346, 291, 223, 292, 277, + /* 1170 */ 222, 211, 291, 277, 291, 207, 210, 20, 308, 287, + /* 1180 */ 339, 336, 40, 291, 227, 230, 225, 357, 327, 81, + /* 1190 */ 323, 292, 269, 340, 349, 352, 291, 291, 353, 307, + /* 1200 */ 277, 291, 310, 311, 312, 313, 314, 315, 292, 317, + /* 1210 */ 287, 143, 320, 81, 291, 351, 324, 325, 352, 351, + /* 1220 */ 277, 352, 241, 351, 251, 289, 251, 288, 277, 265, + /* 1230 */ 307, 273, 248, 310, 311, 312, 313, 314, 315, 259, + /* 1240 */ 317, 251, 243, 320, 252, 299, 239, 324, 325, 263, + /* 1250 */ 269, 263, 303, 0, 263, 0, 72, 0, 277, 47, + /* 1260 */ 174, 47, 174, 47, 47, 0, 47, 47, 287, 0, + /* 1270 */ 174, 47, 291, 0, 47, 0, 47, 0, 81, 160, + /* 1280 */ 159, 241, 114, 156, 0, 0, 152, 151, 307, 0, + /* 1290 */ 0, 310, 311, 312, 313, 314, 315, 316, 317, 318, + /* 1300 */ 319, 0, 44, 0, 0, 0, 0, 0, 0, 269, + /* 1310 */ 0, 0, 0, 0, 0, 0, 0, 277, 0, 0, + /* 1320 */ 0, 0, 40, 0, 0, 0, 0, 287, 0, 0, + /* 1330 */ 0, 291, 0, 0, 0, 0, 241, 0, 40, 22, + /* 1340 */ 41, 14, 0, 0, 44, 14, 37, 307, 88, 47, + /* 1350 */ 310, 311, 312, 313, 314, 315, 0, 317, 0, 0, + /* 1360 */ 0, 0, 0, 0, 269, 0, 44, 0, 0, 0, + /* 1370 */ 0, 0, 277, 0, 38, 37, 37, 37, 90, 0, + /* 1380 */ 146, 37, 287, 161, 146, 143, 291, 37, 141, 241, + /* 1390 */ 45, 37, 45, 47, 354, 355, 47, 45, 47, 22, + /* 1400 */ 59, 37, 307, 0, 47, 310, 311, 312, 313, 314, + /* 1410 */ 315, 45, 317, 0, 19, 320, 22, 269, 22, 47, + /* 1420 */ 325, 47, 47, 47, 41, 277, 48, 47, 33, 41, + /* 1430 */ 0, 22, 0, 22, 0, 287, 22, 47, 47, 291, + /* 1440 */ 45, 20, 294, 0, 241, 47, 51, 52, 53, 54, + /* 1450 */ 55, 47, 0, 22, 0, 307, 241, 0, 310, 311, + /* 1460 */ 312, 313, 314, 315, 0, 317, 0, 81, 41, 41, + /* 1470 */ 37, 212, 269, 44, 82, 80, 41, 41, 83, 82, + /* 1480 */ 277, 81, 81, 81, 269, 44, 212, 82, 81, 41, + /* 1490 */ 287, 44, 277, 206, 291, 44, 41, 82, 212, 146, + /* 1500 */ 82, 82, 287, 41, 82, 47, 291, 47, 47, 41, + /* 1510 */ 307, 2, 117, 310, 311, 312, 313, 314, 315, 47, + /* 1520 */ 317, 47, 307, 81, 47, 310, 311, 312, 313, 314, + /* 1530 */ 315, 82, 317, 241, 44, 82, 44, 142, 22, 0, + /* 1540 */ 145, 82, 37, 144, 81, 44, 81, 141, 81, 22, + /* 1550 */ 81, 348, 82, 82, 81, 44, 81, 162, 22, 164, + /* 1560 */ 178, 269, 81, 81, 180, 81, 81, 47, 82, 277, + /* 1570 */ 355, 91, 47, 82, 81, 92, 47, 81, 47, 287, + /* 1580 */ 82, 81, 47, 291, 82, 81, 294, 47, 82, 241, + /* 1590 */ 93, 81, 105, 105, 105, 81, 81, 47, 81, 307, + /* 1600 */ 105, 47, 310, 311, 312, 313, 314, 315, 114, 317, + /* 1610 */ 22, 59, 47, 58, 41, 64, 79, 269, 47, 47, + /* 1620 */ 22, 47, 47, 47, 47, 277, 47, 64, 241, 47, + /* 1630 */ 47, 47, 47, 47, 0, 287, 47, 47, 47, 291, + /* 1640 */ 45, 37, 0, 47, 45, 37, 0, 47, 45, 37, + /* 1650 */ 0, 45, 47, 37, 0, 307, 269, 241, 310, 311, + /* 1660 */ 312, 313, 314, 315, 277, 317, 47, 319, 46, 0, + /* 1670 */ 0, 22, 21, 21, 287, 22, 20, 22, 291, 358, + /* 1680 */ 358, 294, 358, 358, 358, 269, 241, 358, 358, 358, + /* 1690 */ 358, 358, 358, 277, 307, 358, 358, 310, 311, 312, + /* 1700 */ 313, 314, 315, 287, 317, 358, 358, 291, 358, 358, + /* 1710 */ 294, 358, 358, 358, 269, 358, 358, 241, 358, 358, + /* 1720 */ 358, 358, 277, 307, 358, 358, 310, 311, 312, 313, + /* 1730 */ 314, 315, 287, 317, 358, 358, 291, 358, 358, 358, + /* 1740 */ 358, 358, 358, 358, 358, 269, 358, 358, 241, 358, + /* 1750 */ 358, 358, 307, 277, 358, 310, 311, 312, 313, 314, + /* 1760 */ 315, 358, 317, 287, 358, 358, 358, 291, 358, 358, + /* 1770 */ 358, 358, 358, 358, 358, 358, 269, 358, 358, 241, + /* 1780 */ 358, 358, 358, 307, 277, 358, 310, 311, 312, 313, + /* 1790 */ 314, 315, 358, 317, 287, 358, 358, 358, 291, 358, + /* 1800 */ 358, 358, 358, 358, 358, 358, 358, 269, 358, 358, + /* 1810 */ 358, 241, 358, 358, 307, 277, 358, 310, 311, 312, + /* 1820 */ 313, 314, 315, 358, 317, 287, 358, 358, 241, 291, + /* 1830 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 269, + /* 1840 */ 358, 358, 358, 358, 358, 307, 358, 277, 310, 311, + /* 1850 */ 312, 313, 314, 315, 358, 317, 269, 287, 358, 358, + /* 1860 */ 358, 291, 358, 358, 277, 358, 358, 241, 358, 358, + /* 1870 */ 358, 358, 358, 358, 287, 358, 358, 307, 291, 358, + /* 1880 */ 310, 311, 312, 313, 314, 315, 358, 317, 358, 358, + /* 1890 */ 358, 358, 358, 358, 307, 269, 358, 310, 311, 312, + /* 1900 */ 313, 314, 315, 277, 317, 358, 241, 358, 358, 358, + /* 1910 */ 358, 358, 358, 287, 358, 358, 358, 291, 358, 358, + /* 1920 */ 358, 358, 358, 241, 358, 358, 358, 358, 358, 358, + /* 1930 */ 358, 358, 358, 307, 269, 241, 310, 311, 312, 313, + /* 1940 */ 314, 315, 277, 317, 358, 358, 358, 358, 358, 358, + /* 1950 */ 358, 269, 287, 358, 358, 358, 291, 358, 358, 277, + /* 1960 */ 358, 358, 358, 269, 358, 358, 358, 358, 358, 287, + /* 1970 */ 358, 277, 307, 291, 241, 310, 311, 312, 313, 314, + /* 1980 */ 315, 287, 317, 358, 358, 291, 358, 241, 358, 307, + /* 1990 */ 358, 358, 310, 311, 312, 313, 314, 315, 358, 317, + /* 2000 */ 358, 307, 269, 358, 310, 311, 312, 313, 314, 315, + /* 2010 */ 277, 317, 358, 358, 358, 269, 358, 358, 358, 358, + /* 2020 */ 287, 358, 358, 277, 291, 358, 241, 358, 358, 358, + /* 2030 */ 358, 358, 358, 287, 358, 358, 358, 291, 358, 358, + /* 2040 */ 307, 358, 358, 310, 311, 312, 313, 314, 315, 358, + /* 2050 */ 317, 358, 358, 307, 269, 358, 310, 311, 312, 313, + /* 2060 */ 314, 315, 277, 317, 358, 358, 358, 358, 358, 358, + /* 2070 */ 358, 358, 287, 358, 358, 358, 291, 358, 358, 358, + /* 2080 */ 358, 241, 358, 358, 358, 358, 358, 358, 358, 358, + /* 2090 */ 241, 358, 307, 358, 358, 310, 311, 312, 313, 314, + /* 2100 */ 315, 358, 317, 358, 358, 358, 358, 358, 358, 269, + /* 2110 */ 358, 358, 358, 358, 358, 358, 358, 277, 269, 358, + /* 2120 */ 358, 358, 358, 358, 358, 358, 277, 287, 358, 358, + /* 2130 */ 358, 291, 358, 358, 358, 358, 287, 241, 358, 358, + /* 2140 */ 291, 358, 358, 358, 358, 358, 358, 307, 358, 358, + /* 2150 */ 310, 311, 312, 313, 314, 315, 307, 317, 358, 310, + /* 2160 */ 311, 312, 313, 314, 315, 269, 317, 358, 358, 358, + /* 2170 */ 358, 358, 358, 277, 358, 358, 358, 358, 358, 358, + /* 2180 */ 358, 358, 358, 287, 358, 358, 358, 291, 358, 358, + /* 2190 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, + /* 2200 */ 358, 358, 358, 307, 358, 358, 310, 311, 312, 313, + /* 2210 */ 314, 315, 358, 317, }; -#define YY_SHIFT_COUNT (610) +#define YY_SHIFT_COUNT (611) #define YY_SHIFT_MIN (0) -#define YY_SHIFT_MAX (1757) +#define YY_SHIFT_MAX (1670) static const unsigned short int yy_shift_ofst[] = { - /* 0 */ 768, 0, 0, 48, 234, 234, 234, 234, 255, 255, - /* 10 */ 234, 234, 441, 462, 648, 462, 462, 462, 462, 462, - /* 20 */ 462, 462, 462, 462, 462, 462, 462, 462, 462, 462, - /* 30 */ 462, 462, 462, 462, 462, 462, 462, 462, 254, 254, - /* 40 */ 54, 54, 54, 1188, 1188, 1188, 1188, 331, 508, 74, - /* 50 */ 4, 4, 7, 7, 76, 74, 74, 4, 4, 4, - /* 60 */ 4, 4, 4, 216, 4, 265, 371, 527, 265, 4, - /* 70 */ 4, 265, 4, 265, 265, 527, 265, 4, 447, 644, - /* 80 */ 14, 554, 554, 139, 192, 1453, 1453, 1453, 1453, 1453, - /* 90 */ 1453, 1453, 1453, 1453, 1453, 1453, 1453, 1453, 1453, 1453, - /* 100 */ 1453, 1453, 1453, 1453, 604, 229, 482, 482, 198, 5, - /* 110 */ 438, 438, 438, 764, 5, 772, 527, 265, 265, 527, - /* 120 */ 487, 468, 636, 636, 636, 636, 636, 636, 636, 440, - /* 130 */ 299, 222, 27, 486, 37, 346, 287, 456, 681, 674, - /* 140 */ 484, 769, 470, 652, 470, 390, 390, 390, 615, 773, - /* 150 */ 948, 963, 966, 864, 948, 948, 979, 886, 886, 948, - /* 160 */ 1014, 1014, 1020, 216, 527, 216, 1040, 1051, 216, 1040, - /* 170 */ 216, 772, 1066, 216, 216, 948, 216, 1014, 265, 265, - /* 180 */ 265, 265, 265, 265, 265, 265, 265, 265, 265, 948, - /* 190 */ 1014, 1043, 1020, 447, 967, 527, 447, 1040, 447, 772, - /* 200 */ 1066, 447, 1118, 924, 937, 1043, 924, 937, 1043, 1043, - /* 210 */ 265, 931, 938, 968, 970, 974, 772, 1159, 1145, 957, - /* 220 */ 971, 960, 957, 971, 957, 971, 1112, 937, 1043, 1043, - /* 230 */ 937, 1043, 1064, 772, 1066, 447, 487, 447, 772, 1146, - /* 240 */ 468, 948, 447, 1014, 2153, 2153, 2153, 2153, 2153, 2153, - /* 250 */ 2153, 2153, 71, 1425, 93, 453, 248, 587, 187, 63, - /* 260 */ 385, 391, 211, 570, 95, 95, 95, 95, 95, 95, - /* 270 */ 95, 95, 357, 2, 52, 492, 712, 655, 661, 661, - /* 280 */ 661, 661, 854, 501, 786, 788, 790, 792, 857, 863, - /* 290 */ 867, 862, 557, 677, 880, 881, 888, 900, 715, 749, - /* 300 */ 805, 891, 824, 892, 868, 893, 898, 928, 930, 951, - /* 310 */ 869, 879, 955, 956, 961, 965, 975, 976, 807, 242, - /* 320 */ 1261, 1262, 1192, 1265, 1227, 1107, 1237, 1239, 1240, 1114, - /* 330 */ 1288, 1245, 1246, 1119, 1294, 1249, 1297, 1251, 1300, 1254, - /* 340 */ 1304, 1224, 1144, 1147, 1193, 1151, 1312, 1314, 1161, 1163, - /* 350 */ 1318, 1319, 1278, 1329, 1332, 1333, 1334, 1336, 1337, 1338, - /* 360 */ 1339, 1340, 1341, 1342, 1343, 1344, 1347, 1348, 1349, 1350, - /* 370 */ 1351, 1324, 1354, 1366, 1369, 1371, 1372, 1373, 1352, 1375, - /* 380 */ 1376, 1377, 1382, 1383, 1385, 1346, 1359, 1356, 1381, 1355, - /* 390 */ 1384, 1360, 1402, 1365, 1368, 1407, 1408, 1409, 1379, 1410, - /* 400 */ 1412, 1380, 1413, 1361, 1419, 1421, 1378, 1389, 1386, 1422, - /* 410 */ 1394, 1398, 1390, 1426, 1400, 1411, 1392, 1430, 1414, 1415, - /* 420 */ 1396, 1457, 1459, 1462, 1463, 1391, 1395, 1418, 1447, 1467, - /* 430 */ 1427, 1435, 1437, 1439, 1431, 1432, 1440, 1449, 1450, 1498, - /* 440 */ 1477, 1501, 1481, 1456, 1506, 1485, 1464, 1509, 1488, 1513, - /* 450 */ 1492, 1495, 1518, 1374, 1472, 1521, 1362, 1500, 1399, 1387, - /* 460 */ 1524, 1526, 1527, 1448, 1491, 1393, 1490, 1494, 1330, 1460, - /* 470 */ 1505, 1465, 1451, 1468, 1469, 1466, 1511, 1510, 1514, 1474, - /* 480 */ 1512, 1363, 1475, 1478, 1517, 1357, 1522, 1520, 1480, 1533, - /* 490 */ 1364, 1497, 1528, 1529, 1534, 1535, 1536, 1537, 1497, 1578, - /* 500 */ 1405, 1545, 1507, 1523, 1530, 1543, 1525, 1532, 1544, 1570, - /* 510 */ 1420, 1538, 1540, 1542, 1539, 1546, 1461, 1547, 1603, 1572, - /* 520 */ 1473, 1549, 1519, 1564, 1574, 1551, 1553, 1555, 1593, 1558, - /* 530 */ 1531, 1567, 1569, 1579, 1559, 1568, 1605, 1573, 1575, 1606, - /* 540 */ 1577, 1580, 1608, 1582, 1583, 1609, 1585, 1556, 1565, 1581, - /* 550 */ 1584, 1638, 1576, 1599, 1601, 1617, 1602, 1586, 1637, 1663, - /* 560 */ 1566, 1629, 1643, 1627, 1613, 1652, 1647, 1648, 1649, 1650, - /* 570 */ 1662, 1677, 1664, 1665, 1646, 1431, 1666, 1432, 1667, 1670, - /* 580 */ 1671, 1672, 1673, 1674, 1722, 1676, 1681, 1690, 1728, 1683, - /* 590 */ 1686, 1695, 1733, 1688, 1692, 1702, 1740, 1694, 1697, 1706, - /* 600 */ 1744, 1698, 1701, 1748, 1757, 1745, 1747, 1749, 1751, 1753, - /* 610 */ 1746, + /* 0 */ 469, 0, 0, 48, 96, 96, 96, 96, 280, 280, + /* 10 */ 96, 96, 328, 376, 560, 376, 376, 376, 376, 376, + /* 20 */ 376, 376, 376, 376, 376, 376, 376, 376, 376, 376, + /* 30 */ 376, 376, 376, 376, 376, 376, 376, 376, 187, 187, + /* 40 */ 23, 23, 23, 846, 846, 846, 846, 46, 168, 68, + /* 50 */ 49, 49, 42, 42, 124, 68, 68, 49, 49, 49, + /* 60 */ 49, 49, 49, 35, 49, 49, 53, 77, 235, 53, + /* 70 */ 49, 49, 53, 49, 53, 53, 235, 53, 49, 290, + /* 80 */ 556, 62, 110, 110, 109, 468, 800, 800, 800, 800, + /* 90 */ 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, + /* 100 */ 800, 800, 800, 800, 800, 132, 224, 155, 155, 247, + /* 110 */ 584, 281, 281, 281, 762, 584, 249, 235, 53, 53, + /* 120 */ 235, 257, 481, 558, 558, 558, 558, 558, 558, 558, + /* 130 */ 1395, 676, 709, 583, 78, 365, 267, 399, 429, 829, + /* 140 */ 479, 486, 767, 668, 735, 668, 597, 597, 597, 692, + /* 150 */ 775, 1005, 983, 985, 889, 1005, 1005, 1008, 920, 920, + /* 160 */ 1005, 1042, 1042, 1052, 35, 235, 35, 1058, 1061, 35, + /* 170 */ 1058, 35, 249, 1072, 35, 35, 1005, 35, 1042, 53, + /* 180 */ 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, + /* 190 */ 1005, 1042, 1055, 1052, 290, 965, 235, 290, 1005, 1058, + /* 200 */ 290, 249, 1072, 290, 1123, 934, 938, 1055, 934, 938, + /* 210 */ 1055, 1055, 53, 944, 948, 960, 966, 968, 249, 1157, + /* 220 */ 1142, 957, 961, 955, 957, 961, 957, 961, 1108, 938, + /* 230 */ 1055, 1055, 938, 1055, 1068, 249, 1072, 290, 257, 290, + /* 240 */ 249, 1132, 481, 1005, 290, 1042, 2214, 2214, 2214, 2214, + /* 250 */ 2214, 2214, 2214, 862, 283, 294, 1038, 339, 605, 340, + /* 260 */ 14, 356, 721, 778, 431, 698, 698, 698, 698, 698, + /* 270 */ 698, 698, 698, 325, 250, 324, 633, 476, 537, 537, + /* 280 */ 537, 537, 441, 726, 791, 792, 807, 823, 882, 926, + /* 290 */ 941, 924, 729, 879, 902, 909, 945, 760, 498, 321, + /* 300 */ 914, 661, 927, 925, 929, 930, 931, 932, 933, 904, + /* 310 */ 917, 935, 940, 952, 956, 962, 963, 884, 976, 1253, + /* 320 */ 1255, 1184, 1257, 1212, 1086, 1214, 1216, 1217, 1088, 1265, + /* 330 */ 1219, 1220, 1096, 1269, 1224, 1273, 1227, 1275, 1229, 1277, + /* 340 */ 1197, 1119, 1121, 1168, 1127, 1284, 1285, 1134, 1136, 1289, + /* 350 */ 1290, 1258, 1301, 1303, 1304, 1305, 1306, 1307, 1308, 1310, + /* 360 */ 1311, 1312, 1313, 1314, 1315, 1316, 1318, 1319, 1320, 1321, + /* 370 */ 1282, 1323, 1324, 1325, 1326, 1328, 1329, 1317, 1330, 1332, + /* 380 */ 1333, 1334, 1335, 1337, 1298, 1309, 1299, 1327, 1300, 1331, + /* 390 */ 1322, 1342, 1336, 1338, 1343, 1356, 1358, 1339, 1359, 1360, + /* 400 */ 1340, 1361, 1341, 1362, 1363, 1302, 1345, 1344, 1365, 1346, + /* 410 */ 1347, 1350, 1367, 1351, 1352, 1354, 1368, 1357, 1366, 1364, + /* 420 */ 1369, 1370, 1371, 1373, 1288, 1260, 1349, 1377, 1379, 1372, + /* 430 */ 1374, 1375, 1376, 1383, 1388, 1380, 1390, 1391, 1403, 1394, + /* 440 */ 1413, 1396, 1378, 1430, 1409, 1398, 1432, 1411, 1434, 1414, + /* 450 */ 1421, 1443, 1234, 1404, 1452, 1222, 1431, 1238, 1242, 1454, + /* 460 */ 1457, 1464, 1353, 1466, 1386, 1433, 1247, 1427, 1428, 1259, + /* 470 */ 1392, 1435, 1397, 1400, 1401, 1402, 1405, 1436, 1429, 1441, + /* 480 */ 1407, 1448, 1274, 1415, 1418, 1447, 1287, 1455, 1451, 1419, + /* 490 */ 1462, 1286, 1422, 1458, 1460, 1461, 1472, 1474, 1477, 1422, + /* 500 */ 1509, 1382, 1468, 1449, 1442, 1453, 1490, 1463, 1465, 1492, + /* 510 */ 1516, 1384, 1467, 1459, 1470, 1469, 1473, 1399, 1475, 1539, + /* 520 */ 1505, 1406, 1481, 1480, 1501, 1511, 1482, 1471, 1484, 1527, + /* 530 */ 1485, 1483, 1486, 1520, 1525, 1493, 1491, 1529, 1496, 1498, + /* 540 */ 1531, 1500, 1502, 1535, 1504, 1506, 1540, 1510, 1487, 1488, + /* 550 */ 1489, 1495, 1536, 1497, 1514, 1515, 1550, 1517, 1494, 1554, + /* 560 */ 1588, 1552, 1555, 1565, 1551, 1537, 1573, 1571, 1572, 1574, + /* 570 */ 1575, 1576, 1598, 1577, 1579, 1563, 1383, 1582, 1388, 1583, + /* 580 */ 1584, 1585, 1586, 1589, 1590, 1634, 1591, 1595, 1604, 1642, + /* 590 */ 1596, 1599, 1608, 1646, 1600, 1603, 1612, 1650, 1605, 1606, + /* 600 */ 1616, 1654, 1619, 1622, 1669, 1670, 1649, 1651, 1653, 1655, + /* 610 */ 1652, 1656, }; -#define YY_REDUCE_COUNT (251) -#define YY_REDUCE_MIN (-320) -#define YY_REDUCE_MAX (1796) +#define YY_REDUCE_COUNT (252) +#define YY_REDUCE_MIN (-335) +#define YY_REDUCE_MAX (1896) static const short yy_reduce_ofst[] = { - /* 0 */ 259, -226, 236, 61, 577, 638, 671, 752, 784, 835, - /* 10 */ 29, 850, 901, 953, 736, 962, 1010, 1042, 1074, 1122, - /* 20 */ 1135, 1175, 1223, 1280, 1328, 1358, 1388, 1436, 1445, 1493, - /* 30 */ 1541, 1552, 1571, 1630, 1639, 1699, 1708, 1756, 1760, 1796, - /* 40 */ -20, 261, 269, -272, 207, 204, 298, 182, 449, 512, - /* 50 */ -244, -164, -246, -241, -320, -178, -76, -196, 55, 59, - /* 60 */ 132, 239, 419, -222, 422, -227, -256, -139, -1, 534, - /* 70 */ 535, 84, 537, 310, 102, 179, 448, 568, 343, -75, - /* 80 */ -315, -315, -315, -228, -49, 60, 90, 123, 194, 213, - /* 90 */ 219, 235, 317, 380, 472, 507, 559, 565, 566, 567, - /* 100 */ 569, 572, 576, 579, -154, -152, -216, -68, 33, 138, - /* 110 */ 75, 406, 414, -3, 176, -127, 250, 88, 439, 325, - /* 120 */ 202, 111, 302, 526, 555, 578, 583, 612, 631, 605, - /* 130 */ 663, 653, 571, 574, 628, 592, 666, 666, 689, 690, - /* 140 */ 662, 647, 635, 635, 635, 629, 637, 650, 665, 666, - /* 150 */ 751, 703, 757, 717, 771, 774, 735, 743, 745, 782, - /* 160 */ 791, 794, 737, 789, 759, 806, 777, 776, 827, 787, - /* 170 */ 830, 808, 798, 834, 836, 842, 840, 851, 832, 837, - /* 180 */ 838, 839, 841, 844, 845, 846, 847, 848, 849, 855, - /* 190 */ 866, 820, 817, 872, 822, 852, 874, 833, 878, 856, - /* 200 */ 843, 884, 859, 797, 853, 865, 810, 875, 882, 883, - /* 210 */ 666, 811, 816, 860, 870, 635, 905, 877, 876, 858, - /* 220 */ 871, 829, 873, 885, 889, 894, 903, 908, 902, 904, - /* 230 */ 910, 906, 917, 947, 919, 977, 964, 981, 958, 972, - /* 240 */ 982, 986, 985, 995, 943, 944, 959, 984, 989, 991, - /* 250 */ 1005, 1019, + /* 0 */ 142, 489, 520, 574, -224, 90, 675, 739, 798, 845, + /* 10 */ 892, 923, 981, 1040, 1095, 1148, 1203, 1215, 1292, 1348, + /* 20 */ 1387, 1416, 1445, 1476, 1507, 1538, 1570, 1587, 1626, 1665, + /* 30 */ 1682, 1694, 1733, 1746, 1785, 1840, 1849, 1896, -183, 279, + /* 40 */ -116, 169, 576, -268, -266, -235, 323, -294, -177, -125, + /* 50 */ -103, 97, -237, -213, -335, -301, -299, 69, 131, 158, + /* 60 */ 173, 200, 329, -209, 343, 373, -171, -170, 100, 82, + /* 70 */ 480, 511, 213, 569, 104, 309, 99, 151, 606, -240, + /* 80 */ -85, -242, -242, -242, -221, -254, -126, 12, 143, 212, + /* 90 */ 244, 297, 360, 382, 408, 482, 484, 488, 519, 545, + /* 100 */ 557, 564, 579, 587, 611, -23, 22, -90, -39, 372, + /* 110 */ 415, -112, 305, 424, 512, 471, -104, -176, 572, 357, + /* 120 */ 478, 561, 180, -255, 223, 314, 322, 548, 593, 645, + /* 130 */ 549, 401, 510, 501, 570, 617, 618, 708, 708, 720, + /* 140 */ 734, 714, 689, 671, 671, 671, 657, 669, 670, 684, + /* 150 */ 708, 779, 724, 786, 749, 785, 810, 770, 783, 787, + /* 160 */ 813, 825, 826, 771, 824, 789, 827, 784, 790, 831, + /* 170 */ 795, 838, 805, 808, 842, 844, 850, 847, 856, 832, + /* 180 */ 833, 834, 835, 837, 848, 851, 854, 855, 857, 858, + /* 190 */ 859, 873, 839, 836, 874, 828, 852, 880, 887, 849, + /* 200 */ 886, 863, 860, 891, 840, 799, 871, 875, 819, 876, + /* 210 */ 881, 883, 708, 803, 812, 853, 841, 671, 896, 870, + /* 220 */ 861, 843, 864, 830, 866, 868, 869, 872, 867, 899, + /* 230 */ 905, 906, 916, 910, 936, 943, 939, 973, 964, 975, + /* 240 */ 951, 958, 980, 984, 990, 999, 946, 949, 986, 988, + /* 250 */ 991, 992, 1007, }; static const YYACTIONTYPE yy_default[] = { - /* 0 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 10 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 20 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 30 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 40 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 50 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 60 */ 1356, 1356, 1356, 1425, 1356, 1356, 1356, 1356, 1356, 1356, - /* 70 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1423, 1564, - /* 80 */ 1356, 1731, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 90 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 100 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1425, 1356, - /* 110 */ 1742, 1742, 1742, 1423, 1356, 1356, 1356, 1356, 1356, 1356, - /* 120 */ 1519, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1603, - /* 130 */ 1356, 1356, 1808, 1356, 1609, 1766, 1356, 1356, 1356, 1356, - /* 140 */ 1472, 1758, 1734, 1748, 1735, 1793, 1793, 1793, 1751, 1356, - /* 150 */ 1356, 1356, 1356, 1595, 1356, 1356, 1569, 1566, 1566, 1356, - /* 160 */ 1356, 1356, 1356, 1425, 1356, 1425, 1356, 1356, 1425, 1356, - /* 170 */ 1425, 1356, 1356, 1425, 1425, 1356, 1425, 1356, 1356, 1356, - /* 180 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 190 */ 1356, 1356, 1356, 1423, 1605, 1356, 1423, 1356, 1423, 1356, - /* 200 */ 1356, 1423, 1356, 1773, 1771, 1356, 1773, 1771, 1356, 1356, - /* 210 */ 1356, 1785, 1781, 1764, 1762, 1748, 1356, 1356, 1356, 1799, - /* 220 */ 1795, 1811, 1799, 1795, 1799, 1795, 1356, 1771, 1356, 1356, - /* 230 */ 1771, 1356, 1577, 1356, 1356, 1423, 1356, 1423, 1356, 1488, - /* 240 */ 1356, 1356, 1423, 1356, 1597, 1611, 1587, 1522, 1522, 1522, - /* 250 */ 1426, 1361, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 260 */ 1356, 1356, 1356, 1484, 1675, 1784, 1783, 1707, 1706, 1705, - /* 270 */ 1703, 1674, 1356, 1356, 1356, 1356, 1356, 1356, 1668, 1669, - /* 280 */ 1667, 1666, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 290 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1732, 1356, 1796, - /* 300 */ 1800, 1356, 1356, 1356, 1651, 1356, 1356, 1356, 1356, 1356, - /* 310 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 320 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 330 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 340 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 350 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 360 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 370 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 380 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1390, 1356, 1356, - /* 390 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 400 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 410 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 420 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 430 */ 1356, 1356, 1356, 1356, 1453, 1452, 1356, 1356, 1356, 1356, - /* 440 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 450 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 460 */ 1356, 1356, 1356, 1356, 1356, 1356, 1755, 1765, 1356, 1356, - /* 470 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1651, 1356, - /* 480 */ 1782, 1356, 1741, 1737, 1356, 1356, 1733, 1356, 1356, 1794, - /* 490 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1727, - /* 500 */ 1356, 1700, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 510 */ 1662, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 520 */ 1356, 1356, 1356, 1650, 1356, 1691, 1356, 1356, 1356, 1356, - /* 530 */ 1356, 1356, 1356, 1356, 1516, 1356, 1356, 1356, 1356, 1356, - /* 540 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1501, 1499, 1498, - /* 550 */ 1497, 1356, 1494, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 560 */ 1356, 1356, 1356, 1356, 1356, 1445, 1356, 1356, 1356, 1356, - /* 570 */ 1356, 1356, 1356, 1356, 1356, 1436, 1356, 1435, 1356, 1356, - /* 580 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 590 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 600 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 610 */ 1356, + /* 0 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 10 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 20 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 30 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 40 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 50 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 60 */ 1351, 1351, 1351, 1420, 1351, 1351, 1351, 1351, 1351, 1351, + /* 70 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1418, + /* 80 */ 1559, 1351, 1723, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 90 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 100 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1420, + /* 110 */ 1351, 1734, 1734, 1734, 1418, 1351, 1351, 1351, 1351, 1351, + /* 120 */ 1351, 1514, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 130 */ 1595, 1351, 1351, 1800, 1351, 1601, 1758, 1351, 1351, 1351, + /* 140 */ 1351, 1467, 1750, 1726, 1740, 1727, 1785, 1785, 1785, 1743, + /* 150 */ 1351, 1351, 1351, 1351, 1587, 1351, 1351, 1564, 1561, 1561, + /* 160 */ 1351, 1351, 1351, 1351, 1420, 1351, 1420, 1351, 1351, 1420, + /* 170 */ 1351, 1420, 1351, 1351, 1420, 1420, 1351, 1420, 1351, 1351, + /* 180 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 190 */ 1351, 1351, 1351, 1351, 1418, 1597, 1351, 1418, 1351, 1351, + /* 200 */ 1418, 1351, 1351, 1418, 1351, 1765, 1763, 1351, 1765, 1763, + /* 210 */ 1351, 1351, 1351, 1777, 1773, 1756, 1754, 1740, 1351, 1351, + /* 220 */ 1351, 1791, 1787, 1803, 1791, 1787, 1791, 1787, 1351, 1763, + /* 230 */ 1351, 1351, 1763, 1351, 1572, 1351, 1351, 1418, 1351, 1418, + /* 240 */ 1351, 1483, 1351, 1351, 1418, 1351, 1589, 1603, 1517, 1517, + /* 250 */ 1517, 1421, 1356, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 260 */ 1351, 1351, 1351, 1351, 1479, 1667, 1776, 1775, 1699, 1698, + /* 270 */ 1697, 1695, 1666, 1351, 1351, 1351, 1351, 1351, 1660, 1661, + /* 280 */ 1659, 1658, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 290 */ 1351, 1351, 1351, 1351, 1351, 1351, 1724, 1351, 1788, 1792, + /* 300 */ 1351, 1351, 1351, 1643, 1351, 1351, 1351, 1351, 1351, 1351, + /* 310 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 320 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 330 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 340 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 350 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 360 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 370 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 380 */ 1351, 1351, 1351, 1351, 1351, 1351, 1385, 1351, 1351, 1351, + /* 390 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 400 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 410 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 420 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 430 */ 1351, 1351, 1351, 1448, 1447, 1351, 1351, 1351, 1351, 1351, + /* 440 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 450 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 460 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1747, 1757, 1351, + /* 470 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1643, + /* 480 */ 1351, 1774, 1351, 1733, 1729, 1351, 1351, 1725, 1351, 1351, + /* 490 */ 1786, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 500 */ 1719, 1351, 1692, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 510 */ 1351, 1654, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 520 */ 1351, 1351, 1351, 1351, 1642, 1351, 1683, 1351, 1351, 1351, + /* 530 */ 1351, 1351, 1351, 1351, 1351, 1511, 1351, 1351, 1351, 1351, + /* 540 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1496, 1494, + /* 550 */ 1493, 1492, 1351, 1489, 1351, 1351, 1351, 1351, 1351, 1351, + /* 560 */ 1351, 1351, 1351, 1351, 1351, 1351, 1440, 1351, 1351, 1351, + /* 570 */ 1351, 1351, 1351, 1351, 1351, 1351, 1431, 1351, 1430, 1351, + /* 580 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 590 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 600 */ 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, 1351, + /* 610 */ 1351, 1351, }; /********** End of lemon-generated parsing tables *****************************/ @@ -976,8 +988,6 @@ static const YYCODETYPE yyFallback[] = { 0, /* TOPIC => nothing */ 0, /* AS => nothing */ 0, /* CGROUP => nothing */ - 0, /* WITH => nothing */ - 0, /* SCHEMA => nothing */ 0, /* DESC => nothing */ 0, /* DESCRIBE => nothing */ 0, /* RESET => nothing */ @@ -1062,12 +1072,12 @@ static const YYCODETYPE yyFallback[] = { 0, /* ASC => nothing */ 0, /* NULLS => nothing */ 0, /* ID => nothing */ - 233, /* NK_BITNOT => ID */ - 233, /* INSERT => ID */ - 233, /* VALUES => ID */ - 233, /* IMPORT => ID */ - 233, /* NK_SEMI => ID */ - 233, /* FILE => ID */ + 231, /* NK_BITNOT => ID */ + 231, /* INSERT => ID */ + 231, /* VALUES => ID */ + 231, /* IMPORT => ID */ + 231, /* NK_SEMI => ID */ + 231, /* FILE => ID */ }; #endif /* YYFALLBACK */ @@ -1303,219 +1313,216 @@ static const char *const yyTokenName[] = { /* 145 */ "TOPIC", /* 146 */ "AS", /* 147 */ "CGROUP", - /* 148 */ "WITH", - /* 149 */ "SCHEMA", - /* 150 */ "DESC", - /* 151 */ "DESCRIBE", - /* 152 */ "RESET", - /* 153 */ "QUERY", - /* 154 */ "CACHE", - /* 155 */ "EXPLAIN", - /* 156 */ "ANALYZE", - /* 157 */ "VERBOSE", - /* 158 */ "NK_BOOL", - /* 159 */ "RATIO", - /* 160 */ "COMPACT", - /* 161 */ "VNODES", - /* 162 */ "IN", - /* 163 */ "OUTPUTTYPE", - /* 164 */ "AGGREGATE", - /* 165 */ "BUFSIZE", - /* 166 */ "STREAM", - /* 167 */ "INTO", - /* 168 */ "TRIGGER", - /* 169 */ "AT_ONCE", - /* 170 */ "WINDOW_CLOSE", - /* 171 */ "WATERMARK", - /* 172 */ "KILL", - /* 173 */ "CONNECTION", - /* 174 */ "TRANSACTION", - /* 175 */ "MERGE", - /* 176 */ "VGROUP", - /* 177 */ "REDISTRIBUTE", - /* 178 */ "SPLIT", - /* 179 */ "SYNCDB", - /* 180 */ "NULL", - /* 181 */ "NK_QUESTION", - /* 182 */ "NK_ARROW", - /* 183 */ "ROWTS", - /* 184 */ "TBNAME", - /* 185 */ "QSTARTTS", - /* 186 */ "QENDTS", - /* 187 */ "WSTARTTS", - /* 188 */ "WENDTS", - /* 189 */ "WDURATION", - /* 190 */ "CAST", - /* 191 */ "NOW", - /* 192 */ "TODAY", - /* 193 */ "TIMEZONE", - /* 194 */ "COUNT", - /* 195 */ "FIRST", - /* 196 */ "LAST", - /* 197 */ "LAST_ROW", - /* 198 */ "BETWEEN", - /* 199 */ "IS", - /* 200 */ "NK_LT", - /* 201 */ "NK_GT", - /* 202 */ "NK_LE", - /* 203 */ "NK_GE", - /* 204 */ "NK_NE", - /* 205 */ "MATCH", - /* 206 */ "NMATCH", - /* 207 */ "CONTAINS", - /* 208 */ "JOIN", - /* 209 */ "INNER", - /* 210 */ "SELECT", - /* 211 */ "DISTINCT", - /* 212 */ "WHERE", - /* 213 */ "PARTITION", - /* 214 */ "BY", - /* 215 */ "SESSION", - /* 216 */ "STATE_WINDOW", - /* 217 */ "SLIDING", - /* 218 */ "FILL", - /* 219 */ "VALUE", - /* 220 */ "NONE", - /* 221 */ "PREV", - /* 222 */ "LINEAR", - /* 223 */ "NEXT", - /* 224 */ "GROUP", - /* 225 */ "HAVING", - /* 226 */ "ORDER", - /* 227 */ "SLIMIT", - /* 228 */ "SOFFSET", - /* 229 */ "LIMIT", - /* 230 */ "OFFSET", - /* 231 */ "ASC", - /* 232 */ "NULLS", - /* 233 */ "ID", - /* 234 */ "NK_BITNOT", - /* 235 */ "INSERT", - /* 236 */ "VALUES", - /* 237 */ "IMPORT", - /* 238 */ "NK_SEMI", - /* 239 */ "FILE", - /* 240 */ "cmd", - /* 241 */ "account_options", - /* 242 */ "alter_account_options", - /* 243 */ "literal", - /* 244 */ "alter_account_option", - /* 245 */ "user_name", - /* 246 */ "privileges", - /* 247 */ "priv_level", - /* 248 */ "priv_type_list", - /* 249 */ "priv_type", - /* 250 */ "db_name", - /* 251 */ "dnode_endpoint", - /* 252 */ "dnode_host_name", - /* 253 */ "not_exists_opt", - /* 254 */ "db_options", - /* 255 */ "exists_opt", - /* 256 */ "alter_db_options", - /* 257 */ "integer_list", - /* 258 */ "variable_list", - /* 259 */ "retention_list", - /* 260 */ "alter_db_option", - /* 261 */ "retention", - /* 262 */ "full_table_name", - /* 263 */ "column_def_list", - /* 264 */ "tags_def_opt", - /* 265 */ "table_options", - /* 266 */ "multi_create_clause", - /* 267 */ "tags_def", - /* 268 */ "multi_drop_clause", - /* 269 */ "alter_table_clause", - /* 270 */ "alter_table_options", - /* 271 */ "column_name", - /* 272 */ "type_name", - /* 273 */ "signed_literal", - /* 274 */ "create_subtable_clause", - /* 275 */ "specific_tags_opt", - /* 276 */ "literal_list", - /* 277 */ "drop_table_clause", - /* 278 */ "col_name_list", - /* 279 */ "table_name", - /* 280 */ "column_def", - /* 281 */ "func_name_list", - /* 282 */ "alter_table_option", - /* 283 */ "col_name", - /* 284 */ "db_name_cond_opt", - /* 285 */ "like_pattern_opt", - /* 286 */ "table_name_cond", - /* 287 */ "from_db_opt", - /* 288 */ "func_name", - /* 289 */ "function_name", - /* 290 */ "index_name", - /* 291 */ "index_options", - /* 292 */ "func_list", - /* 293 */ "duration_literal", - /* 294 */ "sliding_opt", - /* 295 */ "func", - /* 296 */ "expression_list", - /* 297 */ "topic_name", - /* 298 */ "topic_options", - /* 299 */ "query_expression", - /* 300 */ "cgroup_name", - /* 301 */ "analyze_opt", - /* 302 */ "explain_options", - /* 303 */ "agg_func_opt", - /* 304 */ "bufsize_opt", - /* 305 */ "stream_name", - /* 306 */ "stream_options", - /* 307 */ "into_opt", - /* 308 */ "dnode_list", - /* 309 */ "signed", - /* 310 */ "literal_func", - /* 311 */ "table_alias", - /* 312 */ "column_alias", - /* 313 */ "expression", - /* 314 */ "pseudo_column", - /* 315 */ "column_reference", - /* 316 */ "function_expression", - /* 317 */ "subquery", - /* 318 */ "star_func", - /* 319 */ "star_func_para_list", - /* 320 */ "noarg_func", - /* 321 */ "other_para_list", - /* 322 */ "star_func_para", - /* 323 */ "predicate", - /* 324 */ "compare_op", - /* 325 */ "in_op", - /* 326 */ "in_predicate_value", - /* 327 */ "boolean_value_expression", - /* 328 */ "boolean_primary", - /* 329 */ "common_expression", - /* 330 */ "from_clause", - /* 331 */ "table_reference_list", - /* 332 */ "table_reference", - /* 333 */ "table_primary", - /* 334 */ "joined_table", - /* 335 */ "alias_opt", - /* 336 */ "parenthesized_joined_table", - /* 337 */ "join_type", - /* 338 */ "search_condition", - /* 339 */ "query_specification", - /* 340 */ "set_quantifier_opt", - /* 341 */ "select_list", - /* 342 */ "where_clause_opt", - /* 343 */ "partition_by_clause_opt", - /* 344 */ "twindow_clause_opt", - /* 345 */ "group_by_clause_opt", - /* 346 */ "having_clause_opt", - /* 347 */ "select_sublist", - /* 348 */ "select_item", - /* 349 */ "fill_opt", - /* 350 */ "fill_mode", - /* 351 */ "group_by_list", - /* 352 */ "query_expression_body", - /* 353 */ "order_by_clause_opt", - /* 354 */ "slimit_clause_opt", - /* 355 */ "limit_clause_opt", - /* 356 */ "query_primary", - /* 357 */ "sort_specification_list", - /* 358 */ "sort_specification", - /* 359 */ "ordering_specification_opt", - /* 360 */ "null_ordering_opt", + /* 148 */ "DESC", + /* 149 */ "DESCRIBE", + /* 150 */ "RESET", + /* 151 */ "QUERY", + /* 152 */ "CACHE", + /* 153 */ "EXPLAIN", + /* 154 */ "ANALYZE", + /* 155 */ "VERBOSE", + /* 156 */ "NK_BOOL", + /* 157 */ "RATIO", + /* 158 */ "COMPACT", + /* 159 */ "VNODES", + /* 160 */ "IN", + /* 161 */ "OUTPUTTYPE", + /* 162 */ "AGGREGATE", + /* 163 */ "BUFSIZE", + /* 164 */ "STREAM", + /* 165 */ "INTO", + /* 166 */ "TRIGGER", + /* 167 */ "AT_ONCE", + /* 168 */ "WINDOW_CLOSE", + /* 169 */ "WATERMARK", + /* 170 */ "KILL", + /* 171 */ "CONNECTION", + /* 172 */ "TRANSACTION", + /* 173 */ "MERGE", + /* 174 */ "VGROUP", + /* 175 */ "REDISTRIBUTE", + /* 176 */ "SPLIT", + /* 177 */ "SYNCDB", + /* 178 */ "NULL", + /* 179 */ "NK_QUESTION", + /* 180 */ "NK_ARROW", + /* 181 */ "ROWTS", + /* 182 */ "TBNAME", + /* 183 */ "QSTARTTS", + /* 184 */ "QENDTS", + /* 185 */ "WSTARTTS", + /* 186 */ "WENDTS", + /* 187 */ "WDURATION", + /* 188 */ "CAST", + /* 189 */ "NOW", + /* 190 */ "TODAY", + /* 191 */ "TIMEZONE", + /* 192 */ "COUNT", + /* 193 */ "FIRST", + /* 194 */ "LAST", + /* 195 */ "LAST_ROW", + /* 196 */ "BETWEEN", + /* 197 */ "IS", + /* 198 */ "NK_LT", + /* 199 */ "NK_GT", + /* 200 */ "NK_LE", + /* 201 */ "NK_GE", + /* 202 */ "NK_NE", + /* 203 */ "MATCH", + /* 204 */ "NMATCH", + /* 205 */ "CONTAINS", + /* 206 */ "JOIN", + /* 207 */ "INNER", + /* 208 */ "SELECT", + /* 209 */ "DISTINCT", + /* 210 */ "WHERE", + /* 211 */ "PARTITION", + /* 212 */ "BY", + /* 213 */ "SESSION", + /* 214 */ "STATE_WINDOW", + /* 215 */ "SLIDING", + /* 216 */ "FILL", + /* 217 */ "VALUE", + /* 218 */ "NONE", + /* 219 */ "PREV", + /* 220 */ "LINEAR", + /* 221 */ "NEXT", + /* 222 */ "GROUP", + /* 223 */ "HAVING", + /* 224 */ "ORDER", + /* 225 */ "SLIMIT", + /* 226 */ "SOFFSET", + /* 227 */ "LIMIT", + /* 228 */ "OFFSET", + /* 229 */ "ASC", + /* 230 */ "NULLS", + /* 231 */ "ID", + /* 232 */ "NK_BITNOT", + /* 233 */ "INSERT", + /* 234 */ "VALUES", + /* 235 */ "IMPORT", + /* 236 */ "NK_SEMI", + /* 237 */ "FILE", + /* 238 */ "cmd", + /* 239 */ "account_options", + /* 240 */ "alter_account_options", + /* 241 */ "literal", + /* 242 */ "alter_account_option", + /* 243 */ "user_name", + /* 244 */ "privileges", + /* 245 */ "priv_level", + /* 246 */ "priv_type_list", + /* 247 */ "priv_type", + /* 248 */ "db_name", + /* 249 */ "dnode_endpoint", + /* 250 */ "dnode_host_name", + /* 251 */ "not_exists_opt", + /* 252 */ "db_options", + /* 253 */ "exists_opt", + /* 254 */ "alter_db_options", + /* 255 */ "integer_list", + /* 256 */ "variable_list", + /* 257 */ "retention_list", + /* 258 */ "alter_db_option", + /* 259 */ "retention", + /* 260 */ "full_table_name", + /* 261 */ "column_def_list", + /* 262 */ "tags_def_opt", + /* 263 */ "table_options", + /* 264 */ "multi_create_clause", + /* 265 */ "tags_def", + /* 266 */ "multi_drop_clause", + /* 267 */ "alter_table_clause", + /* 268 */ "alter_table_options", + /* 269 */ "column_name", + /* 270 */ "type_name", + /* 271 */ "signed_literal", + /* 272 */ "create_subtable_clause", + /* 273 */ "specific_tags_opt", + /* 274 */ "literal_list", + /* 275 */ "drop_table_clause", + /* 276 */ "col_name_list", + /* 277 */ "table_name", + /* 278 */ "column_def", + /* 279 */ "func_name_list", + /* 280 */ "alter_table_option", + /* 281 */ "col_name", + /* 282 */ "db_name_cond_opt", + /* 283 */ "like_pattern_opt", + /* 284 */ "table_name_cond", + /* 285 */ "from_db_opt", + /* 286 */ "func_name", + /* 287 */ "function_name", + /* 288 */ "index_name", + /* 289 */ "index_options", + /* 290 */ "func_list", + /* 291 */ "duration_literal", + /* 292 */ "sliding_opt", + /* 293 */ "func", + /* 294 */ "expression_list", + /* 295 */ "topic_name", + /* 296 */ "query_expression", + /* 297 */ "cgroup_name", + /* 298 */ "analyze_opt", + /* 299 */ "explain_options", + /* 300 */ "agg_func_opt", + /* 301 */ "bufsize_opt", + /* 302 */ "stream_name", + /* 303 */ "stream_options", + /* 304 */ "into_opt", + /* 305 */ "dnode_list", + /* 306 */ "signed", + /* 307 */ "literal_func", + /* 308 */ "table_alias", + /* 309 */ "column_alias", + /* 310 */ "expression", + /* 311 */ "pseudo_column", + /* 312 */ "column_reference", + /* 313 */ "function_expression", + /* 314 */ "subquery", + /* 315 */ "star_func", + /* 316 */ "star_func_para_list", + /* 317 */ "noarg_func", + /* 318 */ "other_para_list", + /* 319 */ "star_func_para", + /* 320 */ "predicate", + /* 321 */ "compare_op", + /* 322 */ "in_op", + /* 323 */ "in_predicate_value", + /* 324 */ "boolean_value_expression", + /* 325 */ "boolean_primary", + /* 326 */ "common_expression", + /* 327 */ "from_clause", + /* 328 */ "table_reference_list", + /* 329 */ "table_reference", + /* 330 */ "table_primary", + /* 331 */ "joined_table", + /* 332 */ "alias_opt", + /* 333 */ "parenthesized_joined_table", + /* 334 */ "join_type", + /* 335 */ "search_condition", + /* 336 */ "query_specification", + /* 337 */ "set_quantifier_opt", + /* 338 */ "select_list", + /* 339 */ "where_clause_opt", + /* 340 */ "partition_by_clause_opt", + /* 341 */ "twindow_clause_opt", + /* 342 */ "group_by_clause_opt", + /* 343 */ "having_clause_opt", + /* 344 */ "select_sublist", + /* 345 */ "select_item", + /* 346 */ "fill_opt", + /* 347 */ "fill_mode", + /* 348 */ "group_by_list", + /* 349 */ "query_expression_body", + /* 350 */ "order_by_clause_opt", + /* 351 */ "slimit_clause_opt", + /* 352 */ "limit_clause_opt", + /* 353 */ "query_primary", + /* 354 */ "sort_specification_list", + /* 355 */ "sort_specification", + /* 356 */ "ordering_specification_opt", + /* 357 */ "null_ordering_opt", }; #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */ @@ -1747,237 +1754,234 @@ static const char *const yyRuleName[] = { /* 221 */ "func_list ::= func", /* 222 */ "func_list ::= func_list NK_COMMA func", /* 223 */ "func ::= function_name NK_LP expression_list NK_RP", - /* 224 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS query_expression", - /* 225 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS db_name", - /* 226 */ "cmd ::= DROP TOPIC exists_opt topic_name", - /* 227 */ "cmd ::= DROP CGROUP exists_opt cgroup_name ON topic_name", - /* 228 */ "topic_options ::=", - /* 229 */ "topic_options ::= topic_options WITH TABLE", - /* 230 */ "topic_options ::= topic_options WITH SCHEMA", - /* 231 */ "topic_options ::= topic_options WITH TAG", - /* 232 */ "cmd ::= DESC full_table_name", - /* 233 */ "cmd ::= DESCRIBE full_table_name", - /* 234 */ "cmd ::= RESET QUERY CACHE", - /* 235 */ "cmd ::= EXPLAIN analyze_opt explain_options query_expression", - /* 236 */ "analyze_opt ::=", - /* 237 */ "analyze_opt ::= ANALYZE", - /* 238 */ "explain_options ::=", - /* 239 */ "explain_options ::= explain_options VERBOSE NK_BOOL", - /* 240 */ "explain_options ::= explain_options RATIO NK_FLOAT", - /* 241 */ "cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP", - /* 242 */ "cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt", - /* 243 */ "cmd ::= DROP FUNCTION exists_opt function_name", - /* 244 */ "agg_func_opt ::=", - /* 245 */ "agg_func_opt ::= AGGREGATE", - /* 246 */ "bufsize_opt ::=", - /* 247 */ "bufsize_opt ::= BUFSIZE NK_INTEGER", - /* 248 */ "cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression", - /* 249 */ "cmd ::= DROP STREAM exists_opt stream_name", - /* 250 */ "into_opt ::=", - /* 251 */ "into_opt ::= INTO full_table_name", - /* 252 */ "stream_options ::=", - /* 253 */ "stream_options ::= stream_options TRIGGER AT_ONCE", - /* 254 */ "stream_options ::= stream_options TRIGGER WINDOW_CLOSE", - /* 255 */ "stream_options ::= stream_options WATERMARK duration_literal", - /* 256 */ "cmd ::= KILL CONNECTION NK_INTEGER", - /* 257 */ "cmd ::= KILL QUERY NK_INTEGER", - /* 258 */ "cmd ::= KILL TRANSACTION NK_INTEGER", - /* 259 */ "cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER", - /* 260 */ "cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list", - /* 261 */ "cmd ::= SPLIT VGROUP NK_INTEGER", - /* 262 */ "dnode_list ::= DNODE NK_INTEGER", - /* 263 */ "dnode_list ::= dnode_list DNODE NK_INTEGER", - /* 264 */ "cmd ::= SYNCDB db_name REPLICA", - /* 265 */ "cmd ::= query_expression", - /* 266 */ "literal ::= NK_INTEGER", - /* 267 */ "literal ::= NK_FLOAT", - /* 268 */ "literal ::= NK_STRING", - /* 269 */ "literal ::= NK_BOOL", - /* 270 */ "literal ::= TIMESTAMP NK_STRING", - /* 271 */ "literal ::= duration_literal", - /* 272 */ "literal ::= NULL", - /* 273 */ "literal ::= NK_QUESTION", - /* 274 */ "duration_literal ::= NK_VARIABLE", - /* 275 */ "signed ::= NK_INTEGER", - /* 276 */ "signed ::= NK_PLUS NK_INTEGER", - /* 277 */ "signed ::= NK_MINUS NK_INTEGER", - /* 278 */ "signed ::= NK_FLOAT", - /* 279 */ "signed ::= NK_PLUS NK_FLOAT", - /* 280 */ "signed ::= NK_MINUS NK_FLOAT", - /* 281 */ "signed_literal ::= signed", - /* 282 */ "signed_literal ::= NK_STRING", - /* 283 */ "signed_literal ::= NK_BOOL", - /* 284 */ "signed_literal ::= TIMESTAMP NK_STRING", - /* 285 */ "signed_literal ::= duration_literal", - /* 286 */ "signed_literal ::= NULL", - /* 287 */ "signed_literal ::= literal_func", - /* 288 */ "literal_list ::= signed_literal", - /* 289 */ "literal_list ::= literal_list NK_COMMA signed_literal", - /* 290 */ "db_name ::= NK_ID", - /* 291 */ "table_name ::= NK_ID", - /* 292 */ "column_name ::= NK_ID", - /* 293 */ "function_name ::= NK_ID", - /* 294 */ "table_alias ::= NK_ID", - /* 295 */ "column_alias ::= NK_ID", - /* 296 */ "user_name ::= NK_ID", - /* 297 */ "index_name ::= NK_ID", - /* 298 */ "topic_name ::= NK_ID", - /* 299 */ "stream_name ::= NK_ID", - /* 300 */ "cgroup_name ::= NK_ID", - /* 301 */ "expression ::= literal", - /* 302 */ "expression ::= pseudo_column", - /* 303 */ "expression ::= column_reference", - /* 304 */ "expression ::= function_expression", - /* 305 */ "expression ::= subquery", - /* 306 */ "expression ::= NK_LP expression NK_RP", - /* 307 */ "expression ::= NK_PLUS expression", - /* 308 */ "expression ::= NK_MINUS expression", - /* 309 */ "expression ::= expression NK_PLUS expression", - /* 310 */ "expression ::= expression NK_MINUS expression", - /* 311 */ "expression ::= expression NK_STAR expression", - /* 312 */ "expression ::= expression NK_SLASH expression", - /* 313 */ "expression ::= expression NK_REM expression", - /* 314 */ "expression ::= column_reference NK_ARROW NK_STRING", - /* 315 */ "expression_list ::= expression", - /* 316 */ "expression_list ::= expression_list NK_COMMA expression", - /* 317 */ "column_reference ::= column_name", - /* 318 */ "column_reference ::= table_name NK_DOT column_name", - /* 319 */ "pseudo_column ::= ROWTS", - /* 320 */ "pseudo_column ::= TBNAME", - /* 321 */ "pseudo_column ::= table_name NK_DOT TBNAME", - /* 322 */ "pseudo_column ::= QSTARTTS", - /* 323 */ "pseudo_column ::= QENDTS", - /* 324 */ "pseudo_column ::= WSTARTTS", - /* 325 */ "pseudo_column ::= WENDTS", - /* 326 */ "pseudo_column ::= WDURATION", - /* 327 */ "function_expression ::= function_name NK_LP expression_list NK_RP", - /* 328 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP", - /* 329 */ "function_expression ::= CAST NK_LP expression AS type_name NK_RP", - /* 330 */ "function_expression ::= literal_func", - /* 331 */ "literal_func ::= noarg_func NK_LP NK_RP", - /* 332 */ "literal_func ::= NOW", - /* 333 */ "noarg_func ::= NOW", - /* 334 */ "noarg_func ::= TODAY", - /* 335 */ "noarg_func ::= TIMEZONE", - /* 336 */ "star_func ::= COUNT", - /* 337 */ "star_func ::= FIRST", - /* 338 */ "star_func ::= LAST", - /* 339 */ "star_func ::= LAST_ROW", - /* 340 */ "star_func_para_list ::= NK_STAR", - /* 341 */ "star_func_para_list ::= other_para_list", - /* 342 */ "other_para_list ::= star_func_para", - /* 343 */ "other_para_list ::= other_para_list NK_COMMA star_func_para", - /* 344 */ "star_func_para ::= expression", - /* 345 */ "star_func_para ::= table_name NK_DOT NK_STAR", - /* 346 */ "predicate ::= expression compare_op expression", - /* 347 */ "predicate ::= expression BETWEEN expression AND expression", - /* 348 */ "predicate ::= expression NOT BETWEEN expression AND expression", - /* 349 */ "predicate ::= expression IS NULL", - /* 350 */ "predicate ::= expression IS NOT NULL", - /* 351 */ "predicate ::= expression in_op in_predicate_value", - /* 352 */ "compare_op ::= NK_LT", - /* 353 */ "compare_op ::= NK_GT", - /* 354 */ "compare_op ::= NK_LE", - /* 355 */ "compare_op ::= NK_GE", - /* 356 */ "compare_op ::= NK_NE", - /* 357 */ "compare_op ::= NK_EQ", - /* 358 */ "compare_op ::= LIKE", - /* 359 */ "compare_op ::= NOT LIKE", - /* 360 */ "compare_op ::= MATCH", - /* 361 */ "compare_op ::= NMATCH", - /* 362 */ "compare_op ::= CONTAINS", - /* 363 */ "in_op ::= IN", - /* 364 */ "in_op ::= NOT IN", - /* 365 */ "in_predicate_value ::= NK_LP expression_list NK_RP", - /* 366 */ "boolean_value_expression ::= boolean_primary", - /* 367 */ "boolean_value_expression ::= NOT boolean_primary", - /* 368 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression", - /* 369 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression", - /* 370 */ "boolean_primary ::= predicate", - /* 371 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP", - /* 372 */ "common_expression ::= expression", - /* 373 */ "common_expression ::= boolean_value_expression", - /* 374 */ "from_clause ::= FROM table_reference_list", - /* 375 */ "table_reference_list ::= table_reference", - /* 376 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference", - /* 377 */ "table_reference ::= table_primary", - /* 378 */ "table_reference ::= joined_table", - /* 379 */ "table_primary ::= table_name alias_opt", - /* 380 */ "table_primary ::= db_name NK_DOT table_name alias_opt", - /* 381 */ "table_primary ::= subquery alias_opt", - /* 382 */ "table_primary ::= parenthesized_joined_table", - /* 383 */ "alias_opt ::=", - /* 384 */ "alias_opt ::= table_alias", - /* 385 */ "alias_opt ::= AS table_alias", - /* 386 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP", - /* 387 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP", - /* 388 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition", - /* 389 */ "join_type ::=", - /* 390 */ "join_type ::= INNER", - /* 391 */ "query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt", - /* 392 */ "set_quantifier_opt ::=", - /* 393 */ "set_quantifier_opt ::= DISTINCT", - /* 394 */ "set_quantifier_opt ::= ALL", - /* 395 */ "select_list ::= NK_STAR", - /* 396 */ "select_list ::= select_sublist", - /* 397 */ "select_sublist ::= select_item", - /* 398 */ "select_sublist ::= select_sublist NK_COMMA select_item", - /* 399 */ "select_item ::= common_expression", - /* 400 */ "select_item ::= common_expression column_alias", - /* 401 */ "select_item ::= common_expression AS column_alias", - /* 402 */ "select_item ::= table_name NK_DOT NK_STAR", - /* 403 */ "where_clause_opt ::=", - /* 404 */ "where_clause_opt ::= WHERE search_condition", - /* 405 */ "partition_by_clause_opt ::=", - /* 406 */ "partition_by_clause_opt ::= PARTITION BY expression_list", - /* 407 */ "twindow_clause_opt ::=", - /* 408 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP", - /* 409 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP", - /* 410 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt", - /* 411 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt", - /* 412 */ "sliding_opt ::=", - /* 413 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP", - /* 414 */ "fill_opt ::=", - /* 415 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", - /* 416 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP", - /* 417 */ "fill_mode ::= NONE", - /* 418 */ "fill_mode ::= PREV", - /* 419 */ "fill_mode ::= NULL", - /* 420 */ "fill_mode ::= LINEAR", - /* 421 */ "fill_mode ::= NEXT", - /* 422 */ "group_by_clause_opt ::=", - /* 423 */ "group_by_clause_opt ::= GROUP BY group_by_list", - /* 424 */ "group_by_list ::= expression", - /* 425 */ "group_by_list ::= group_by_list NK_COMMA expression", - /* 426 */ "having_clause_opt ::=", - /* 427 */ "having_clause_opt ::= HAVING search_condition", - /* 428 */ "query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt", - /* 429 */ "query_expression_body ::= query_primary", - /* 430 */ "query_expression_body ::= query_expression_body UNION ALL query_expression_body", - /* 431 */ "query_expression_body ::= query_expression_body UNION query_expression_body", - /* 432 */ "query_primary ::= query_specification", - /* 433 */ "query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP", - /* 434 */ "order_by_clause_opt ::=", - /* 435 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", - /* 436 */ "slimit_clause_opt ::=", - /* 437 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", - /* 438 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", - /* 439 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 440 */ "limit_clause_opt ::=", - /* 441 */ "limit_clause_opt ::= LIMIT NK_INTEGER", - /* 442 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", - /* 443 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 444 */ "subquery ::= NK_LP query_expression NK_RP", - /* 445 */ "search_condition ::= common_expression", - /* 446 */ "sort_specification_list ::= sort_specification", - /* 447 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", - /* 448 */ "sort_specification ::= expression ordering_specification_opt null_ordering_opt", - /* 449 */ "ordering_specification_opt ::=", - /* 450 */ "ordering_specification_opt ::= ASC", - /* 451 */ "ordering_specification_opt ::= DESC", - /* 452 */ "null_ordering_opt ::=", - /* 453 */ "null_ordering_opt ::= NULLS FIRST", - /* 454 */ "null_ordering_opt ::= NULLS LAST", + /* 224 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression", + /* 225 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name", + /* 226 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name", + /* 227 */ "cmd ::= DROP TOPIC exists_opt topic_name", + /* 228 */ "cmd ::= DROP CGROUP exists_opt cgroup_name ON topic_name", + /* 229 */ "cmd ::= DESC full_table_name", + /* 230 */ "cmd ::= DESCRIBE full_table_name", + /* 231 */ "cmd ::= RESET QUERY CACHE", + /* 232 */ "cmd ::= EXPLAIN analyze_opt explain_options query_expression", + /* 233 */ "analyze_opt ::=", + /* 234 */ "analyze_opt ::= ANALYZE", + /* 235 */ "explain_options ::=", + /* 236 */ "explain_options ::= explain_options VERBOSE NK_BOOL", + /* 237 */ "explain_options ::= explain_options RATIO NK_FLOAT", + /* 238 */ "cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP", + /* 239 */ "cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt", + /* 240 */ "cmd ::= DROP FUNCTION exists_opt function_name", + /* 241 */ "agg_func_opt ::=", + /* 242 */ "agg_func_opt ::= AGGREGATE", + /* 243 */ "bufsize_opt ::=", + /* 244 */ "bufsize_opt ::= BUFSIZE NK_INTEGER", + /* 245 */ "cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression", + /* 246 */ "cmd ::= DROP STREAM exists_opt stream_name", + /* 247 */ "into_opt ::=", + /* 248 */ "into_opt ::= INTO full_table_name", + /* 249 */ "stream_options ::=", + /* 250 */ "stream_options ::= stream_options TRIGGER AT_ONCE", + /* 251 */ "stream_options ::= stream_options TRIGGER WINDOW_CLOSE", + /* 252 */ "stream_options ::= stream_options WATERMARK duration_literal", + /* 253 */ "cmd ::= KILL CONNECTION NK_INTEGER", + /* 254 */ "cmd ::= KILL QUERY NK_INTEGER", + /* 255 */ "cmd ::= KILL TRANSACTION NK_INTEGER", + /* 256 */ "cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER", + /* 257 */ "cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list", + /* 258 */ "cmd ::= SPLIT VGROUP NK_INTEGER", + /* 259 */ "dnode_list ::= DNODE NK_INTEGER", + /* 260 */ "dnode_list ::= dnode_list DNODE NK_INTEGER", + /* 261 */ "cmd ::= SYNCDB db_name REPLICA", + /* 262 */ "cmd ::= query_expression", + /* 263 */ "literal ::= NK_INTEGER", + /* 264 */ "literal ::= NK_FLOAT", + /* 265 */ "literal ::= NK_STRING", + /* 266 */ "literal ::= NK_BOOL", + /* 267 */ "literal ::= TIMESTAMP NK_STRING", + /* 268 */ "literal ::= duration_literal", + /* 269 */ "literal ::= NULL", + /* 270 */ "literal ::= NK_QUESTION", + /* 271 */ "duration_literal ::= NK_VARIABLE", + /* 272 */ "signed ::= NK_INTEGER", + /* 273 */ "signed ::= NK_PLUS NK_INTEGER", + /* 274 */ "signed ::= NK_MINUS NK_INTEGER", + /* 275 */ "signed ::= NK_FLOAT", + /* 276 */ "signed ::= NK_PLUS NK_FLOAT", + /* 277 */ "signed ::= NK_MINUS NK_FLOAT", + /* 278 */ "signed_literal ::= signed", + /* 279 */ "signed_literal ::= NK_STRING", + /* 280 */ "signed_literal ::= NK_BOOL", + /* 281 */ "signed_literal ::= TIMESTAMP NK_STRING", + /* 282 */ "signed_literal ::= duration_literal", + /* 283 */ "signed_literal ::= NULL", + /* 284 */ "signed_literal ::= literal_func", + /* 285 */ "literal_list ::= signed_literal", + /* 286 */ "literal_list ::= literal_list NK_COMMA signed_literal", + /* 287 */ "db_name ::= NK_ID", + /* 288 */ "table_name ::= NK_ID", + /* 289 */ "column_name ::= NK_ID", + /* 290 */ "function_name ::= NK_ID", + /* 291 */ "table_alias ::= NK_ID", + /* 292 */ "column_alias ::= NK_ID", + /* 293 */ "user_name ::= NK_ID", + /* 294 */ "index_name ::= NK_ID", + /* 295 */ "topic_name ::= NK_ID", + /* 296 */ "stream_name ::= NK_ID", + /* 297 */ "cgroup_name ::= NK_ID", + /* 298 */ "expression ::= literal", + /* 299 */ "expression ::= pseudo_column", + /* 300 */ "expression ::= column_reference", + /* 301 */ "expression ::= function_expression", + /* 302 */ "expression ::= subquery", + /* 303 */ "expression ::= NK_LP expression NK_RP", + /* 304 */ "expression ::= NK_PLUS expression", + /* 305 */ "expression ::= NK_MINUS expression", + /* 306 */ "expression ::= expression NK_PLUS expression", + /* 307 */ "expression ::= expression NK_MINUS expression", + /* 308 */ "expression ::= expression NK_STAR expression", + /* 309 */ "expression ::= expression NK_SLASH expression", + /* 310 */ "expression ::= expression NK_REM expression", + /* 311 */ "expression ::= column_reference NK_ARROW NK_STRING", + /* 312 */ "expression_list ::= expression", + /* 313 */ "expression_list ::= expression_list NK_COMMA expression", + /* 314 */ "column_reference ::= column_name", + /* 315 */ "column_reference ::= table_name NK_DOT column_name", + /* 316 */ "pseudo_column ::= ROWTS", + /* 317 */ "pseudo_column ::= TBNAME", + /* 318 */ "pseudo_column ::= table_name NK_DOT TBNAME", + /* 319 */ "pseudo_column ::= QSTARTTS", + /* 320 */ "pseudo_column ::= QENDTS", + /* 321 */ "pseudo_column ::= WSTARTTS", + /* 322 */ "pseudo_column ::= WENDTS", + /* 323 */ "pseudo_column ::= WDURATION", + /* 324 */ "function_expression ::= function_name NK_LP expression_list NK_RP", + /* 325 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP", + /* 326 */ "function_expression ::= CAST NK_LP expression AS type_name NK_RP", + /* 327 */ "function_expression ::= literal_func", + /* 328 */ "literal_func ::= noarg_func NK_LP NK_RP", + /* 329 */ "literal_func ::= NOW", + /* 330 */ "noarg_func ::= NOW", + /* 331 */ "noarg_func ::= TODAY", + /* 332 */ "noarg_func ::= TIMEZONE", + /* 333 */ "star_func ::= COUNT", + /* 334 */ "star_func ::= FIRST", + /* 335 */ "star_func ::= LAST", + /* 336 */ "star_func ::= LAST_ROW", + /* 337 */ "star_func_para_list ::= NK_STAR", + /* 338 */ "star_func_para_list ::= other_para_list", + /* 339 */ "other_para_list ::= star_func_para", + /* 340 */ "other_para_list ::= other_para_list NK_COMMA star_func_para", + /* 341 */ "star_func_para ::= expression", + /* 342 */ "star_func_para ::= table_name NK_DOT NK_STAR", + /* 343 */ "predicate ::= expression compare_op expression", + /* 344 */ "predicate ::= expression BETWEEN expression AND expression", + /* 345 */ "predicate ::= expression NOT BETWEEN expression AND expression", + /* 346 */ "predicate ::= expression IS NULL", + /* 347 */ "predicate ::= expression IS NOT NULL", + /* 348 */ "predicate ::= expression in_op in_predicate_value", + /* 349 */ "compare_op ::= NK_LT", + /* 350 */ "compare_op ::= NK_GT", + /* 351 */ "compare_op ::= NK_LE", + /* 352 */ "compare_op ::= NK_GE", + /* 353 */ "compare_op ::= NK_NE", + /* 354 */ "compare_op ::= NK_EQ", + /* 355 */ "compare_op ::= LIKE", + /* 356 */ "compare_op ::= NOT LIKE", + /* 357 */ "compare_op ::= MATCH", + /* 358 */ "compare_op ::= NMATCH", + /* 359 */ "compare_op ::= CONTAINS", + /* 360 */ "in_op ::= IN", + /* 361 */ "in_op ::= NOT IN", + /* 362 */ "in_predicate_value ::= NK_LP expression_list NK_RP", + /* 363 */ "boolean_value_expression ::= boolean_primary", + /* 364 */ "boolean_value_expression ::= NOT boolean_primary", + /* 365 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression", + /* 366 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression", + /* 367 */ "boolean_primary ::= predicate", + /* 368 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP", + /* 369 */ "common_expression ::= expression", + /* 370 */ "common_expression ::= boolean_value_expression", + /* 371 */ "from_clause ::= FROM table_reference_list", + /* 372 */ "table_reference_list ::= table_reference", + /* 373 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference", + /* 374 */ "table_reference ::= table_primary", + /* 375 */ "table_reference ::= joined_table", + /* 376 */ "table_primary ::= table_name alias_opt", + /* 377 */ "table_primary ::= db_name NK_DOT table_name alias_opt", + /* 378 */ "table_primary ::= subquery alias_opt", + /* 379 */ "table_primary ::= parenthesized_joined_table", + /* 380 */ "alias_opt ::=", + /* 381 */ "alias_opt ::= table_alias", + /* 382 */ "alias_opt ::= AS table_alias", + /* 383 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP", + /* 384 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP", + /* 385 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition", + /* 386 */ "join_type ::=", + /* 387 */ "join_type ::= INNER", + /* 388 */ "query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt", + /* 389 */ "set_quantifier_opt ::=", + /* 390 */ "set_quantifier_opt ::= DISTINCT", + /* 391 */ "set_quantifier_opt ::= ALL", + /* 392 */ "select_list ::= NK_STAR", + /* 393 */ "select_list ::= select_sublist", + /* 394 */ "select_sublist ::= select_item", + /* 395 */ "select_sublist ::= select_sublist NK_COMMA select_item", + /* 396 */ "select_item ::= common_expression", + /* 397 */ "select_item ::= common_expression column_alias", + /* 398 */ "select_item ::= common_expression AS column_alias", + /* 399 */ "select_item ::= table_name NK_DOT NK_STAR", + /* 400 */ "where_clause_opt ::=", + /* 401 */ "where_clause_opt ::= WHERE search_condition", + /* 402 */ "partition_by_clause_opt ::=", + /* 403 */ "partition_by_clause_opt ::= PARTITION BY expression_list", + /* 404 */ "twindow_clause_opt ::=", + /* 405 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP", + /* 406 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP", + /* 407 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt", + /* 408 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt", + /* 409 */ "sliding_opt ::=", + /* 410 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP", + /* 411 */ "fill_opt ::=", + /* 412 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", + /* 413 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP", + /* 414 */ "fill_mode ::= NONE", + /* 415 */ "fill_mode ::= PREV", + /* 416 */ "fill_mode ::= NULL", + /* 417 */ "fill_mode ::= LINEAR", + /* 418 */ "fill_mode ::= NEXT", + /* 419 */ "group_by_clause_opt ::=", + /* 420 */ "group_by_clause_opt ::= GROUP BY group_by_list", + /* 421 */ "group_by_list ::= expression", + /* 422 */ "group_by_list ::= group_by_list NK_COMMA expression", + /* 423 */ "having_clause_opt ::=", + /* 424 */ "having_clause_opt ::= HAVING search_condition", + /* 425 */ "query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt", + /* 426 */ "query_expression_body ::= query_primary", + /* 427 */ "query_expression_body ::= query_expression_body UNION ALL query_expression_body", + /* 428 */ "query_expression_body ::= query_expression_body UNION query_expression_body", + /* 429 */ "query_primary ::= query_specification", + /* 430 */ "query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP", + /* 431 */ "order_by_clause_opt ::=", + /* 432 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", + /* 433 */ "slimit_clause_opt ::=", + /* 434 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", + /* 435 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", + /* 436 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 437 */ "limit_clause_opt ::=", + /* 438 */ "limit_clause_opt ::= LIMIT NK_INTEGER", + /* 439 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", + /* 440 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 441 */ "subquery ::= NK_LP query_expression NK_RP", + /* 442 */ "search_condition ::= common_expression", + /* 443 */ "sort_specification_list ::= sort_specification", + /* 444 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", + /* 445 */ "sort_specification ::= expression ordering_specification_opt null_ordering_opt", + /* 446 */ "ordering_specification_opt ::=", + /* 447 */ "ordering_specification_opt ::= ASC", + /* 448 */ "ordering_specification_opt ::= DESC", + /* 449 */ "null_ordering_opt ::=", + /* 450 */ "null_ordering_opt ::= NULLS FIRST", + /* 451 */ "null_ordering_opt ::= NULLS LAST", }; #endif /* NDEBUG */ @@ -2104,175 +2108,174 @@ static void yy_destructor( */ /********* Begin destructor definitions ***************************************/ /* Default NON-TERMINAL Destructor */ - case 240: /* cmd */ - case 243: /* literal */ - case 254: /* db_options */ - case 256: /* alter_db_options */ - case 261: /* retention */ - case 262: /* full_table_name */ - case 265: /* table_options */ - case 269: /* alter_table_clause */ - case 270: /* alter_table_options */ - case 273: /* signed_literal */ - case 274: /* create_subtable_clause */ - case 277: /* drop_table_clause */ - case 280: /* column_def */ - case 283: /* col_name */ - case 284: /* db_name_cond_opt */ - case 285: /* like_pattern_opt */ - case 286: /* table_name_cond */ - case 287: /* from_db_opt */ - case 288: /* func_name */ - case 291: /* index_options */ - case 293: /* duration_literal */ - case 294: /* sliding_opt */ - case 295: /* func */ - case 298: /* topic_options */ - case 299: /* query_expression */ - case 302: /* explain_options */ - case 306: /* stream_options */ - case 307: /* into_opt */ - case 309: /* signed */ - case 310: /* literal_func */ - case 313: /* expression */ - case 314: /* pseudo_column */ - case 315: /* column_reference */ - case 316: /* function_expression */ - case 317: /* subquery */ - case 322: /* star_func_para */ - case 323: /* predicate */ - case 326: /* in_predicate_value */ - case 327: /* boolean_value_expression */ - case 328: /* boolean_primary */ - case 329: /* common_expression */ - case 330: /* from_clause */ - case 331: /* table_reference_list */ - case 332: /* table_reference */ - case 333: /* table_primary */ - case 334: /* joined_table */ - case 336: /* parenthesized_joined_table */ - case 338: /* search_condition */ - case 339: /* query_specification */ - case 342: /* where_clause_opt */ - case 344: /* twindow_clause_opt */ - case 346: /* having_clause_opt */ - case 348: /* select_item */ - case 349: /* fill_opt */ - case 352: /* query_expression_body */ - case 354: /* slimit_clause_opt */ - case 355: /* limit_clause_opt */ - case 356: /* query_primary */ - case 358: /* sort_specification */ + case 238: /* cmd */ + case 241: /* literal */ + case 252: /* db_options */ + case 254: /* alter_db_options */ + case 259: /* retention */ + case 260: /* full_table_name */ + case 263: /* table_options */ + case 267: /* alter_table_clause */ + case 268: /* alter_table_options */ + case 271: /* signed_literal */ + case 272: /* create_subtable_clause */ + case 275: /* drop_table_clause */ + case 278: /* column_def */ + case 281: /* col_name */ + case 282: /* db_name_cond_opt */ + case 283: /* like_pattern_opt */ + case 284: /* table_name_cond */ + case 285: /* from_db_opt */ + case 286: /* func_name */ + case 289: /* index_options */ + case 291: /* duration_literal */ + case 292: /* sliding_opt */ + case 293: /* func */ + case 296: /* query_expression */ + case 299: /* explain_options */ + case 303: /* stream_options */ + case 304: /* into_opt */ + case 306: /* signed */ + case 307: /* literal_func */ + case 310: /* expression */ + case 311: /* pseudo_column */ + case 312: /* column_reference */ + case 313: /* function_expression */ + case 314: /* subquery */ + case 319: /* star_func_para */ + case 320: /* predicate */ + case 323: /* in_predicate_value */ + case 324: /* boolean_value_expression */ + case 325: /* boolean_primary */ + case 326: /* common_expression */ + case 327: /* from_clause */ + case 328: /* table_reference_list */ + case 329: /* table_reference */ + case 330: /* table_primary */ + case 331: /* joined_table */ + case 333: /* parenthesized_joined_table */ + case 335: /* search_condition */ + case 336: /* query_specification */ + case 339: /* where_clause_opt */ + case 341: /* twindow_clause_opt */ + case 343: /* having_clause_opt */ + case 345: /* select_item */ + case 346: /* fill_opt */ + case 349: /* query_expression_body */ + case 351: /* slimit_clause_opt */ + case 352: /* limit_clause_opt */ + case 353: /* query_primary */ + case 355: /* sort_specification */ { - nodesDestroyNode((yypminor->yy636)); + nodesDestroyNode((yypminor->yy172)); } break; - case 241: /* account_options */ - case 242: /* alter_account_options */ - case 244: /* alter_account_option */ - case 304: /* bufsize_opt */ + case 239: /* account_options */ + case 240: /* alter_account_options */ + case 242: /* alter_account_option */ + case 301: /* bufsize_opt */ { } break; - case 245: /* user_name */ - case 247: /* priv_level */ - case 250: /* db_name */ - case 251: /* dnode_endpoint */ - case 252: /* dnode_host_name */ - case 271: /* column_name */ - case 279: /* table_name */ - case 289: /* function_name */ - case 290: /* index_name */ - case 297: /* topic_name */ - case 300: /* cgroup_name */ - case 305: /* stream_name */ - case 311: /* table_alias */ - case 312: /* column_alias */ - case 318: /* star_func */ - case 320: /* noarg_func */ - case 335: /* alias_opt */ + case 243: /* user_name */ + case 245: /* priv_level */ + case 248: /* db_name */ + case 249: /* dnode_endpoint */ + case 250: /* dnode_host_name */ + case 269: /* column_name */ + case 277: /* table_name */ + case 287: /* function_name */ + case 288: /* index_name */ + case 295: /* topic_name */ + case 297: /* cgroup_name */ + case 302: /* stream_name */ + case 308: /* table_alias */ + case 309: /* column_alias */ + case 315: /* star_func */ + case 317: /* noarg_func */ + case 332: /* alias_opt */ { } break; - case 246: /* privileges */ - case 248: /* priv_type_list */ - case 249: /* priv_type */ + case 244: /* privileges */ + case 246: /* priv_type_list */ + case 247: /* priv_type */ { } break; - case 253: /* not_exists_opt */ - case 255: /* exists_opt */ - case 301: /* analyze_opt */ - case 303: /* agg_func_opt */ - case 340: /* set_quantifier_opt */ + case 251: /* not_exists_opt */ + case 253: /* exists_opt */ + case 298: /* analyze_opt */ + case 300: /* agg_func_opt */ + case 337: /* set_quantifier_opt */ { } break; - case 257: /* integer_list */ - case 258: /* variable_list */ - case 259: /* retention_list */ - case 263: /* column_def_list */ - case 264: /* tags_def_opt */ - case 266: /* multi_create_clause */ - case 267: /* tags_def */ - case 268: /* multi_drop_clause */ - case 275: /* specific_tags_opt */ - case 276: /* literal_list */ - case 278: /* col_name_list */ - case 281: /* func_name_list */ - case 292: /* func_list */ - case 296: /* expression_list */ - case 308: /* dnode_list */ - case 319: /* star_func_para_list */ - case 321: /* other_para_list */ - case 341: /* select_list */ - case 343: /* partition_by_clause_opt */ - case 345: /* group_by_clause_opt */ - case 347: /* select_sublist */ - case 351: /* group_by_list */ - case 353: /* order_by_clause_opt */ - case 357: /* sort_specification_list */ + case 255: /* integer_list */ + case 256: /* variable_list */ + case 257: /* retention_list */ + case 261: /* column_def_list */ + case 262: /* tags_def_opt */ + case 264: /* multi_create_clause */ + case 265: /* tags_def */ + case 266: /* multi_drop_clause */ + case 273: /* specific_tags_opt */ + case 274: /* literal_list */ + case 276: /* col_name_list */ + case 279: /* func_name_list */ + case 290: /* func_list */ + case 294: /* expression_list */ + case 305: /* dnode_list */ + case 316: /* star_func_para_list */ + case 318: /* other_para_list */ + case 338: /* select_list */ + case 340: /* partition_by_clause_opt */ + case 342: /* group_by_clause_opt */ + case 344: /* select_sublist */ + case 348: /* group_by_list */ + case 350: /* order_by_clause_opt */ + case 354: /* sort_specification_list */ { - nodesDestroyList((yypminor->yy236)); + nodesDestroyList((yypminor->yy60)); } break; - case 260: /* alter_db_option */ - case 282: /* alter_table_option */ + case 258: /* alter_db_option */ + case 280: /* alter_table_option */ { } break; - case 272: /* type_name */ + case 270: /* type_name */ { } break; - case 324: /* compare_op */ - case 325: /* in_op */ + case 321: /* compare_op */ + case 322: /* in_op */ { } break; - case 337: /* join_type */ + case 334: /* join_type */ { } break; - case 350: /* fill_mode */ + case 347: /* fill_mode */ { } break; - case 359: /* ordering_specification_opt */ + case 356: /* ordering_specification_opt */ { } break; - case 360: /* null_ordering_opt */ + case 357: /* null_ordering_opt */ { } @@ -2571,461 +2574,458 @@ static const struct { YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */ signed char nrhs; /* Negative of the number of RHS symbols in the rule */ } yyRuleInfo[] = { - { 240, -6 }, /* (0) cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */ - { 240, -4 }, /* (1) cmd ::= ALTER ACCOUNT NK_ID alter_account_options */ - { 241, 0 }, /* (2) account_options ::= */ - { 241, -3 }, /* (3) account_options ::= account_options PPS literal */ - { 241, -3 }, /* (4) account_options ::= account_options TSERIES literal */ - { 241, -3 }, /* (5) account_options ::= account_options STORAGE literal */ - { 241, -3 }, /* (6) account_options ::= account_options STREAMS literal */ - { 241, -3 }, /* (7) account_options ::= account_options QTIME literal */ - { 241, -3 }, /* (8) account_options ::= account_options DBS literal */ - { 241, -3 }, /* (9) account_options ::= account_options USERS literal */ - { 241, -3 }, /* (10) account_options ::= account_options CONNS literal */ - { 241, -3 }, /* (11) account_options ::= account_options STATE literal */ - { 242, -1 }, /* (12) alter_account_options ::= alter_account_option */ - { 242, -2 }, /* (13) alter_account_options ::= alter_account_options alter_account_option */ - { 244, -2 }, /* (14) alter_account_option ::= PASS literal */ - { 244, -2 }, /* (15) alter_account_option ::= PPS literal */ - { 244, -2 }, /* (16) alter_account_option ::= TSERIES literal */ - { 244, -2 }, /* (17) alter_account_option ::= STORAGE literal */ - { 244, -2 }, /* (18) alter_account_option ::= STREAMS literal */ - { 244, -2 }, /* (19) alter_account_option ::= QTIME literal */ - { 244, -2 }, /* (20) alter_account_option ::= DBS literal */ - { 244, -2 }, /* (21) alter_account_option ::= USERS literal */ - { 244, -2 }, /* (22) alter_account_option ::= CONNS literal */ - { 244, -2 }, /* (23) alter_account_option ::= STATE literal */ - { 240, -5 }, /* (24) cmd ::= CREATE USER user_name PASS NK_STRING */ - { 240, -5 }, /* (25) cmd ::= ALTER USER user_name PASS NK_STRING */ - { 240, -5 }, /* (26) cmd ::= ALTER USER user_name PRIVILEGE NK_STRING */ - { 240, -3 }, /* (27) cmd ::= DROP USER user_name */ - { 240, -6 }, /* (28) cmd ::= GRANT privileges ON priv_level TO user_name */ - { 240, -6 }, /* (29) cmd ::= REVOKE privileges ON priv_level FROM user_name */ - { 246, -1 }, /* (30) privileges ::= ALL */ - { 246, -1 }, /* (31) privileges ::= priv_type_list */ - { 248, -1 }, /* (32) priv_type_list ::= priv_type */ - { 248, -3 }, /* (33) priv_type_list ::= priv_type_list NK_COMMA priv_type */ - { 249, -1 }, /* (34) priv_type ::= READ */ - { 249, -1 }, /* (35) priv_type ::= WRITE */ - { 247, -3 }, /* (36) priv_level ::= NK_STAR NK_DOT NK_STAR */ - { 247, -3 }, /* (37) priv_level ::= db_name NK_DOT NK_STAR */ - { 240, -3 }, /* (38) cmd ::= CREATE DNODE dnode_endpoint */ - { 240, -5 }, /* (39) cmd ::= CREATE DNODE dnode_host_name PORT NK_INTEGER */ - { 240, -3 }, /* (40) cmd ::= DROP DNODE NK_INTEGER */ - { 240, -3 }, /* (41) cmd ::= DROP DNODE dnode_endpoint */ - { 240, -4 }, /* (42) cmd ::= ALTER DNODE NK_INTEGER NK_STRING */ - { 240, -5 }, /* (43) cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */ - { 240, -4 }, /* (44) cmd ::= ALTER ALL DNODES NK_STRING */ - { 240, -5 }, /* (45) cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */ - { 251, -1 }, /* (46) dnode_endpoint ::= NK_STRING */ - { 252, -1 }, /* (47) dnode_host_name ::= NK_ID */ - { 252, -1 }, /* (48) dnode_host_name ::= NK_IPTOKEN */ - { 240, -3 }, /* (49) cmd ::= ALTER LOCAL NK_STRING */ - { 240, -4 }, /* (50) cmd ::= ALTER LOCAL NK_STRING NK_STRING */ - { 240, -5 }, /* (51) cmd ::= CREATE QNODE ON DNODE NK_INTEGER */ - { 240, -5 }, /* (52) cmd ::= DROP QNODE ON DNODE NK_INTEGER */ - { 240, -5 }, /* (53) cmd ::= CREATE BNODE ON DNODE NK_INTEGER */ - { 240, -5 }, /* (54) cmd ::= DROP BNODE ON DNODE NK_INTEGER */ - { 240, -5 }, /* (55) cmd ::= CREATE SNODE ON DNODE NK_INTEGER */ - { 240, -5 }, /* (56) cmd ::= DROP SNODE ON DNODE NK_INTEGER */ - { 240, -5 }, /* (57) cmd ::= CREATE MNODE ON DNODE NK_INTEGER */ - { 240, -5 }, /* (58) cmd ::= DROP MNODE ON DNODE NK_INTEGER */ - { 240, -5 }, /* (59) cmd ::= CREATE DATABASE not_exists_opt db_name db_options */ - { 240, -4 }, /* (60) cmd ::= DROP DATABASE exists_opt db_name */ - { 240, -2 }, /* (61) cmd ::= USE db_name */ - { 240, -4 }, /* (62) cmd ::= ALTER DATABASE db_name alter_db_options */ - { 253, -3 }, /* (63) not_exists_opt ::= IF NOT EXISTS */ - { 253, 0 }, /* (64) not_exists_opt ::= */ - { 255, -2 }, /* (65) exists_opt ::= IF EXISTS */ - { 255, 0 }, /* (66) exists_opt ::= */ - { 254, 0 }, /* (67) db_options ::= */ - { 254, -3 }, /* (68) db_options ::= db_options BUFFER NK_INTEGER */ - { 254, -3 }, /* (69) db_options ::= db_options CACHELAST NK_INTEGER */ - { 254, -3 }, /* (70) db_options ::= db_options COMP NK_INTEGER */ - { 254, -3 }, /* (71) db_options ::= db_options DAYS NK_INTEGER */ - { 254, -3 }, /* (72) db_options ::= db_options DAYS NK_VARIABLE */ - { 254, -3 }, /* (73) db_options ::= db_options FSYNC NK_INTEGER */ - { 254, -3 }, /* (74) db_options ::= db_options MAXROWS NK_INTEGER */ - { 254, -3 }, /* (75) db_options ::= db_options MINROWS NK_INTEGER */ - { 254, -3 }, /* (76) db_options ::= db_options KEEP integer_list */ - { 254, -3 }, /* (77) db_options ::= db_options KEEP variable_list */ - { 254, -3 }, /* (78) db_options ::= db_options PAGES NK_INTEGER */ - { 254, -3 }, /* (79) db_options ::= db_options PAGESIZE NK_INTEGER */ - { 254, -3 }, /* (80) db_options ::= db_options PRECISION NK_STRING */ - { 254, -3 }, /* (81) db_options ::= db_options REPLICA NK_INTEGER */ - { 254, -3 }, /* (82) db_options ::= db_options STRICT NK_INTEGER */ - { 254, -3 }, /* (83) db_options ::= db_options WAL NK_INTEGER */ - { 254, -3 }, /* (84) db_options ::= db_options VGROUPS NK_INTEGER */ - { 254, -3 }, /* (85) db_options ::= db_options SINGLE_STABLE NK_INTEGER */ - { 254, -3 }, /* (86) db_options ::= db_options RETENTIONS retention_list */ - { 254, -3 }, /* (87) db_options ::= db_options SCHEMALESS NK_INTEGER */ - { 256, -1 }, /* (88) alter_db_options ::= alter_db_option */ - { 256, -2 }, /* (89) alter_db_options ::= alter_db_options alter_db_option */ - { 260, -2 }, /* (90) alter_db_option ::= BUFFER NK_INTEGER */ - { 260, -2 }, /* (91) alter_db_option ::= CACHELAST NK_INTEGER */ - { 260, -2 }, /* (92) alter_db_option ::= FSYNC NK_INTEGER */ - { 260, -2 }, /* (93) alter_db_option ::= KEEP integer_list */ - { 260, -2 }, /* (94) alter_db_option ::= KEEP variable_list */ - { 260, -2 }, /* (95) alter_db_option ::= PAGES NK_INTEGER */ - { 260, -2 }, /* (96) alter_db_option ::= REPLICA NK_INTEGER */ - { 260, -2 }, /* (97) alter_db_option ::= STRICT NK_INTEGER */ - { 260, -2 }, /* (98) alter_db_option ::= WAL NK_INTEGER */ - { 257, -1 }, /* (99) integer_list ::= NK_INTEGER */ - { 257, -3 }, /* (100) integer_list ::= integer_list NK_COMMA NK_INTEGER */ - { 258, -1 }, /* (101) variable_list ::= NK_VARIABLE */ - { 258, -3 }, /* (102) variable_list ::= variable_list NK_COMMA NK_VARIABLE */ - { 259, -1 }, /* (103) retention_list ::= retention */ - { 259, -3 }, /* (104) retention_list ::= retention_list NK_COMMA retention */ - { 261, -3 }, /* (105) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ - { 240, -9 }, /* (106) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ - { 240, -3 }, /* (107) cmd ::= CREATE TABLE multi_create_clause */ - { 240, -9 }, /* (108) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ - { 240, -3 }, /* (109) cmd ::= DROP TABLE multi_drop_clause */ - { 240, -4 }, /* (110) cmd ::= DROP STABLE exists_opt full_table_name */ - { 240, -3 }, /* (111) cmd ::= ALTER TABLE alter_table_clause */ - { 240, -3 }, /* (112) cmd ::= ALTER STABLE alter_table_clause */ - { 269, -2 }, /* (113) alter_table_clause ::= full_table_name alter_table_options */ - { 269, -5 }, /* (114) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ - { 269, -4 }, /* (115) alter_table_clause ::= full_table_name DROP COLUMN column_name */ - { 269, -5 }, /* (116) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ - { 269, -5 }, /* (117) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ - { 269, -5 }, /* (118) alter_table_clause ::= full_table_name ADD TAG column_name type_name */ - { 269, -4 }, /* (119) alter_table_clause ::= full_table_name DROP TAG column_name */ - { 269, -5 }, /* (120) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ - { 269, -5 }, /* (121) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ - { 269, -6 }, /* (122) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ - { 266, -1 }, /* (123) multi_create_clause ::= create_subtable_clause */ - { 266, -2 }, /* (124) multi_create_clause ::= multi_create_clause create_subtable_clause */ - { 274, -10 }, /* (125) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP literal_list NK_RP table_options */ - { 268, -1 }, /* (126) multi_drop_clause ::= drop_table_clause */ - { 268, -2 }, /* (127) multi_drop_clause ::= multi_drop_clause drop_table_clause */ - { 277, -2 }, /* (128) drop_table_clause ::= exists_opt full_table_name */ - { 275, 0 }, /* (129) specific_tags_opt ::= */ - { 275, -3 }, /* (130) specific_tags_opt ::= NK_LP col_name_list NK_RP */ - { 262, -1 }, /* (131) full_table_name ::= table_name */ - { 262, -3 }, /* (132) full_table_name ::= db_name NK_DOT table_name */ - { 263, -1 }, /* (133) column_def_list ::= column_def */ - { 263, -3 }, /* (134) column_def_list ::= column_def_list NK_COMMA column_def */ - { 280, -2 }, /* (135) column_def ::= column_name type_name */ - { 280, -4 }, /* (136) column_def ::= column_name type_name COMMENT NK_STRING */ - { 272, -1 }, /* (137) type_name ::= BOOL */ - { 272, -1 }, /* (138) type_name ::= TINYINT */ - { 272, -1 }, /* (139) type_name ::= SMALLINT */ - { 272, -1 }, /* (140) type_name ::= INT */ - { 272, -1 }, /* (141) type_name ::= INTEGER */ - { 272, -1 }, /* (142) type_name ::= BIGINT */ - { 272, -1 }, /* (143) type_name ::= FLOAT */ - { 272, -1 }, /* (144) type_name ::= DOUBLE */ - { 272, -4 }, /* (145) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ - { 272, -1 }, /* (146) type_name ::= TIMESTAMP */ - { 272, -4 }, /* (147) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ - { 272, -2 }, /* (148) type_name ::= TINYINT UNSIGNED */ - { 272, -2 }, /* (149) type_name ::= SMALLINT UNSIGNED */ - { 272, -2 }, /* (150) type_name ::= INT UNSIGNED */ - { 272, -2 }, /* (151) type_name ::= BIGINT UNSIGNED */ - { 272, -1 }, /* (152) type_name ::= JSON */ - { 272, -4 }, /* (153) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ - { 272, -1 }, /* (154) type_name ::= MEDIUMBLOB */ - { 272, -1 }, /* (155) type_name ::= BLOB */ - { 272, -4 }, /* (156) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ - { 272, -1 }, /* (157) type_name ::= DECIMAL */ - { 272, -4 }, /* (158) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ - { 272, -6 }, /* (159) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ - { 264, 0 }, /* (160) tags_def_opt ::= */ - { 264, -1 }, /* (161) tags_def_opt ::= tags_def */ - { 267, -4 }, /* (162) tags_def ::= TAGS NK_LP column_def_list NK_RP */ - { 265, 0 }, /* (163) table_options ::= */ - { 265, -3 }, /* (164) table_options ::= table_options COMMENT NK_STRING */ - { 265, -3 }, /* (165) table_options ::= table_options DELAY NK_INTEGER */ - { 265, -3 }, /* (166) table_options ::= table_options FILE_FACTOR NK_FLOAT */ - { 265, -5 }, /* (167) table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP */ - { 265, -3 }, /* (168) table_options ::= table_options TTL NK_INTEGER */ - { 265, -5 }, /* (169) table_options ::= table_options SMA NK_LP col_name_list NK_RP */ - { 270, -1 }, /* (170) alter_table_options ::= alter_table_option */ - { 270, -2 }, /* (171) alter_table_options ::= alter_table_options alter_table_option */ - { 282, -2 }, /* (172) alter_table_option ::= COMMENT NK_STRING */ - { 282, -2 }, /* (173) alter_table_option ::= TTL NK_INTEGER */ - { 278, -1 }, /* (174) col_name_list ::= col_name */ - { 278, -3 }, /* (175) col_name_list ::= col_name_list NK_COMMA col_name */ - { 283, -1 }, /* (176) col_name ::= column_name */ - { 240, -2 }, /* (177) cmd ::= SHOW DNODES */ - { 240, -2 }, /* (178) cmd ::= SHOW USERS */ - { 240, -2 }, /* (179) cmd ::= SHOW DATABASES */ - { 240, -4 }, /* (180) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */ - { 240, -4 }, /* (181) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ - { 240, -3 }, /* (182) cmd ::= SHOW db_name_cond_opt VGROUPS */ - { 240, -2 }, /* (183) cmd ::= SHOW MNODES */ - { 240, -2 }, /* (184) cmd ::= SHOW MODULES */ - { 240, -2 }, /* (185) cmd ::= SHOW QNODES */ - { 240, -2 }, /* (186) cmd ::= SHOW FUNCTIONS */ - { 240, -5 }, /* (187) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ - { 240, -2 }, /* (188) cmd ::= SHOW STREAMS */ - { 240, -2 }, /* (189) cmd ::= SHOW ACCOUNTS */ - { 240, -2 }, /* (190) cmd ::= SHOW APPS */ - { 240, -2 }, /* (191) cmd ::= SHOW CONNECTIONS */ - { 240, -2 }, /* (192) cmd ::= SHOW LICENCE */ - { 240, -2 }, /* (193) cmd ::= SHOW GRANTS */ - { 240, -4 }, /* (194) cmd ::= SHOW CREATE DATABASE db_name */ - { 240, -4 }, /* (195) cmd ::= SHOW CREATE TABLE full_table_name */ - { 240, -4 }, /* (196) cmd ::= SHOW CREATE STABLE full_table_name */ - { 240, -2 }, /* (197) cmd ::= SHOW QUERIES */ - { 240, -2 }, /* (198) cmd ::= SHOW SCORES */ - { 240, -2 }, /* (199) cmd ::= SHOW TOPICS */ - { 240, -2 }, /* (200) cmd ::= SHOW VARIABLES */ - { 240, -2 }, /* (201) cmd ::= SHOW BNODES */ - { 240, -2 }, /* (202) cmd ::= SHOW SNODES */ - { 240, -2 }, /* (203) cmd ::= SHOW CLUSTER */ - { 240, -2 }, /* (204) cmd ::= SHOW TRANSACTIONS */ - { 284, 0 }, /* (205) db_name_cond_opt ::= */ - { 284, -2 }, /* (206) db_name_cond_opt ::= db_name NK_DOT */ - { 285, 0 }, /* (207) like_pattern_opt ::= */ - { 285, -2 }, /* (208) like_pattern_opt ::= LIKE NK_STRING */ - { 286, -1 }, /* (209) table_name_cond ::= table_name */ - { 287, 0 }, /* (210) from_db_opt ::= */ - { 287, -2 }, /* (211) from_db_opt ::= FROM db_name */ - { 281, -1 }, /* (212) func_name_list ::= func_name */ - { 281, -3 }, /* (213) func_name_list ::= func_name_list NK_COMMA func_name */ - { 288, -1 }, /* (214) func_name ::= function_name */ - { 240, -8 }, /* (215) cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options */ - { 240, -10 }, /* (216) cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP */ - { 240, -6 }, /* (217) cmd ::= DROP INDEX exists_opt index_name ON table_name */ - { 291, 0 }, /* (218) index_options ::= */ - { 291, -9 }, /* (219) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt */ - { 291, -11 }, /* (220) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt */ - { 292, -1 }, /* (221) func_list ::= func */ - { 292, -3 }, /* (222) func_list ::= func_list NK_COMMA func */ - { 295, -4 }, /* (223) func ::= function_name NK_LP expression_list NK_RP */ - { 240, -7 }, /* (224) cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS query_expression */ - { 240, -7 }, /* (225) cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS db_name */ - { 240, -4 }, /* (226) cmd ::= DROP TOPIC exists_opt topic_name */ - { 240, -6 }, /* (227) cmd ::= DROP CGROUP exists_opt cgroup_name ON topic_name */ - { 298, 0 }, /* (228) topic_options ::= */ - { 298, -3 }, /* (229) topic_options ::= topic_options WITH TABLE */ - { 298, -3 }, /* (230) topic_options ::= topic_options WITH SCHEMA */ - { 298, -3 }, /* (231) topic_options ::= topic_options WITH TAG */ - { 240, -2 }, /* (232) cmd ::= DESC full_table_name */ - { 240, -2 }, /* (233) cmd ::= DESCRIBE full_table_name */ - { 240, -3 }, /* (234) cmd ::= RESET QUERY CACHE */ - { 240, -4 }, /* (235) cmd ::= EXPLAIN analyze_opt explain_options query_expression */ - { 301, 0 }, /* (236) analyze_opt ::= */ - { 301, -1 }, /* (237) analyze_opt ::= ANALYZE */ - { 302, 0 }, /* (238) explain_options ::= */ - { 302, -3 }, /* (239) explain_options ::= explain_options VERBOSE NK_BOOL */ - { 302, -3 }, /* (240) explain_options ::= explain_options RATIO NK_FLOAT */ - { 240, -6 }, /* (241) cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP */ - { 240, -10 }, /* (242) cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */ - { 240, -4 }, /* (243) cmd ::= DROP FUNCTION exists_opt function_name */ - { 303, 0 }, /* (244) agg_func_opt ::= */ - { 303, -1 }, /* (245) agg_func_opt ::= AGGREGATE */ - { 304, 0 }, /* (246) bufsize_opt ::= */ - { 304, -2 }, /* (247) bufsize_opt ::= BUFSIZE NK_INTEGER */ - { 240, -8 }, /* (248) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression */ - { 240, -4 }, /* (249) cmd ::= DROP STREAM exists_opt stream_name */ - { 307, 0 }, /* (250) into_opt ::= */ - { 307, -2 }, /* (251) into_opt ::= INTO full_table_name */ - { 306, 0 }, /* (252) stream_options ::= */ - { 306, -3 }, /* (253) stream_options ::= stream_options TRIGGER AT_ONCE */ - { 306, -3 }, /* (254) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ - { 306, -3 }, /* (255) stream_options ::= stream_options WATERMARK duration_literal */ - { 240, -3 }, /* (256) cmd ::= KILL CONNECTION NK_INTEGER */ - { 240, -3 }, /* (257) cmd ::= KILL QUERY NK_INTEGER */ - { 240, -3 }, /* (258) cmd ::= KILL TRANSACTION NK_INTEGER */ - { 240, -4 }, /* (259) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ - { 240, -4 }, /* (260) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ - { 240, -3 }, /* (261) cmd ::= SPLIT VGROUP NK_INTEGER */ - { 308, -2 }, /* (262) dnode_list ::= DNODE NK_INTEGER */ - { 308, -3 }, /* (263) dnode_list ::= dnode_list DNODE NK_INTEGER */ - { 240, -3 }, /* (264) cmd ::= SYNCDB db_name REPLICA */ - { 240, -1 }, /* (265) cmd ::= query_expression */ - { 243, -1 }, /* (266) literal ::= NK_INTEGER */ - { 243, -1 }, /* (267) literal ::= NK_FLOAT */ - { 243, -1 }, /* (268) literal ::= NK_STRING */ - { 243, -1 }, /* (269) literal ::= NK_BOOL */ - { 243, -2 }, /* (270) literal ::= TIMESTAMP NK_STRING */ - { 243, -1 }, /* (271) literal ::= duration_literal */ - { 243, -1 }, /* (272) literal ::= NULL */ - { 243, -1 }, /* (273) literal ::= NK_QUESTION */ - { 293, -1 }, /* (274) duration_literal ::= NK_VARIABLE */ - { 309, -1 }, /* (275) signed ::= NK_INTEGER */ - { 309, -2 }, /* (276) signed ::= NK_PLUS NK_INTEGER */ - { 309, -2 }, /* (277) signed ::= NK_MINUS NK_INTEGER */ - { 309, -1 }, /* (278) signed ::= NK_FLOAT */ - { 309, -2 }, /* (279) signed ::= NK_PLUS NK_FLOAT */ - { 309, -2 }, /* (280) signed ::= NK_MINUS NK_FLOAT */ - { 273, -1 }, /* (281) signed_literal ::= signed */ - { 273, -1 }, /* (282) signed_literal ::= NK_STRING */ - { 273, -1 }, /* (283) signed_literal ::= NK_BOOL */ - { 273, -2 }, /* (284) signed_literal ::= TIMESTAMP NK_STRING */ - { 273, -1 }, /* (285) signed_literal ::= duration_literal */ - { 273, -1 }, /* (286) signed_literal ::= NULL */ - { 273, -1 }, /* (287) signed_literal ::= literal_func */ - { 276, -1 }, /* (288) literal_list ::= signed_literal */ - { 276, -3 }, /* (289) literal_list ::= literal_list NK_COMMA signed_literal */ - { 250, -1 }, /* (290) db_name ::= NK_ID */ - { 279, -1 }, /* (291) table_name ::= NK_ID */ - { 271, -1 }, /* (292) column_name ::= NK_ID */ - { 289, -1 }, /* (293) function_name ::= NK_ID */ - { 311, -1 }, /* (294) table_alias ::= NK_ID */ - { 312, -1 }, /* (295) column_alias ::= NK_ID */ - { 245, -1 }, /* (296) user_name ::= NK_ID */ - { 290, -1 }, /* (297) index_name ::= NK_ID */ - { 297, -1 }, /* (298) topic_name ::= NK_ID */ - { 305, -1 }, /* (299) stream_name ::= NK_ID */ - { 300, -1 }, /* (300) cgroup_name ::= NK_ID */ - { 313, -1 }, /* (301) expression ::= literal */ - { 313, -1 }, /* (302) expression ::= pseudo_column */ - { 313, -1 }, /* (303) expression ::= column_reference */ - { 313, -1 }, /* (304) expression ::= function_expression */ - { 313, -1 }, /* (305) expression ::= subquery */ - { 313, -3 }, /* (306) expression ::= NK_LP expression NK_RP */ - { 313, -2 }, /* (307) expression ::= NK_PLUS expression */ - { 313, -2 }, /* (308) expression ::= NK_MINUS expression */ - { 313, -3 }, /* (309) expression ::= expression NK_PLUS expression */ - { 313, -3 }, /* (310) expression ::= expression NK_MINUS expression */ - { 313, -3 }, /* (311) expression ::= expression NK_STAR expression */ - { 313, -3 }, /* (312) expression ::= expression NK_SLASH expression */ - { 313, -3 }, /* (313) expression ::= expression NK_REM expression */ - { 313, -3 }, /* (314) expression ::= column_reference NK_ARROW NK_STRING */ - { 296, -1 }, /* (315) expression_list ::= expression */ - { 296, -3 }, /* (316) expression_list ::= expression_list NK_COMMA expression */ - { 315, -1 }, /* (317) column_reference ::= column_name */ - { 315, -3 }, /* (318) column_reference ::= table_name NK_DOT column_name */ - { 314, -1 }, /* (319) pseudo_column ::= ROWTS */ - { 314, -1 }, /* (320) pseudo_column ::= TBNAME */ - { 314, -3 }, /* (321) pseudo_column ::= table_name NK_DOT TBNAME */ - { 314, -1 }, /* (322) pseudo_column ::= QSTARTTS */ - { 314, -1 }, /* (323) pseudo_column ::= QENDTS */ - { 314, -1 }, /* (324) pseudo_column ::= WSTARTTS */ - { 314, -1 }, /* (325) pseudo_column ::= WENDTS */ - { 314, -1 }, /* (326) pseudo_column ::= WDURATION */ - { 316, -4 }, /* (327) function_expression ::= function_name NK_LP expression_list NK_RP */ - { 316, -4 }, /* (328) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ - { 316, -6 }, /* (329) function_expression ::= CAST NK_LP expression AS type_name NK_RP */ - { 316, -1 }, /* (330) function_expression ::= literal_func */ - { 310, -3 }, /* (331) literal_func ::= noarg_func NK_LP NK_RP */ - { 310, -1 }, /* (332) literal_func ::= NOW */ - { 320, -1 }, /* (333) noarg_func ::= NOW */ - { 320, -1 }, /* (334) noarg_func ::= TODAY */ - { 320, -1 }, /* (335) noarg_func ::= TIMEZONE */ - { 318, -1 }, /* (336) star_func ::= COUNT */ - { 318, -1 }, /* (337) star_func ::= FIRST */ - { 318, -1 }, /* (338) star_func ::= LAST */ - { 318, -1 }, /* (339) star_func ::= LAST_ROW */ - { 319, -1 }, /* (340) star_func_para_list ::= NK_STAR */ - { 319, -1 }, /* (341) star_func_para_list ::= other_para_list */ - { 321, -1 }, /* (342) other_para_list ::= star_func_para */ - { 321, -3 }, /* (343) other_para_list ::= other_para_list NK_COMMA star_func_para */ - { 322, -1 }, /* (344) star_func_para ::= expression */ - { 322, -3 }, /* (345) star_func_para ::= table_name NK_DOT NK_STAR */ - { 323, -3 }, /* (346) predicate ::= expression compare_op expression */ - { 323, -5 }, /* (347) predicate ::= expression BETWEEN expression AND expression */ - { 323, -6 }, /* (348) predicate ::= expression NOT BETWEEN expression AND expression */ - { 323, -3 }, /* (349) predicate ::= expression IS NULL */ - { 323, -4 }, /* (350) predicate ::= expression IS NOT NULL */ - { 323, -3 }, /* (351) predicate ::= expression in_op in_predicate_value */ - { 324, -1 }, /* (352) compare_op ::= NK_LT */ - { 324, -1 }, /* (353) compare_op ::= NK_GT */ - { 324, -1 }, /* (354) compare_op ::= NK_LE */ - { 324, -1 }, /* (355) compare_op ::= NK_GE */ - { 324, -1 }, /* (356) compare_op ::= NK_NE */ - { 324, -1 }, /* (357) compare_op ::= NK_EQ */ - { 324, -1 }, /* (358) compare_op ::= LIKE */ - { 324, -2 }, /* (359) compare_op ::= NOT LIKE */ - { 324, -1 }, /* (360) compare_op ::= MATCH */ - { 324, -1 }, /* (361) compare_op ::= NMATCH */ - { 324, -1 }, /* (362) compare_op ::= CONTAINS */ - { 325, -1 }, /* (363) in_op ::= IN */ - { 325, -2 }, /* (364) in_op ::= NOT IN */ - { 326, -3 }, /* (365) in_predicate_value ::= NK_LP expression_list NK_RP */ - { 327, -1 }, /* (366) boolean_value_expression ::= boolean_primary */ - { 327, -2 }, /* (367) boolean_value_expression ::= NOT boolean_primary */ - { 327, -3 }, /* (368) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ - { 327, -3 }, /* (369) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ - { 328, -1 }, /* (370) boolean_primary ::= predicate */ - { 328, -3 }, /* (371) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ - { 329, -1 }, /* (372) common_expression ::= expression */ - { 329, -1 }, /* (373) common_expression ::= boolean_value_expression */ - { 330, -2 }, /* (374) from_clause ::= FROM table_reference_list */ - { 331, -1 }, /* (375) table_reference_list ::= table_reference */ - { 331, -3 }, /* (376) table_reference_list ::= table_reference_list NK_COMMA table_reference */ - { 332, -1 }, /* (377) table_reference ::= table_primary */ - { 332, -1 }, /* (378) table_reference ::= joined_table */ - { 333, -2 }, /* (379) table_primary ::= table_name alias_opt */ - { 333, -4 }, /* (380) table_primary ::= db_name NK_DOT table_name alias_opt */ - { 333, -2 }, /* (381) table_primary ::= subquery alias_opt */ - { 333, -1 }, /* (382) table_primary ::= parenthesized_joined_table */ - { 335, 0 }, /* (383) alias_opt ::= */ - { 335, -1 }, /* (384) alias_opt ::= table_alias */ - { 335, -2 }, /* (385) alias_opt ::= AS table_alias */ - { 336, -3 }, /* (386) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - { 336, -3 }, /* (387) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ - { 334, -6 }, /* (388) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ - { 337, 0 }, /* (389) join_type ::= */ - { 337, -1 }, /* (390) join_type ::= INNER */ - { 339, -9 }, /* (391) query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ - { 340, 0 }, /* (392) set_quantifier_opt ::= */ - { 340, -1 }, /* (393) set_quantifier_opt ::= DISTINCT */ - { 340, -1 }, /* (394) set_quantifier_opt ::= ALL */ - { 341, -1 }, /* (395) select_list ::= NK_STAR */ - { 341, -1 }, /* (396) select_list ::= select_sublist */ - { 347, -1 }, /* (397) select_sublist ::= select_item */ - { 347, -3 }, /* (398) select_sublist ::= select_sublist NK_COMMA select_item */ - { 348, -1 }, /* (399) select_item ::= common_expression */ - { 348, -2 }, /* (400) select_item ::= common_expression column_alias */ - { 348, -3 }, /* (401) select_item ::= common_expression AS column_alias */ - { 348, -3 }, /* (402) select_item ::= table_name NK_DOT NK_STAR */ - { 342, 0 }, /* (403) where_clause_opt ::= */ - { 342, -2 }, /* (404) where_clause_opt ::= WHERE search_condition */ - { 343, 0 }, /* (405) partition_by_clause_opt ::= */ - { 343, -3 }, /* (406) partition_by_clause_opt ::= PARTITION BY expression_list */ - { 344, 0 }, /* (407) twindow_clause_opt ::= */ - { 344, -6 }, /* (408) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ - { 344, -4 }, /* (409) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */ - { 344, -6 }, /* (410) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ - { 344, -8 }, /* (411) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ - { 294, 0 }, /* (412) sliding_opt ::= */ - { 294, -4 }, /* (413) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ - { 349, 0 }, /* (414) fill_opt ::= */ - { 349, -4 }, /* (415) fill_opt ::= FILL NK_LP fill_mode NK_RP */ - { 349, -6 }, /* (416) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ - { 350, -1 }, /* (417) fill_mode ::= NONE */ - { 350, -1 }, /* (418) fill_mode ::= PREV */ - { 350, -1 }, /* (419) fill_mode ::= NULL */ - { 350, -1 }, /* (420) fill_mode ::= LINEAR */ - { 350, -1 }, /* (421) fill_mode ::= NEXT */ - { 345, 0 }, /* (422) group_by_clause_opt ::= */ - { 345, -3 }, /* (423) group_by_clause_opt ::= GROUP BY group_by_list */ - { 351, -1 }, /* (424) group_by_list ::= expression */ - { 351, -3 }, /* (425) group_by_list ::= group_by_list NK_COMMA expression */ - { 346, 0 }, /* (426) having_clause_opt ::= */ - { 346, -2 }, /* (427) having_clause_opt ::= HAVING search_condition */ - { 299, -4 }, /* (428) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ - { 352, -1 }, /* (429) query_expression_body ::= query_primary */ - { 352, -4 }, /* (430) query_expression_body ::= query_expression_body UNION ALL query_expression_body */ - { 352, -3 }, /* (431) query_expression_body ::= query_expression_body UNION query_expression_body */ - { 356, -1 }, /* (432) query_primary ::= query_specification */ - { 356, -6 }, /* (433) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */ - { 353, 0 }, /* (434) order_by_clause_opt ::= */ - { 353, -3 }, /* (435) order_by_clause_opt ::= ORDER BY sort_specification_list */ - { 354, 0 }, /* (436) slimit_clause_opt ::= */ - { 354, -2 }, /* (437) slimit_clause_opt ::= SLIMIT NK_INTEGER */ - { 354, -4 }, /* (438) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - { 354, -4 }, /* (439) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - { 355, 0 }, /* (440) limit_clause_opt ::= */ - { 355, -2 }, /* (441) limit_clause_opt ::= LIMIT NK_INTEGER */ - { 355, -4 }, /* (442) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ - { 355, -4 }, /* (443) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - { 317, -3 }, /* (444) subquery ::= NK_LP query_expression NK_RP */ - { 338, -1 }, /* (445) search_condition ::= common_expression */ - { 357, -1 }, /* (446) sort_specification_list ::= sort_specification */ - { 357, -3 }, /* (447) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ - { 358, -3 }, /* (448) sort_specification ::= expression ordering_specification_opt null_ordering_opt */ - { 359, 0 }, /* (449) ordering_specification_opt ::= */ - { 359, -1 }, /* (450) ordering_specification_opt ::= ASC */ - { 359, -1 }, /* (451) ordering_specification_opt ::= DESC */ - { 360, 0 }, /* (452) null_ordering_opt ::= */ - { 360, -2 }, /* (453) null_ordering_opt ::= NULLS FIRST */ - { 360, -2 }, /* (454) null_ordering_opt ::= NULLS LAST */ + { 238, -6 }, /* (0) cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */ + { 238, -4 }, /* (1) cmd ::= ALTER ACCOUNT NK_ID alter_account_options */ + { 239, 0 }, /* (2) account_options ::= */ + { 239, -3 }, /* (3) account_options ::= account_options PPS literal */ + { 239, -3 }, /* (4) account_options ::= account_options TSERIES literal */ + { 239, -3 }, /* (5) account_options ::= account_options STORAGE literal */ + { 239, -3 }, /* (6) account_options ::= account_options STREAMS literal */ + { 239, -3 }, /* (7) account_options ::= account_options QTIME literal */ + { 239, -3 }, /* (8) account_options ::= account_options DBS literal */ + { 239, -3 }, /* (9) account_options ::= account_options USERS literal */ + { 239, -3 }, /* (10) account_options ::= account_options CONNS literal */ + { 239, -3 }, /* (11) account_options ::= account_options STATE literal */ + { 240, -1 }, /* (12) alter_account_options ::= alter_account_option */ + { 240, -2 }, /* (13) alter_account_options ::= alter_account_options alter_account_option */ + { 242, -2 }, /* (14) alter_account_option ::= PASS literal */ + { 242, -2 }, /* (15) alter_account_option ::= PPS literal */ + { 242, -2 }, /* (16) alter_account_option ::= TSERIES literal */ + { 242, -2 }, /* (17) alter_account_option ::= STORAGE literal */ + { 242, -2 }, /* (18) alter_account_option ::= STREAMS literal */ + { 242, -2 }, /* (19) alter_account_option ::= QTIME literal */ + { 242, -2 }, /* (20) alter_account_option ::= DBS literal */ + { 242, -2 }, /* (21) alter_account_option ::= USERS literal */ + { 242, -2 }, /* (22) alter_account_option ::= CONNS literal */ + { 242, -2 }, /* (23) alter_account_option ::= STATE literal */ + { 238, -5 }, /* (24) cmd ::= CREATE USER user_name PASS NK_STRING */ + { 238, -5 }, /* (25) cmd ::= ALTER USER user_name PASS NK_STRING */ + { 238, -5 }, /* (26) cmd ::= ALTER USER user_name PRIVILEGE NK_STRING */ + { 238, -3 }, /* (27) cmd ::= DROP USER user_name */ + { 238, -6 }, /* (28) cmd ::= GRANT privileges ON priv_level TO user_name */ + { 238, -6 }, /* (29) cmd ::= REVOKE privileges ON priv_level FROM user_name */ + { 244, -1 }, /* (30) privileges ::= ALL */ + { 244, -1 }, /* (31) privileges ::= priv_type_list */ + { 246, -1 }, /* (32) priv_type_list ::= priv_type */ + { 246, -3 }, /* (33) priv_type_list ::= priv_type_list NK_COMMA priv_type */ + { 247, -1 }, /* (34) priv_type ::= READ */ + { 247, -1 }, /* (35) priv_type ::= WRITE */ + { 245, -3 }, /* (36) priv_level ::= NK_STAR NK_DOT NK_STAR */ + { 245, -3 }, /* (37) priv_level ::= db_name NK_DOT NK_STAR */ + { 238, -3 }, /* (38) cmd ::= CREATE DNODE dnode_endpoint */ + { 238, -5 }, /* (39) cmd ::= CREATE DNODE dnode_host_name PORT NK_INTEGER */ + { 238, -3 }, /* (40) cmd ::= DROP DNODE NK_INTEGER */ + { 238, -3 }, /* (41) cmd ::= DROP DNODE dnode_endpoint */ + { 238, -4 }, /* (42) cmd ::= ALTER DNODE NK_INTEGER NK_STRING */ + { 238, -5 }, /* (43) cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */ + { 238, -4 }, /* (44) cmd ::= ALTER ALL DNODES NK_STRING */ + { 238, -5 }, /* (45) cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */ + { 249, -1 }, /* (46) dnode_endpoint ::= NK_STRING */ + { 250, -1 }, /* (47) dnode_host_name ::= NK_ID */ + { 250, -1 }, /* (48) dnode_host_name ::= NK_IPTOKEN */ + { 238, -3 }, /* (49) cmd ::= ALTER LOCAL NK_STRING */ + { 238, -4 }, /* (50) cmd ::= ALTER LOCAL NK_STRING NK_STRING */ + { 238, -5 }, /* (51) cmd ::= CREATE QNODE ON DNODE NK_INTEGER */ + { 238, -5 }, /* (52) cmd ::= DROP QNODE ON DNODE NK_INTEGER */ + { 238, -5 }, /* (53) cmd ::= CREATE BNODE ON DNODE NK_INTEGER */ + { 238, -5 }, /* (54) cmd ::= DROP BNODE ON DNODE NK_INTEGER */ + { 238, -5 }, /* (55) cmd ::= CREATE SNODE ON DNODE NK_INTEGER */ + { 238, -5 }, /* (56) cmd ::= DROP SNODE ON DNODE NK_INTEGER */ + { 238, -5 }, /* (57) cmd ::= CREATE MNODE ON DNODE NK_INTEGER */ + { 238, -5 }, /* (58) cmd ::= DROP MNODE ON DNODE NK_INTEGER */ + { 238, -5 }, /* (59) cmd ::= CREATE DATABASE not_exists_opt db_name db_options */ + { 238, -4 }, /* (60) cmd ::= DROP DATABASE exists_opt db_name */ + { 238, -2 }, /* (61) cmd ::= USE db_name */ + { 238, -4 }, /* (62) cmd ::= ALTER DATABASE db_name alter_db_options */ + { 251, -3 }, /* (63) not_exists_opt ::= IF NOT EXISTS */ + { 251, 0 }, /* (64) not_exists_opt ::= */ + { 253, -2 }, /* (65) exists_opt ::= IF EXISTS */ + { 253, 0 }, /* (66) exists_opt ::= */ + { 252, 0 }, /* (67) db_options ::= */ + { 252, -3 }, /* (68) db_options ::= db_options BUFFER NK_INTEGER */ + { 252, -3 }, /* (69) db_options ::= db_options CACHELAST NK_INTEGER */ + { 252, -3 }, /* (70) db_options ::= db_options COMP NK_INTEGER */ + { 252, -3 }, /* (71) db_options ::= db_options DAYS NK_INTEGER */ + { 252, -3 }, /* (72) db_options ::= db_options DAYS NK_VARIABLE */ + { 252, -3 }, /* (73) db_options ::= db_options FSYNC NK_INTEGER */ + { 252, -3 }, /* (74) db_options ::= db_options MAXROWS NK_INTEGER */ + { 252, -3 }, /* (75) db_options ::= db_options MINROWS NK_INTEGER */ + { 252, -3 }, /* (76) db_options ::= db_options KEEP integer_list */ + { 252, -3 }, /* (77) db_options ::= db_options KEEP variable_list */ + { 252, -3 }, /* (78) db_options ::= db_options PAGES NK_INTEGER */ + { 252, -3 }, /* (79) db_options ::= db_options PAGESIZE NK_INTEGER */ + { 252, -3 }, /* (80) db_options ::= db_options PRECISION NK_STRING */ + { 252, -3 }, /* (81) db_options ::= db_options REPLICA NK_INTEGER */ + { 252, -3 }, /* (82) db_options ::= db_options STRICT NK_INTEGER */ + { 252, -3 }, /* (83) db_options ::= db_options WAL NK_INTEGER */ + { 252, -3 }, /* (84) db_options ::= db_options VGROUPS NK_INTEGER */ + { 252, -3 }, /* (85) db_options ::= db_options SINGLE_STABLE NK_INTEGER */ + { 252, -3 }, /* (86) db_options ::= db_options RETENTIONS retention_list */ + { 252, -3 }, /* (87) db_options ::= db_options SCHEMALESS NK_INTEGER */ + { 254, -1 }, /* (88) alter_db_options ::= alter_db_option */ + { 254, -2 }, /* (89) alter_db_options ::= alter_db_options alter_db_option */ + { 258, -2 }, /* (90) alter_db_option ::= BUFFER NK_INTEGER */ + { 258, -2 }, /* (91) alter_db_option ::= CACHELAST NK_INTEGER */ + { 258, -2 }, /* (92) alter_db_option ::= FSYNC NK_INTEGER */ + { 258, -2 }, /* (93) alter_db_option ::= KEEP integer_list */ + { 258, -2 }, /* (94) alter_db_option ::= KEEP variable_list */ + { 258, -2 }, /* (95) alter_db_option ::= PAGES NK_INTEGER */ + { 258, -2 }, /* (96) alter_db_option ::= REPLICA NK_INTEGER */ + { 258, -2 }, /* (97) alter_db_option ::= STRICT NK_INTEGER */ + { 258, -2 }, /* (98) alter_db_option ::= WAL NK_INTEGER */ + { 255, -1 }, /* (99) integer_list ::= NK_INTEGER */ + { 255, -3 }, /* (100) integer_list ::= integer_list NK_COMMA NK_INTEGER */ + { 256, -1 }, /* (101) variable_list ::= NK_VARIABLE */ + { 256, -3 }, /* (102) variable_list ::= variable_list NK_COMMA NK_VARIABLE */ + { 257, -1 }, /* (103) retention_list ::= retention */ + { 257, -3 }, /* (104) retention_list ::= retention_list NK_COMMA retention */ + { 259, -3 }, /* (105) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ + { 238, -9 }, /* (106) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ + { 238, -3 }, /* (107) cmd ::= CREATE TABLE multi_create_clause */ + { 238, -9 }, /* (108) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ + { 238, -3 }, /* (109) cmd ::= DROP TABLE multi_drop_clause */ + { 238, -4 }, /* (110) cmd ::= DROP STABLE exists_opt full_table_name */ + { 238, -3 }, /* (111) cmd ::= ALTER TABLE alter_table_clause */ + { 238, -3 }, /* (112) cmd ::= ALTER STABLE alter_table_clause */ + { 267, -2 }, /* (113) alter_table_clause ::= full_table_name alter_table_options */ + { 267, -5 }, /* (114) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ + { 267, -4 }, /* (115) alter_table_clause ::= full_table_name DROP COLUMN column_name */ + { 267, -5 }, /* (116) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ + { 267, -5 }, /* (117) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ + { 267, -5 }, /* (118) alter_table_clause ::= full_table_name ADD TAG column_name type_name */ + { 267, -4 }, /* (119) alter_table_clause ::= full_table_name DROP TAG column_name */ + { 267, -5 }, /* (120) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ + { 267, -5 }, /* (121) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ + { 267, -6 }, /* (122) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ + { 264, -1 }, /* (123) multi_create_clause ::= create_subtable_clause */ + { 264, -2 }, /* (124) multi_create_clause ::= multi_create_clause create_subtable_clause */ + { 272, -10 }, /* (125) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP literal_list NK_RP table_options */ + { 266, -1 }, /* (126) multi_drop_clause ::= drop_table_clause */ + { 266, -2 }, /* (127) multi_drop_clause ::= multi_drop_clause drop_table_clause */ + { 275, -2 }, /* (128) drop_table_clause ::= exists_opt full_table_name */ + { 273, 0 }, /* (129) specific_tags_opt ::= */ + { 273, -3 }, /* (130) specific_tags_opt ::= NK_LP col_name_list NK_RP */ + { 260, -1 }, /* (131) full_table_name ::= table_name */ + { 260, -3 }, /* (132) full_table_name ::= db_name NK_DOT table_name */ + { 261, -1 }, /* (133) column_def_list ::= column_def */ + { 261, -3 }, /* (134) column_def_list ::= column_def_list NK_COMMA column_def */ + { 278, -2 }, /* (135) column_def ::= column_name type_name */ + { 278, -4 }, /* (136) column_def ::= column_name type_name COMMENT NK_STRING */ + { 270, -1 }, /* (137) type_name ::= BOOL */ + { 270, -1 }, /* (138) type_name ::= TINYINT */ + { 270, -1 }, /* (139) type_name ::= SMALLINT */ + { 270, -1 }, /* (140) type_name ::= INT */ + { 270, -1 }, /* (141) type_name ::= INTEGER */ + { 270, -1 }, /* (142) type_name ::= BIGINT */ + { 270, -1 }, /* (143) type_name ::= FLOAT */ + { 270, -1 }, /* (144) type_name ::= DOUBLE */ + { 270, -4 }, /* (145) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ + { 270, -1 }, /* (146) type_name ::= TIMESTAMP */ + { 270, -4 }, /* (147) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ + { 270, -2 }, /* (148) type_name ::= TINYINT UNSIGNED */ + { 270, -2 }, /* (149) type_name ::= SMALLINT UNSIGNED */ + { 270, -2 }, /* (150) type_name ::= INT UNSIGNED */ + { 270, -2 }, /* (151) type_name ::= BIGINT UNSIGNED */ + { 270, -1 }, /* (152) type_name ::= JSON */ + { 270, -4 }, /* (153) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ + { 270, -1 }, /* (154) type_name ::= MEDIUMBLOB */ + { 270, -1 }, /* (155) type_name ::= BLOB */ + { 270, -4 }, /* (156) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ + { 270, -1 }, /* (157) type_name ::= DECIMAL */ + { 270, -4 }, /* (158) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ + { 270, -6 }, /* (159) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ + { 262, 0 }, /* (160) tags_def_opt ::= */ + { 262, -1 }, /* (161) tags_def_opt ::= tags_def */ + { 265, -4 }, /* (162) tags_def ::= TAGS NK_LP column_def_list NK_RP */ + { 263, 0 }, /* (163) table_options ::= */ + { 263, -3 }, /* (164) table_options ::= table_options COMMENT NK_STRING */ + { 263, -3 }, /* (165) table_options ::= table_options DELAY NK_INTEGER */ + { 263, -3 }, /* (166) table_options ::= table_options FILE_FACTOR NK_FLOAT */ + { 263, -5 }, /* (167) table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP */ + { 263, -3 }, /* (168) table_options ::= table_options TTL NK_INTEGER */ + { 263, -5 }, /* (169) table_options ::= table_options SMA NK_LP col_name_list NK_RP */ + { 268, -1 }, /* (170) alter_table_options ::= alter_table_option */ + { 268, -2 }, /* (171) alter_table_options ::= alter_table_options alter_table_option */ + { 280, -2 }, /* (172) alter_table_option ::= COMMENT NK_STRING */ + { 280, -2 }, /* (173) alter_table_option ::= TTL NK_INTEGER */ + { 276, -1 }, /* (174) col_name_list ::= col_name */ + { 276, -3 }, /* (175) col_name_list ::= col_name_list NK_COMMA col_name */ + { 281, -1 }, /* (176) col_name ::= column_name */ + { 238, -2 }, /* (177) cmd ::= SHOW DNODES */ + { 238, -2 }, /* (178) cmd ::= SHOW USERS */ + { 238, -2 }, /* (179) cmd ::= SHOW DATABASES */ + { 238, -4 }, /* (180) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */ + { 238, -4 }, /* (181) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ + { 238, -3 }, /* (182) cmd ::= SHOW db_name_cond_opt VGROUPS */ + { 238, -2 }, /* (183) cmd ::= SHOW MNODES */ + { 238, -2 }, /* (184) cmd ::= SHOW MODULES */ + { 238, -2 }, /* (185) cmd ::= SHOW QNODES */ + { 238, -2 }, /* (186) cmd ::= SHOW FUNCTIONS */ + { 238, -5 }, /* (187) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ + { 238, -2 }, /* (188) cmd ::= SHOW STREAMS */ + { 238, -2 }, /* (189) cmd ::= SHOW ACCOUNTS */ + { 238, -2 }, /* (190) cmd ::= SHOW APPS */ + { 238, -2 }, /* (191) cmd ::= SHOW CONNECTIONS */ + { 238, -2 }, /* (192) cmd ::= SHOW LICENCE */ + { 238, -2 }, /* (193) cmd ::= SHOW GRANTS */ + { 238, -4 }, /* (194) cmd ::= SHOW CREATE DATABASE db_name */ + { 238, -4 }, /* (195) cmd ::= SHOW CREATE TABLE full_table_name */ + { 238, -4 }, /* (196) cmd ::= SHOW CREATE STABLE full_table_name */ + { 238, -2 }, /* (197) cmd ::= SHOW QUERIES */ + { 238, -2 }, /* (198) cmd ::= SHOW SCORES */ + { 238, -2 }, /* (199) cmd ::= SHOW TOPICS */ + { 238, -2 }, /* (200) cmd ::= SHOW VARIABLES */ + { 238, -2 }, /* (201) cmd ::= SHOW BNODES */ + { 238, -2 }, /* (202) cmd ::= SHOW SNODES */ + { 238, -2 }, /* (203) cmd ::= SHOW CLUSTER */ + { 238, -2 }, /* (204) cmd ::= SHOW TRANSACTIONS */ + { 282, 0 }, /* (205) db_name_cond_opt ::= */ + { 282, -2 }, /* (206) db_name_cond_opt ::= db_name NK_DOT */ + { 283, 0 }, /* (207) like_pattern_opt ::= */ + { 283, -2 }, /* (208) like_pattern_opt ::= LIKE NK_STRING */ + { 284, -1 }, /* (209) table_name_cond ::= table_name */ + { 285, 0 }, /* (210) from_db_opt ::= */ + { 285, -2 }, /* (211) from_db_opt ::= FROM db_name */ + { 279, -1 }, /* (212) func_name_list ::= func_name */ + { 279, -3 }, /* (213) func_name_list ::= func_name_list NK_COMMA func_name */ + { 286, -1 }, /* (214) func_name ::= function_name */ + { 238, -8 }, /* (215) cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options */ + { 238, -10 }, /* (216) cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP */ + { 238, -6 }, /* (217) cmd ::= DROP INDEX exists_opt index_name ON table_name */ + { 289, 0 }, /* (218) index_options ::= */ + { 289, -9 }, /* (219) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt */ + { 289, -11 }, /* (220) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt */ + { 290, -1 }, /* (221) func_list ::= func */ + { 290, -3 }, /* (222) func_list ::= func_list NK_COMMA func */ + { 293, -4 }, /* (223) func ::= function_name NK_LP expression_list NK_RP */ + { 238, -6 }, /* (224) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression */ + { 238, -7 }, /* (225) cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name */ + { 238, -7 }, /* (226) cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name */ + { 238, -4 }, /* (227) cmd ::= DROP TOPIC exists_opt topic_name */ + { 238, -6 }, /* (228) cmd ::= DROP CGROUP exists_opt cgroup_name ON topic_name */ + { 238, -2 }, /* (229) cmd ::= DESC full_table_name */ + { 238, -2 }, /* (230) cmd ::= DESCRIBE full_table_name */ + { 238, -3 }, /* (231) cmd ::= RESET QUERY CACHE */ + { 238, -4 }, /* (232) cmd ::= EXPLAIN analyze_opt explain_options query_expression */ + { 298, 0 }, /* (233) analyze_opt ::= */ + { 298, -1 }, /* (234) analyze_opt ::= ANALYZE */ + { 299, 0 }, /* (235) explain_options ::= */ + { 299, -3 }, /* (236) explain_options ::= explain_options VERBOSE NK_BOOL */ + { 299, -3 }, /* (237) explain_options ::= explain_options RATIO NK_FLOAT */ + { 238, -6 }, /* (238) cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP */ + { 238, -10 }, /* (239) cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */ + { 238, -4 }, /* (240) cmd ::= DROP FUNCTION exists_opt function_name */ + { 300, 0 }, /* (241) agg_func_opt ::= */ + { 300, -1 }, /* (242) agg_func_opt ::= AGGREGATE */ + { 301, 0 }, /* (243) bufsize_opt ::= */ + { 301, -2 }, /* (244) bufsize_opt ::= BUFSIZE NK_INTEGER */ + { 238, -8 }, /* (245) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression */ + { 238, -4 }, /* (246) cmd ::= DROP STREAM exists_opt stream_name */ + { 304, 0 }, /* (247) into_opt ::= */ + { 304, -2 }, /* (248) into_opt ::= INTO full_table_name */ + { 303, 0 }, /* (249) stream_options ::= */ + { 303, -3 }, /* (250) stream_options ::= stream_options TRIGGER AT_ONCE */ + { 303, -3 }, /* (251) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ + { 303, -3 }, /* (252) stream_options ::= stream_options WATERMARK duration_literal */ + { 238, -3 }, /* (253) cmd ::= KILL CONNECTION NK_INTEGER */ + { 238, -3 }, /* (254) cmd ::= KILL QUERY NK_INTEGER */ + { 238, -3 }, /* (255) cmd ::= KILL TRANSACTION NK_INTEGER */ + { 238, -4 }, /* (256) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ + { 238, -4 }, /* (257) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ + { 238, -3 }, /* (258) cmd ::= SPLIT VGROUP NK_INTEGER */ + { 305, -2 }, /* (259) dnode_list ::= DNODE NK_INTEGER */ + { 305, -3 }, /* (260) dnode_list ::= dnode_list DNODE NK_INTEGER */ + { 238, -3 }, /* (261) cmd ::= SYNCDB db_name REPLICA */ + { 238, -1 }, /* (262) cmd ::= query_expression */ + { 241, -1 }, /* (263) literal ::= NK_INTEGER */ + { 241, -1 }, /* (264) literal ::= NK_FLOAT */ + { 241, -1 }, /* (265) literal ::= NK_STRING */ + { 241, -1 }, /* (266) literal ::= NK_BOOL */ + { 241, -2 }, /* (267) literal ::= TIMESTAMP NK_STRING */ + { 241, -1 }, /* (268) literal ::= duration_literal */ + { 241, -1 }, /* (269) literal ::= NULL */ + { 241, -1 }, /* (270) literal ::= NK_QUESTION */ + { 291, -1 }, /* (271) duration_literal ::= NK_VARIABLE */ + { 306, -1 }, /* (272) signed ::= NK_INTEGER */ + { 306, -2 }, /* (273) signed ::= NK_PLUS NK_INTEGER */ + { 306, -2 }, /* (274) signed ::= NK_MINUS NK_INTEGER */ + { 306, -1 }, /* (275) signed ::= NK_FLOAT */ + { 306, -2 }, /* (276) signed ::= NK_PLUS NK_FLOAT */ + { 306, -2 }, /* (277) signed ::= NK_MINUS NK_FLOAT */ + { 271, -1 }, /* (278) signed_literal ::= signed */ + { 271, -1 }, /* (279) signed_literal ::= NK_STRING */ + { 271, -1 }, /* (280) signed_literal ::= NK_BOOL */ + { 271, -2 }, /* (281) signed_literal ::= TIMESTAMP NK_STRING */ + { 271, -1 }, /* (282) signed_literal ::= duration_literal */ + { 271, -1 }, /* (283) signed_literal ::= NULL */ + { 271, -1 }, /* (284) signed_literal ::= literal_func */ + { 274, -1 }, /* (285) literal_list ::= signed_literal */ + { 274, -3 }, /* (286) literal_list ::= literal_list NK_COMMA signed_literal */ + { 248, -1 }, /* (287) db_name ::= NK_ID */ + { 277, -1 }, /* (288) table_name ::= NK_ID */ + { 269, -1 }, /* (289) column_name ::= NK_ID */ + { 287, -1 }, /* (290) function_name ::= NK_ID */ + { 308, -1 }, /* (291) table_alias ::= NK_ID */ + { 309, -1 }, /* (292) column_alias ::= NK_ID */ + { 243, -1 }, /* (293) user_name ::= NK_ID */ + { 288, -1 }, /* (294) index_name ::= NK_ID */ + { 295, -1 }, /* (295) topic_name ::= NK_ID */ + { 302, -1 }, /* (296) stream_name ::= NK_ID */ + { 297, -1 }, /* (297) cgroup_name ::= NK_ID */ + { 310, -1 }, /* (298) expression ::= literal */ + { 310, -1 }, /* (299) expression ::= pseudo_column */ + { 310, -1 }, /* (300) expression ::= column_reference */ + { 310, -1 }, /* (301) expression ::= function_expression */ + { 310, -1 }, /* (302) expression ::= subquery */ + { 310, -3 }, /* (303) expression ::= NK_LP expression NK_RP */ + { 310, -2 }, /* (304) expression ::= NK_PLUS expression */ + { 310, -2 }, /* (305) expression ::= NK_MINUS expression */ + { 310, -3 }, /* (306) expression ::= expression NK_PLUS expression */ + { 310, -3 }, /* (307) expression ::= expression NK_MINUS expression */ + { 310, -3 }, /* (308) expression ::= expression NK_STAR expression */ + { 310, -3 }, /* (309) expression ::= expression NK_SLASH expression */ + { 310, -3 }, /* (310) expression ::= expression NK_REM expression */ + { 310, -3 }, /* (311) expression ::= column_reference NK_ARROW NK_STRING */ + { 294, -1 }, /* (312) expression_list ::= expression */ + { 294, -3 }, /* (313) expression_list ::= expression_list NK_COMMA expression */ + { 312, -1 }, /* (314) column_reference ::= column_name */ + { 312, -3 }, /* (315) column_reference ::= table_name NK_DOT column_name */ + { 311, -1 }, /* (316) pseudo_column ::= ROWTS */ + { 311, -1 }, /* (317) pseudo_column ::= TBNAME */ + { 311, -3 }, /* (318) pseudo_column ::= table_name NK_DOT TBNAME */ + { 311, -1 }, /* (319) pseudo_column ::= QSTARTTS */ + { 311, -1 }, /* (320) pseudo_column ::= QENDTS */ + { 311, -1 }, /* (321) pseudo_column ::= WSTARTTS */ + { 311, -1 }, /* (322) pseudo_column ::= WENDTS */ + { 311, -1 }, /* (323) pseudo_column ::= WDURATION */ + { 313, -4 }, /* (324) function_expression ::= function_name NK_LP expression_list NK_RP */ + { 313, -4 }, /* (325) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ + { 313, -6 }, /* (326) function_expression ::= CAST NK_LP expression AS type_name NK_RP */ + { 313, -1 }, /* (327) function_expression ::= literal_func */ + { 307, -3 }, /* (328) literal_func ::= noarg_func NK_LP NK_RP */ + { 307, -1 }, /* (329) literal_func ::= NOW */ + { 317, -1 }, /* (330) noarg_func ::= NOW */ + { 317, -1 }, /* (331) noarg_func ::= TODAY */ + { 317, -1 }, /* (332) noarg_func ::= TIMEZONE */ + { 315, -1 }, /* (333) star_func ::= COUNT */ + { 315, -1 }, /* (334) star_func ::= FIRST */ + { 315, -1 }, /* (335) star_func ::= LAST */ + { 315, -1 }, /* (336) star_func ::= LAST_ROW */ + { 316, -1 }, /* (337) star_func_para_list ::= NK_STAR */ + { 316, -1 }, /* (338) star_func_para_list ::= other_para_list */ + { 318, -1 }, /* (339) other_para_list ::= star_func_para */ + { 318, -3 }, /* (340) other_para_list ::= other_para_list NK_COMMA star_func_para */ + { 319, -1 }, /* (341) star_func_para ::= expression */ + { 319, -3 }, /* (342) star_func_para ::= table_name NK_DOT NK_STAR */ + { 320, -3 }, /* (343) predicate ::= expression compare_op expression */ + { 320, -5 }, /* (344) predicate ::= expression BETWEEN expression AND expression */ + { 320, -6 }, /* (345) predicate ::= expression NOT BETWEEN expression AND expression */ + { 320, -3 }, /* (346) predicate ::= expression IS NULL */ + { 320, -4 }, /* (347) predicate ::= expression IS NOT NULL */ + { 320, -3 }, /* (348) predicate ::= expression in_op in_predicate_value */ + { 321, -1 }, /* (349) compare_op ::= NK_LT */ + { 321, -1 }, /* (350) compare_op ::= NK_GT */ + { 321, -1 }, /* (351) compare_op ::= NK_LE */ + { 321, -1 }, /* (352) compare_op ::= NK_GE */ + { 321, -1 }, /* (353) compare_op ::= NK_NE */ + { 321, -1 }, /* (354) compare_op ::= NK_EQ */ + { 321, -1 }, /* (355) compare_op ::= LIKE */ + { 321, -2 }, /* (356) compare_op ::= NOT LIKE */ + { 321, -1 }, /* (357) compare_op ::= MATCH */ + { 321, -1 }, /* (358) compare_op ::= NMATCH */ + { 321, -1 }, /* (359) compare_op ::= CONTAINS */ + { 322, -1 }, /* (360) in_op ::= IN */ + { 322, -2 }, /* (361) in_op ::= NOT IN */ + { 323, -3 }, /* (362) in_predicate_value ::= NK_LP expression_list NK_RP */ + { 324, -1 }, /* (363) boolean_value_expression ::= boolean_primary */ + { 324, -2 }, /* (364) boolean_value_expression ::= NOT boolean_primary */ + { 324, -3 }, /* (365) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ + { 324, -3 }, /* (366) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ + { 325, -1 }, /* (367) boolean_primary ::= predicate */ + { 325, -3 }, /* (368) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ + { 326, -1 }, /* (369) common_expression ::= expression */ + { 326, -1 }, /* (370) common_expression ::= boolean_value_expression */ + { 327, -2 }, /* (371) from_clause ::= FROM table_reference_list */ + { 328, -1 }, /* (372) table_reference_list ::= table_reference */ + { 328, -3 }, /* (373) table_reference_list ::= table_reference_list NK_COMMA table_reference */ + { 329, -1 }, /* (374) table_reference ::= table_primary */ + { 329, -1 }, /* (375) table_reference ::= joined_table */ + { 330, -2 }, /* (376) table_primary ::= table_name alias_opt */ + { 330, -4 }, /* (377) table_primary ::= db_name NK_DOT table_name alias_opt */ + { 330, -2 }, /* (378) table_primary ::= subquery alias_opt */ + { 330, -1 }, /* (379) table_primary ::= parenthesized_joined_table */ + { 332, 0 }, /* (380) alias_opt ::= */ + { 332, -1 }, /* (381) alias_opt ::= table_alias */ + { 332, -2 }, /* (382) alias_opt ::= AS table_alias */ + { 333, -3 }, /* (383) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ + { 333, -3 }, /* (384) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ + { 331, -6 }, /* (385) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ + { 334, 0 }, /* (386) join_type ::= */ + { 334, -1 }, /* (387) join_type ::= INNER */ + { 336, -9 }, /* (388) query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ + { 337, 0 }, /* (389) set_quantifier_opt ::= */ + { 337, -1 }, /* (390) set_quantifier_opt ::= DISTINCT */ + { 337, -1 }, /* (391) set_quantifier_opt ::= ALL */ + { 338, -1 }, /* (392) select_list ::= NK_STAR */ + { 338, -1 }, /* (393) select_list ::= select_sublist */ + { 344, -1 }, /* (394) select_sublist ::= select_item */ + { 344, -3 }, /* (395) select_sublist ::= select_sublist NK_COMMA select_item */ + { 345, -1 }, /* (396) select_item ::= common_expression */ + { 345, -2 }, /* (397) select_item ::= common_expression column_alias */ + { 345, -3 }, /* (398) select_item ::= common_expression AS column_alias */ + { 345, -3 }, /* (399) select_item ::= table_name NK_DOT NK_STAR */ + { 339, 0 }, /* (400) where_clause_opt ::= */ + { 339, -2 }, /* (401) where_clause_opt ::= WHERE search_condition */ + { 340, 0 }, /* (402) partition_by_clause_opt ::= */ + { 340, -3 }, /* (403) partition_by_clause_opt ::= PARTITION BY expression_list */ + { 341, 0 }, /* (404) twindow_clause_opt ::= */ + { 341, -6 }, /* (405) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ + { 341, -4 }, /* (406) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */ + { 341, -6 }, /* (407) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ + { 341, -8 }, /* (408) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ + { 292, 0 }, /* (409) sliding_opt ::= */ + { 292, -4 }, /* (410) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ + { 346, 0 }, /* (411) fill_opt ::= */ + { 346, -4 }, /* (412) fill_opt ::= FILL NK_LP fill_mode NK_RP */ + { 346, -6 }, /* (413) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ + { 347, -1 }, /* (414) fill_mode ::= NONE */ + { 347, -1 }, /* (415) fill_mode ::= PREV */ + { 347, -1 }, /* (416) fill_mode ::= NULL */ + { 347, -1 }, /* (417) fill_mode ::= LINEAR */ + { 347, -1 }, /* (418) fill_mode ::= NEXT */ + { 342, 0 }, /* (419) group_by_clause_opt ::= */ + { 342, -3 }, /* (420) group_by_clause_opt ::= GROUP BY group_by_list */ + { 348, -1 }, /* (421) group_by_list ::= expression */ + { 348, -3 }, /* (422) group_by_list ::= group_by_list NK_COMMA expression */ + { 343, 0 }, /* (423) having_clause_opt ::= */ + { 343, -2 }, /* (424) having_clause_opt ::= HAVING search_condition */ + { 296, -4 }, /* (425) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ + { 349, -1 }, /* (426) query_expression_body ::= query_primary */ + { 349, -4 }, /* (427) query_expression_body ::= query_expression_body UNION ALL query_expression_body */ + { 349, -3 }, /* (428) query_expression_body ::= query_expression_body UNION query_expression_body */ + { 353, -1 }, /* (429) query_primary ::= query_specification */ + { 353, -6 }, /* (430) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */ + { 350, 0 }, /* (431) order_by_clause_opt ::= */ + { 350, -3 }, /* (432) order_by_clause_opt ::= ORDER BY sort_specification_list */ + { 351, 0 }, /* (433) slimit_clause_opt ::= */ + { 351, -2 }, /* (434) slimit_clause_opt ::= SLIMIT NK_INTEGER */ + { 351, -4 }, /* (435) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + { 351, -4 }, /* (436) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + { 352, 0 }, /* (437) limit_clause_opt ::= */ + { 352, -2 }, /* (438) limit_clause_opt ::= LIMIT NK_INTEGER */ + { 352, -4 }, /* (439) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ + { 352, -4 }, /* (440) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + { 314, -3 }, /* (441) subquery ::= NK_LP query_expression NK_RP */ + { 335, -1 }, /* (442) search_condition ::= common_expression */ + { 354, -1 }, /* (443) sort_specification_list ::= sort_specification */ + { 354, -3 }, /* (444) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ + { 355, -3 }, /* (445) sort_specification ::= expression ordering_specification_opt null_ordering_opt */ + { 356, 0 }, /* (446) ordering_specification_opt ::= */ + { 356, -1 }, /* (447) ordering_specification_opt ::= ASC */ + { 356, -1 }, /* (448) ordering_specification_opt ::= DESC */ + { 357, 0 }, /* (449) null_ordering_opt ::= */ + { 357, -2 }, /* (450) null_ordering_opt ::= NULLS FIRST */ + { 357, -2 }, /* (451) null_ordering_opt ::= NULLS LAST */ }; static void yy_accept(yyParser*); /* Forward Declaration */ @@ -3114,11 +3114,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,241,&yymsp[0].minor); + yy_destructor(yypParser,239,&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,242,&yymsp[0].minor); + yy_destructor(yypParser,240,&yymsp[0].minor); break; case 2: /* account_options ::= */ { } @@ -3132,20 +3132,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,241,&yymsp[-2].minor); +{ yy_destructor(yypParser,239,&yymsp[-2].minor); { } - yy_destructor(yypParser,243,&yymsp[0].minor); + yy_destructor(yypParser,241,&yymsp[0].minor); } break; case 12: /* alter_account_options ::= alter_account_option */ -{ yy_destructor(yypParser,244,&yymsp[0].minor); +{ yy_destructor(yypParser,242,&yymsp[0].minor); { } } break; case 13: /* alter_account_options ::= alter_account_options alter_account_option */ -{ yy_destructor(yypParser,242,&yymsp[-1].minor); +{ yy_destructor(yypParser,240,&yymsp[-1].minor); { } - yy_destructor(yypParser,244,&yymsp[0].minor); + yy_destructor(yypParser,242,&yymsp[0].minor); } break; case 14: /* alter_account_option ::= PASS literal */ @@ -3159,63 +3159,63 @@ 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,243,&yymsp[0].minor); + yy_destructor(yypParser,241,&yymsp[0].minor); break; case 24: /* cmd ::= CREATE USER user_name PASS NK_STRING */ -{ pCxt->pRootNode = createCreateUserStmt(pCxt, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy0); } +{ pCxt->pRootNode = createCreateUserStmt(pCxt, &yymsp[-2].minor.yy105, &yymsp[0].minor.yy0); } break; case 25: /* cmd ::= ALTER USER user_name PASS NK_STRING */ -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy53, TSDB_ALTER_USER_PASSWD, &yymsp[0].minor.yy0); } +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy105, TSDB_ALTER_USER_PASSWD, &yymsp[0].minor.yy0); } break; case 26: /* cmd ::= ALTER USER user_name PRIVILEGE NK_STRING */ -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy53, TSDB_ALTER_USER_PRIVILEGES, &yymsp[0].minor.yy0); } +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy105, TSDB_ALTER_USER_PRIVILEGES, &yymsp[0].minor.yy0); } break; case 27: /* cmd ::= DROP USER user_name */ -{ pCxt->pRootNode = createDropUserStmt(pCxt, &yymsp[0].minor.yy53); } +{ pCxt->pRootNode = createDropUserStmt(pCxt, &yymsp[0].minor.yy105); } break; case 28: /* cmd ::= GRANT privileges ON priv_level TO user_name */ -{ pCxt->pRootNode = createGrantStmt(pCxt, yymsp[-4].minor.yy435, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy53); } +{ pCxt->pRootNode = createGrantStmt(pCxt, yymsp[-4].minor.yy593, &yymsp[-2].minor.yy105, &yymsp[0].minor.yy105); } break; case 29: /* cmd ::= REVOKE privileges ON priv_level FROM user_name */ -{ pCxt->pRootNode = createRevokeStmt(pCxt, yymsp[-4].minor.yy435, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy53); } +{ pCxt->pRootNode = createRevokeStmt(pCxt, yymsp[-4].minor.yy593, &yymsp[-2].minor.yy105, &yymsp[0].minor.yy105); } break; case 30: /* privileges ::= ALL */ -{ yymsp[0].minor.yy435 = PRIVILEGE_TYPE_ALL; } +{ yymsp[0].minor.yy593 = PRIVILEGE_TYPE_ALL; } break; case 31: /* privileges ::= priv_type_list */ case 32: /* priv_type_list ::= priv_type */ yytestcase(yyruleno==32); -{ yylhsminor.yy435 = yymsp[0].minor.yy435; } - yymsp[0].minor.yy435 = yylhsminor.yy435; +{ yylhsminor.yy593 = yymsp[0].minor.yy593; } + yymsp[0].minor.yy593 = yylhsminor.yy593; break; case 33: /* priv_type_list ::= priv_type_list NK_COMMA priv_type */ -{ yylhsminor.yy435 = yymsp[-2].minor.yy435 | yymsp[0].minor.yy435; } - yymsp[-2].minor.yy435 = yylhsminor.yy435; +{ yylhsminor.yy593 = yymsp[-2].minor.yy593 | yymsp[0].minor.yy593; } + yymsp[-2].minor.yy593 = yylhsminor.yy593; break; case 34: /* priv_type ::= READ */ -{ yymsp[0].minor.yy435 = PRIVILEGE_TYPE_READ; } +{ yymsp[0].minor.yy593 = PRIVILEGE_TYPE_READ; } break; case 35: /* priv_type ::= WRITE */ -{ yymsp[0].minor.yy435 = PRIVILEGE_TYPE_WRITE; } +{ yymsp[0].minor.yy593 = PRIVILEGE_TYPE_WRITE; } break; case 36: /* priv_level ::= NK_STAR NK_DOT NK_STAR */ -{ yylhsminor.yy53 = yymsp[-2].minor.yy0; } - yymsp[-2].minor.yy53 = yylhsminor.yy53; +{ yylhsminor.yy105 = yymsp[-2].minor.yy0; } + yymsp[-2].minor.yy105 = yylhsminor.yy105; break; case 37: /* priv_level ::= db_name NK_DOT NK_STAR */ -{ yylhsminor.yy53 = yymsp[-2].minor.yy53; } - yymsp[-2].minor.yy53 = yylhsminor.yy53; +{ yylhsminor.yy105 = yymsp[-2].minor.yy105; } + yymsp[-2].minor.yy105 = yylhsminor.yy105; break; case 38: /* cmd ::= CREATE DNODE dnode_endpoint */ -{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[0].minor.yy53, NULL); } +{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[0].minor.yy105, NULL); } break; case 39: /* cmd ::= CREATE DNODE dnode_host_name PORT NK_INTEGER */ -{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy0); } +{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[-2].minor.yy105, &yymsp[0].minor.yy0); } break; case 40: /* cmd ::= DROP DNODE NK_INTEGER */ { pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[0].minor.yy0); } break; case 41: /* cmd ::= DROP DNODE dnode_endpoint */ -{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[0].minor.yy53); } +{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[0].minor.yy105); } break; case 42: /* cmd ::= ALTER DNODE NK_INTEGER NK_STRING */ { pCxt->pRootNode = createAlterDnodeStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, NULL); } @@ -3232,26 +3232,26 @@ static YYACTIONTYPE yy_reduce( case 46: /* dnode_endpoint ::= NK_STRING */ case 47: /* dnode_host_name ::= NK_ID */ yytestcase(yyruleno==47); case 48: /* dnode_host_name ::= NK_IPTOKEN */ yytestcase(yyruleno==48); - case 290: /* db_name ::= NK_ID */ yytestcase(yyruleno==290); - case 291: /* table_name ::= NK_ID */ yytestcase(yyruleno==291); - case 292: /* column_name ::= NK_ID */ yytestcase(yyruleno==292); - case 293: /* function_name ::= NK_ID */ yytestcase(yyruleno==293); - case 294: /* table_alias ::= NK_ID */ yytestcase(yyruleno==294); - case 295: /* column_alias ::= NK_ID */ yytestcase(yyruleno==295); - case 296: /* user_name ::= NK_ID */ yytestcase(yyruleno==296); - case 297: /* index_name ::= NK_ID */ yytestcase(yyruleno==297); - case 298: /* topic_name ::= NK_ID */ yytestcase(yyruleno==298); - case 299: /* stream_name ::= NK_ID */ yytestcase(yyruleno==299); - case 300: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==300); - case 333: /* noarg_func ::= NOW */ yytestcase(yyruleno==333); - case 334: /* noarg_func ::= TODAY */ yytestcase(yyruleno==334); - case 335: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==335); - case 336: /* star_func ::= COUNT */ yytestcase(yyruleno==336); - case 337: /* star_func ::= FIRST */ yytestcase(yyruleno==337); - case 338: /* star_func ::= LAST */ yytestcase(yyruleno==338); - case 339: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==339); -{ yylhsminor.yy53 = yymsp[0].minor.yy0; } - yymsp[0].minor.yy53 = yylhsminor.yy53; + case 287: /* db_name ::= NK_ID */ yytestcase(yyruleno==287); + case 288: /* table_name ::= NK_ID */ yytestcase(yyruleno==288); + case 289: /* column_name ::= NK_ID */ yytestcase(yyruleno==289); + case 290: /* function_name ::= NK_ID */ yytestcase(yyruleno==290); + case 291: /* table_alias ::= NK_ID */ yytestcase(yyruleno==291); + case 292: /* column_alias ::= NK_ID */ yytestcase(yyruleno==292); + case 293: /* user_name ::= NK_ID */ yytestcase(yyruleno==293); + case 294: /* index_name ::= NK_ID */ yytestcase(yyruleno==294); + case 295: /* topic_name ::= NK_ID */ yytestcase(yyruleno==295); + case 296: /* stream_name ::= NK_ID */ yytestcase(yyruleno==296); + case 297: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==297); + case 330: /* noarg_func ::= NOW */ yytestcase(yyruleno==330); + case 331: /* noarg_func ::= TODAY */ yytestcase(yyruleno==331); + case 332: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==332); + case 333: /* star_func ::= COUNT */ yytestcase(yyruleno==333); + case 334: /* star_func ::= FIRST */ yytestcase(yyruleno==334); + case 335: /* star_func ::= LAST */ yytestcase(yyruleno==335); + case 336: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==336); +{ yylhsminor.yy105 = yymsp[0].minor.yy0; } + yymsp[0].minor.yy105 = yylhsminor.yy105; break; case 49: /* cmd ::= ALTER LOCAL NK_STRING */ { pCxt->pRootNode = createAlterLocalStmt(pCxt, &yymsp[0].minor.yy0, NULL); } @@ -3284,156 +3284,156 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createDropComponentNodeStmt(pCxt, QUERY_NODE_DROP_MNODE_STMT, &yymsp[0].minor.yy0); } break; case 59: /* cmd ::= CREATE DATABASE not_exists_opt db_name db_options */ -{ pCxt->pRootNode = createCreateDatabaseStmt(pCxt, yymsp[-2].minor.yy603, &yymsp[-1].minor.yy53, yymsp[0].minor.yy636); } +{ pCxt->pRootNode = createCreateDatabaseStmt(pCxt, yymsp[-2].minor.yy617, &yymsp[-1].minor.yy105, yymsp[0].minor.yy172); } break; case 60: /* cmd ::= DROP DATABASE exists_opt db_name */ -{ pCxt->pRootNode = createDropDatabaseStmt(pCxt, yymsp[-1].minor.yy603, &yymsp[0].minor.yy53); } +{ pCxt->pRootNode = createDropDatabaseStmt(pCxt, yymsp[-1].minor.yy617, &yymsp[0].minor.yy105); } break; case 61: /* cmd ::= USE db_name */ -{ pCxt->pRootNode = createUseDatabaseStmt(pCxt, &yymsp[0].minor.yy53); } +{ pCxt->pRootNode = createUseDatabaseStmt(pCxt, &yymsp[0].minor.yy105); } break; case 62: /* cmd ::= ALTER DATABASE db_name alter_db_options */ -{ pCxt->pRootNode = createAlterDatabaseStmt(pCxt, &yymsp[-1].minor.yy53, yymsp[0].minor.yy636); } +{ pCxt->pRootNode = createAlterDatabaseStmt(pCxt, &yymsp[-1].minor.yy105, yymsp[0].minor.yy172); } break; case 63: /* not_exists_opt ::= IF NOT EXISTS */ -{ yymsp[-2].minor.yy603 = true; } +{ yymsp[-2].minor.yy617 = true; } break; case 64: /* not_exists_opt ::= */ case 66: /* exists_opt ::= */ yytestcase(yyruleno==66); - case 236: /* analyze_opt ::= */ yytestcase(yyruleno==236); - case 244: /* agg_func_opt ::= */ yytestcase(yyruleno==244); - case 392: /* set_quantifier_opt ::= */ yytestcase(yyruleno==392); -{ yymsp[1].minor.yy603 = false; } + case 233: /* analyze_opt ::= */ yytestcase(yyruleno==233); + case 241: /* agg_func_opt ::= */ yytestcase(yyruleno==241); + case 389: /* set_quantifier_opt ::= */ yytestcase(yyruleno==389); +{ yymsp[1].minor.yy617 = false; } break; case 65: /* exists_opt ::= IF EXISTS */ -{ yymsp[-1].minor.yy603 = true; } +{ yymsp[-1].minor.yy617 = true; } break; case 67: /* db_options ::= */ -{ yymsp[1].minor.yy636 = createDefaultDatabaseOptions(pCxt); } +{ yymsp[1].minor.yy172 = createDefaultDatabaseOptions(pCxt); } break; case 68: /* db_options ::= db_options BUFFER NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_BUFFER, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setDatabaseOption(pCxt, yymsp[-2].minor.yy172, DB_OPTION_BUFFER, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 69: /* db_options ::= db_options CACHELAST NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_CACHELAST, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setDatabaseOption(pCxt, yymsp[-2].minor.yy172, DB_OPTION_CACHELAST, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 70: /* db_options ::= db_options COMP NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_COMP, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setDatabaseOption(pCxt, yymsp[-2].minor.yy172, DB_OPTION_COMP, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 71: /* db_options ::= db_options DAYS NK_INTEGER */ case 72: /* db_options ::= db_options DAYS NK_VARIABLE */ yytestcase(yyruleno==72); -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_DAYS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setDatabaseOption(pCxt, yymsp[-2].minor.yy172, DB_OPTION_DAYS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 73: /* db_options ::= db_options FSYNC NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_FSYNC, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setDatabaseOption(pCxt, yymsp[-2].minor.yy172, DB_OPTION_FSYNC, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 74: /* db_options ::= db_options MAXROWS NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_MAXROWS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setDatabaseOption(pCxt, yymsp[-2].minor.yy172, DB_OPTION_MAXROWS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 75: /* db_options ::= db_options MINROWS NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_MINROWS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setDatabaseOption(pCxt, yymsp[-2].minor.yy172, DB_OPTION_MINROWS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 76: /* db_options ::= db_options KEEP integer_list */ case 77: /* db_options ::= db_options KEEP variable_list */ yytestcase(yyruleno==77); -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_KEEP, yymsp[0].minor.yy236); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setDatabaseOption(pCxt, yymsp[-2].minor.yy172, DB_OPTION_KEEP, yymsp[0].minor.yy60); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 78: /* db_options ::= db_options PAGES NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_PAGES, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setDatabaseOption(pCxt, yymsp[-2].minor.yy172, DB_OPTION_PAGES, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 79: /* db_options ::= db_options PAGESIZE NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_PAGESIZE, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setDatabaseOption(pCxt, yymsp[-2].minor.yy172, DB_OPTION_PAGESIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 80: /* db_options ::= db_options PRECISION NK_STRING */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_PRECISION, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setDatabaseOption(pCxt, yymsp[-2].minor.yy172, DB_OPTION_PRECISION, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 81: /* db_options ::= db_options REPLICA NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_REPLICA, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setDatabaseOption(pCxt, yymsp[-2].minor.yy172, DB_OPTION_REPLICA, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 82: /* db_options ::= db_options STRICT NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_STRICT, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setDatabaseOption(pCxt, yymsp[-2].minor.yy172, DB_OPTION_STRICT, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 83: /* db_options ::= db_options WAL NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_WAL, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setDatabaseOption(pCxt, yymsp[-2].minor.yy172, DB_OPTION_WAL, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 84: /* db_options ::= db_options VGROUPS NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_VGROUPS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setDatabaseOption(pCxt, yymsp[-2].minor.yy172, DB_OPTION_VGROUPS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 85: /* db_options ::= db_options SINGLE_STABLE NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_SINGLE_STABLE, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setDatabaseOption(pCxt, yymsp[-2].minor.yy172, DB_OPTION_SINGLE_STABLE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 86: /* db_options ::= db_options RETENTIONS retention_list */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_RETENTIONS, yymsp[0].minor.yy236); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setDatabaseOption(pCxt, yymsp[-2].minor.yy172, DB_OPTION_RETENTIONS, yymsp[0].minor.yy60); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 87: /* db_options ::= db_options SCHEMALESS NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_SCHEMALESS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setDatabaseOption(pCxt, yymsp[-2].minor.yy172, DB_OPTION_SCHEMALESS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 88: /* alter_db_options ::= alter_db_option */ -{ yylhsminor.yy636 = createAlterDatabaseOptions(pCxt); yylhsminor.yy636 = setAlterDatabaseOption(pCxt, yylhsminor.yy636, &yymsp[0].minor.yy25); } - yymsp[0].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createAlterDatabaseOptions(pCxt); yylhsminor.yy172 = setAlterDatabaseOption(pCxt, yylhsminor.yy172, &yymsp[0].minor.yy609); } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; case 89: /* alter_db_options ::= alter_db_options alter_db_option */ -{ yylhsminor.yy636 = setAlterDatabaseOption(pCxt, yymsp[-1].minor.yy636, &yymsp[0].minor.yy25); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setAlterDatabaseOption(pCxt, yymsp[-1].minor.yy172, &yymsp[0].minor.yy609); } + yymsp[-1].minor.yy172 = yylhsminor.yy172; break; case 90: /* alter_db_option ::= BUFFER NK_INTEGER */ -{ yymsp[-1].minor.yy25.type = DB_OPTION_BUFFER; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy609.type = DB_OPTION_BUFFER; yymsp[-1].minor.yy609.val = yymsp[0].minor.yy0; } break; case 91: /* alter_db_option ::= CACHELAST NK_INTEGER */ -{ yymsp[-1].minor.yy25.type = DB_OPTION_CACHELAST; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy609.type = DB_OPTION_CACHELAST; yymsp[-1].minor.yy609.val = yymsp[0].minor.yy0; } break; case 92: /* alter_db_option ::= FSYNC NK_INTEGER */ -{ yymsp[-1].minor.yy25.type = DB_OPTION_FSYNC; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy609.type = DB_OPTION_FSYNC; yymsp[-1].minor.yy609.val = yymsp[0].minor.yy0; } break; case 93: /* alter_db_option ::= KEEP integer_list */ case 94: /* alter_db_option ::= KEEP variable_list */ yytestcase(yyruleno==94); -{ yymsp[-1].minor.yy25.type = DB_OPTION_KEEP; yymsp[-1].minor.yy25.pList = yymsp[0].minor.yy236; } +{ yymsp[-1].minor.yy609.type = DB_OPTION_KEEP; yymsp[-1].minor.yy609.pList = yymsp[0].minor.yy60; } break; case 95: /* alter_db_option ::= PAGES NK_INTEGER */ -{ yymsp[-1].minor.yy25.type = DB_OPTION_PAGES; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy609.type = DB_OPTION_PAGES; yymsp[-1].minor.yy609.val = yymsp[0].minor.yy0; } break; case 96: /* alter_db_option ::= REPLICA NK_INTEGER */ -{ yymsp[-1].minor.yy25.type = DB_OPTION_REPLICA; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy609.type = DB_OPTION_REPLICA; yymsp[-1].minor.yy609.val = yymsp[0].minor.yy0; } break; case 97: /* alter_db_option ::= STRICT NK_INTEGER */ -{ yymsp[-1].minor.yy25.type = DB_OPTION_STRICT; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy609.type = DB_OPTION_STRICT; yymsp[-1].minor.yy609.val = yymsp[0].minor.yy0; } break; case 98: /* alter_db_option ::= WAL NK_INTEGER */ -{ yymsp[-1].minor.yy25.type = DB_OPTION_WAL; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy609.type = DB_OPTION_WAL; yymsp[-1].minor.yy609.val = yymsp[0].minor.yy0; } break; case 99: /* integer_list ::= NK_INTEGER */ -{ yylhsminor.yy236 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy236 = yylhsminor.yy236; +{ yylhsminor.yy60 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy60 = yylhsminor.yy60; break; case 100: /* integer_list ::= integer_list NK_COMMA NK_INTEGER */ - case 263: /* dnode_list ::= dnode_list DNODE NK_INTEGER */ yytestcase(yyruleno==263); -{ yylhsminor.yy236 = addNodeToList(pCxt, yymsp[-2].minor.yy236, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } - yymsp[-2].minor.yy236 = yylhsminor.yy236; + case 260: /* dnode_list ::= dnode_list DNODE NK_INTEGER */ yytestcase(yyruleno==260); +{ yylhsminor.yy60 = addNodeToList(pCxt, yymsp[-2].minor.yy60, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy60 = yylhsminor.yy60; break; case 101: /* variable_list ::= NK_VARIABLE */ -{ yylhsminor.yy236 = createNodeList(pCxt, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy236 = yylhsminor.yy236; +{ yylhsminor.yy60 = createNodeList(pCxt, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy60 = yylhsminor.yy60; break; case 102: /* variable_list ::= variable_list NK_COMMA NK_VARIABLE */ -{ yylhsminor.yy236 = addNodeToList(pCxt, yymsp[-2].minor.yy236, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[-2].minor.yy236 = yylhsminor.yy236; +{ yylhsminor.yy60 = addNodeToList(pCxt, yymsp[-2].minor.yy60, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy60 = yylhsminor.yy60; break; case 103: /* retention_list ::= retention */ case 123: /* multi_create_clause ::= create_subtable_clause */ yytestcase(yyruleno==123); @@ -3442,246 +3442,246 @@ static YYACTIONTYPE yy_reduce( case 174: /* col_name_list ::= col_name */ yytestcase(yyruleno==174); case 212: /* func_name_list ::= func_name */ yytestcase(yyruleno==212); case 221: /* func_list ::= func */ yytestcase(yyruleno==221); - case 288: /* literal_list ::= signed_literal */ yytestcase(yyruleno==288); - case 342: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==342); - case 397: /* select_sublist ::= select_item */ yytestcase(yyruleno==397); - case 446: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==446); -{ yylhsminor.yy236 = createNodeList(pCxt, yymsp[0].minor.yy636); } - yymsp[0].minor.yy236 = yylhsminor.yy236; + case 285: /* literal_list ::= signed_literal */ yytestcase(yyruleno==285); + case 339: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==339); + case 394: /* select_sublist ::= select_item */ yytestcase(yyruleno==394); + case 443: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==443); +{ yylhsminor.yy60 = createNodeList(pCxt, yymsp[0].minor.yy172); } + yymsp[0].minor.yy60 = yylhsminor.yy60; break; case 104: /* retention_list ::= retention_list NK_COMMA retention */ case 134: /* column_def_list ::= column_def_list NK_COMMA column_def */ yytestcase(yyruleno==134); case 175: /* col_name_list ::= col_name_list NK_COMMA col_name */ yytestcase(yyruleno==175); case 213: /* func_name_list ::= func_name_list NK_COMMA func_name */ yytestcase(yyruleno==213); case 222: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==222); - case 289: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==289); - case 343: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==343); - case 398: /* select_sublist ::= select_sublist NK_COMMA select_item */ yytestcase(yyruleno==398); - case 447: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==447); -{ yylhsminor.yy236 = addNodeToList(pCxt, yymsp[-2].minor.yy236, yymsp[0].minor.yy636); } - yymsp[-2].minor.yy236 = yylhsminor.yy236; + case 286: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==286); + case 340: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==340); + case 395: /* select_sublist ::= select_sublist NK_COMMA select_item */ yytestcase(yyruleno==395); + case 444: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==444); +{ yylhsminor.yy60 = addNodeToList(pCxt, yymsp[-2].minor.yy60, yymsp[0].minor.yy172); } + yymsp[-2].minor.yy60 = yylhsminor.yy60; break; case 105: /* retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ -{ yylhsminor.yy636 = createNodeListNodeEx(pCxt, createDurationValueNode(pCxt, &yymsp[-2].minor.yy0), createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createNodeListNodeEx(pCxt, createDurationValueNode(pCxt, &yymsp[-2].minor.yy0), createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 106: /* cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ case 108: /* cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ yytestcase(yyruleno==108); -{ pCxt->pRootNode = createCreateTableStmt(pCxt, yymsp[-6].minor.yy603, yymsp[-5].minor.yy636, yymsp[-3].minor.yy236, yymsp[-1].minor.yy236, yymsp[0].minor.yy636); } +{ pCxt->pRootNode = createCreateTableStmt(pCxt, yymsp[-6].minor.yy617, yymsp[-5].minor.yy172, yymsp[-3].minor.yy60, yymsp[-1].minor.yy60, yymsp[0].minor.yy172); } break; case 107: /* cmd ::= CREATE TABLE multi_create_clause */ -{ pCxt->pRootNode = createCreateMultiTableStmt(pCxt, yymsp[0].minor.yy236); } +{ pCxt->pRootNode = createCreateMultiTableStmt(pCxt, yymsp[0].minor.yy60); } break; case 109: /* cmd ::= DROP TABLE multi_drop_clause */ -{ pCxt->pRootNode = createDropTableStmt(pCxt, yymsp[0].minor.yy236); } +{ pCxt->pRootNode = createDropTableStmt(pCxt, yymsp[0].minor.yy60); } break; case 110: /* cmd ::= DROP STABLE exists_opt full_table_name */ -{ pCxt->pRootNode = createDropSuperTableStmt(pCxt, yymsp[-1].minor.yy603, yymsp[0].minor.yy636); } +{ pCxt->pRootNode = createDropSuperTableStmt(pCxt, yymsp[-1].minor.yy617, yymsp[0].minor.yy172); } break; case 111: /* cmd ::= ALTER TABLE alter_table_clause */ case 112: /* cmd ::= ALTER STABLE alter_table_clause */ yytestcase(yyruleno==112); - case 265: /* cmd ::= query_expression */ yytestcase(yyruleno==265); -{ pCxt->pRootNode = yymsp[0].minor.yy636; } + case 262: /* cmd ::= query_expression */ yytestcase(yyruleno==262); +{ pCxt->pRootNode = yymsp[0].minor.yy172; } break; case 113: /* alter_table_clause ::= full_table_name alter_table_options */ -{ yylhsminor.yy636 = createAlterTableModifyOptions(pCxt, yymsp[-1].minor.yy636, yymsp[0].minor.yy636); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createAlterTableModifyOptions(pCxt, yymsp[-1].minor.yy172, yymsp[0].minor.yy172); } + yymsp[-1].minor.yy172 = yylhsminor.yy172; break; case 114: /* alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ -{ yylhsminor.yy636 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy636, TSDB_ALTER_TABLE_ADD_COLUMN, &yymsp[-1].minor.yy53, yymsp[0].minor.yy450); } - yymsp[-4].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy172, TSDB_ALTER_TABLE_ADD_COLUMN, &yymsp[-1].minor.yy105, yymsp[0].minor.yy248); } + yymsp[-4].minor.yy172 = yylhsminor.yy172; break; case 115: /* alter_table_clause ::= full_table_name DROP COLUMN column_name */ -{ yylhsminor.yy636 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy636, TSDB_ALTER_TABLE_DROP_COLUMN, &yymsp[0].minor.yy53); } - yymsp[-3].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy172, TSDB_ALTER_TABLE_DROP_COLUMN, &yymsp[0].minor.yy105); } + yymsp[-3].minor.yy172 = yylhsminor.yy172; break; case 116: /* alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ -{ yylhsminor.yy636 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy636, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, &yymsp[-1].minor.yy53, yymsp[0].minor.yy450); } - yymsp[-4].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy172, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, &yymsp[-1].minor.yy105, yymsp[0].minor.yy248); } + yymsp[-4].minor.yy172 = yylhsminor.yy172; break; case 117: /* alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ -{ yylhsminor.yy636 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy636, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &yymsp[-1].minor.yy53, &yymsp[0].minor.yy53); } - yymsp[-4].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy172, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &yymsp[-1].minor.yy105, &yymsp[0].minor.yy105); } + yymsp[-4].minor.yy172 = yylhsminor.yy172; break; case 118: /* alter_table_clause ::= full_table_name ADD TAG column_name type_name */ -{ yylhsminor.yy636 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy636, TSDB_ALTER_TABLE_ADD_TAG, &yymsp[-1].minor.yy53, yymsp[0].minor.yy450); } - yymsp[-4].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy172, TSDB_ALTER_TABLE_ADD_TAG, &yymsp[-1].minor.yy105, yymsp[0].minor.yy248); } + yymsp[-4].minor.yy172 = yylhsminor.yy172; break; case 119: /* alter_table_clause ::= full_table_name DROP TAG column_name */ -{ yylhsminor.yy636 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy636, TSDB_ALTER_TABLE_DROP_TAG, &yymsp[0].minor.yy53); } - yymsp[-3].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy172, TSDB_ALTER_TABLE_DROP_TAG, &yymsp[0].minor.yy105); } + yymsp[-3].minor.yy172 = yylhsminor.yy172; break; case 120: /* alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ -{ yylhsminor.yy636 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy636, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &yymsp[-1].minor.yy53, yymsp[0].minor.yy450); } - yymsp[-4].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy172, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &yymsp[-1].minor.yy105, yymsp[0].minor.yy248); } + yymsp[-4].minor.yy172 = yylhsminor.yy172; break; case 121: /* alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ -{ yylhsminor.yy636 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy636, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &yymsp[-1].minor.yy53, &yymsp[0].minor.yy53); } - yymsp[-4].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy172, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &yymsp[-1].minor.yy105, &yymsp[0].minor.yy105); } + yymsp[-4].minor.yy172 = yylhsminor.yy172; break; case 122: /* alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ -{ yylhsminor.yy636 = createAlterTableSetTag(pCxt, yymsp[-5].minor.yy636, &yymsp[-2].minor.yy53, yymsp[0].minor.yy636); } - yymsp[-5].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createAlterTableSetTag(pCxt, yymsp[-5].minor.yy172, &yymsp[-2].minor.yy105, yymsp[0].minor.yy172); } + yymsp[-5].minor.yy172 = yylhsminor.yy172; break; case 124: /* multi_create_clause ::= multi_create_clause create_subtable_clause */ case 127: /* multi_drop_clause ::= multi_drop_clause drop_table_clause */ yytestcase(yyruleno==127); -{ yylhsminor.yy236 = addNodeToList(pCxt, yymsp[-1].minor.yy236, yymsp[0].minor.yy636); } - yymsp[-1].minor.yy236 = yylhsminor.yy236; +{ yylhsminor.yy60 = addNodeToList(pCxt, yymsp[-1].minor.yy60, yymsp[0].minor.yy172); } + yymsp[-1].minor.yy60 = yylhsminor.yy60; break; case 125: /* create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP literal_list NK_RP table_options */ -{ yylhsminor.yy636 = createCreateSubTableClause(pCxt, yymsp[-9].minor.yy603, yymsp[-8].minor.yy636, yymsp[-6].minor.yy636, yymsp[-5].minor.yy236, yymsp[-2].minor.yy236, yymsp[0].minor.yy636); } - yymsp[-9].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createCreateSubTableClause(pCxt, yymsp[-9].minor.yy617, yymsp[-8].minor.yy172, yymsp[-6].minor.yy172, yymsp[-5].minor.yy60, yymsp[-2].minor.yy60, yymsp[0].minor.yy172); } + yymsp[-9].minor.yy172 = yylhsminor.yy172; break; case 128: /* drop_table_clause ::= exists_opt full_table_name */ -{ yylhsminor.yy636 = createDropTableClause(pCxt, yymsp[-1].minor.yy603, yymsp[0].minor.yy636); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createDropTableClause(pCxt, yymsp[-1].minor.yy617, yymsp[0].minor.yy172); } + yymsp[-1].minor.yy172 = yylhsminor.yy172; break; case 129: /* specific_tags_opt ::= */ case 160: /* tags_def_opt ::= */ yytestcase(yyruleno==160); - case 405: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==405); - case 422: /* group_by_clause_opt ::= */ yytestcase(yyruleno==422); - case 434: /* order_by_clause_opt ::= */ yytestcase(yyruleno==434); -{ yymsp[1].minor.yy236 = NULL; } + case 402: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==402); + case 419: /* group_by_clause_opt ::= */ yytestcase(yyruleno==419); + case 431: /* order_by_clause_opt ::= */ yytestcase(yyruleno==431); +{ yymsp[1].minor.yy60 = NULL; } break; case 130: /* specific_tags_opt ::= NK_LP col_name_list NK_RP */ -{ yymsp[-2].minor.yy236 = yymsp[-1].minor.yy236; } +{ yymsp[-2].minor.yy60 = yymsp[-1].minor.yy60; } break; case 131: /* full_table_name ::= table_name */ -{ yylhsminor.yy636 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy53, NULL); } - yymsp[0].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy105, NULL); } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; case 132: /* full_table_name ::= db_name NK_DOT table_name */ -{ yylhsminor.yy636 = createRealTableNode(pCxt, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy53, NULL); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createRealTableNode(pCxt, &yymsp[-2].minor.yy105, &yymsp[0].minor.yy105, NULL); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 135: /* column_def ::= column_name type_name */ -{ yylhsminor.yy636 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy53, yymsp[0].minor.yy450, NULL); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy105, yymsp[0].minor.yy248, NULL); } + yymsp[-1].minor.yy172 = yylhsminor.yy172; break; case 136: /* column_def ::= column_name type_name COMMENT NK_STRING */ -{ yylhsminor.yy636 = createColumnDefNode(pCxt, &yymsp[-3].minor.yy53, yymsp[-2].minor.yy450, &yymsp[0].minor.yy0); } - yymsp[-3].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createColumnDefNode(pCxt, &yymsp[-3].minor.yy105, yymsp[-2].minor.yy248, &yymsp[0].minor.yy0); } + yymsp[-3].minor.yy172 = yylhsminor.yy172; break; case 137: /* type_name ::= BOOL */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_BOOL); } +{ yymsp[0].minor.yy248 = createDataType(TSDB_DATA_TYPE_BOOL); } break; case 138: /* type_name ::= TINYINT */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_TINYINT); } +{ yymsp[0].minor.yy248 = createDataType(TSDB_DATA_TYPE_TINYINT); } break; case 139: /* type_name ::= SMALLINT */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_SMALLINT); } +{ yymsp[0].minor.yy248 = createDataType(TSDB_DATA_TYPE_SMALLINT); } break; case 140: /* type_name ::= INT */ case 141: /* type_name ::= INTEGER */ yytestcase(yyruleno==141); -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_INT); } +{ yymsp[0].minor.yy248 = createDataType(TSDB_DATA_TYPE_INT); } break; case 142: /* type_name ::= BIGINT */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_BIGINT); } +{ yymsp[0].minor.yy248 = createDataType(TSDB_DATA_TYPE_BIGINT); } break; case 143: /* type_name ::= FLOAT */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_FLOAT); } +{ yymsp[0].minor.yy248 = createDataType(TSDB_DATA_TYPE_FLOAT); } break; case 144: /* type_name ::= DOUBLE */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_DOUBLE); } +{ yymsp[0].minor.yy248 = createDataType(TSDB_DATA_TYPE_DOUBLE); } break; case 145: /* type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy450 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy0); } +{ yymsp[-3].minor.yy248 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy0); } break; case 146: /* type_name ::= TIMESTAMP */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_TIMESTAMP); } +{ yymsp[0].minor.yy248 = createDataType(TSDB_DATA_TYPE_TIMESTAMP); } break; case 147: /* type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy450 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, &yymsp[-1].minor.yy0); } +{ yymsp[-3].minor.yy248 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, &yymsp[-1].minor.yy0); } break; case 148: /* type_name ::= TINYINT UNSIGNED */ -{ yymsp[-1].minor.yy450 = createDataType(TSDB_DATA_TYPE_UTINYINT); } +{ yymsp[-1].minor.yy248 = createDataType(TSDB_DATA_TYPE_UTINYINT); } break; case 149: /* type_name ::= SMALLINT UNSIGNED */ -{ yymsp[-1].minor.yy450 = createDataType(TSDB_DATA_TYPE_USMALLINT); } +{ yymsp[-1].minor.yy248 = createDataType(TSDB_DATA_TYPE_USMALLINT); } break; case 150: /* type_name ::= INT UNSIGNED */ -{ yymsp[-1].minor.yy450 = createDataType(TSDB_DATA_TYPE_UINT); } +{ yymsp[-1].minor.yy248 = createDataType(TSDB_DATA_TYPE_UINT); } break; case 151: /* type_name ::= BIGINT UNSIGNED */ -{ yymsp[-1].minor.yy450 = createDataType(TSDB_DATA_TYPE_UBIGINT); } +{ yymsp[-1].minor.yy248 = createDataType(TSDB_DATA_TYPE_UBIGINT); } break; case 152: /* type_name ::= JSON */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_JSON); } +{ yymsp[0].minor.yy248 = createDataType(TSDB_DATA_TYPE_JSON); } break; case 153: /* type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy450 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, &yymsp[-1].minor.yy0); } +{ yymsp[-3].minor.yy248 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, &yymsp[-1].minor.yy0); } break; case 154: /* type_name ::= MEDIUMBLOB */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_MEDIUMBLOB); } +{ yymsp[0].minor.yy248 = createDataType(TSDB_DATA_TYPE_MEDIUMBLOB); } break; case 155: /* type_name ::= BLOB */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_BLOB); } +{ yymsp[0].minor.yy248 = createDataType(TSDB_DATA_TYPE_BLOB); } break; case 156: /* type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy450 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, &yymsp[-1].minor.yy0); } +{ yymsp[-3].minor.yy248 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, &yymsp[-1].minor.yy0); } break; case 157: /* type_name ::= DECIMAL */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_DECIMAL); } +{ yymsp[0].minor.yy248 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; case 158: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy450 = createDataType(TSDB_DATA_TYPE_DECIMAL); } +{ yymsp[-3].minor.yy248 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; case 159: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ -{ yymsp[-5].minor.yy450 = createDataType(TSDB_DATA_TYPE_DECIMAL); } +{ yymsp[-5].minor.yy248 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; case 161: /* tags_def_opt ::= tags_def */ - case 341: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==341); - case 396: /* select_list ::= select_sublist */ yytestcase(yyruleno==396); -{ yylhsminor.yy236 = yymsp[0].minor.yy236; } - yymsp[0].minor.yy236 = yylhsminor.yy236; + case 338: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==338); + case 393: /* select_list ::= select_sublist */ yytestcase(yyruleno==393); +{ yylhsminor.yy60 = yymsp[0].minor.yy60; } + yymsp[0].minor.yy60 = yylhsminor.yy60; break; case 162: /* tags_def ::= TAGS NK_LP column_def_list NK_RP */ -{ yymsp[-3].minor.yy236 = yymsp[-1].minor.yy236; } +{ yymsp[-3].minor.yy60 = yymsp[-1].minor.yy60; } break; case 163: /* table_options ::= */ -{ yymsp[1].minor.yy636 = createDefaultTableOptions(pCxt); } +{ yymsp[1].minor.yy172 = createDefaultTableOptions(pCxt); } break; case 164: /* table_options ::= table_options COMMENT NK_STRING */ -{ yylhsminor.yy636 = setTableOption(pCxt, yymsp[-2].minor.yy636, TABLE_OPTION_COMMENT, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setTableOption(pCxt, yymsp[-2].minor.yy172, TABLE_OPTION_COMMENT, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 165: /* table_options ::= table_options DELAY NK_INTEGER */ -{ yylhsminor.yy636 = setTableOption(pCxt, yymsp[-2].minor.yy636, TABLE_OPTION_DELAY, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setTableOption(pCxt, yymsp[-2].minor.yy172, TABLE_OPTION_DELAY, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 166: /* table_options ::= table_options FILE_FACTOR NK_FLOAT */ -{ yylhsminor.yy636 = setTableOption(pCxt, yymsp[-2].minor.yy636, TABLE_OPTION_FILE_FACTOR, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setTableOption(pCxt, yymsp[-2].minor.yy172, TABLE_OPTION_FILE_FACTOR, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 167: /* table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP */ -{ yylhsminor.yy636 = setTableOption(pCxt, yymsp[-4].minor.yy636, TABLE_OPTION_ROLLUP, yymsp[-1].minor.yy236); } - yymsp[-4].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setTableOption(pCxt, yymsp[-4].minor.yy172, TABLE_OPTION_ROLLUP, yymsp[-1].minor.yy60); } + yymsp[-4].minor.yy172 = yylhsminor.yy172; break; case 168: /* table_options ::= table_options TTL NK_INTEGER */ -{ yylhsminor.yy636 = setTableOption(pCxt, yymsp[-2].minor.yy636, TABLE_OPTION_TTL, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setTableOption(pCxt, yymsp[-2].minor.yy172, TABLE_OPTION_TTL, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; case 169: /* table_options ::= table_options SMA NK_LP col_name_list NK_RP */ -{ yylhsminor.yy636 = setTableOption(pCxt, yymsp[-4].minor.yy636, TABLE_OPTION_SMA, yymsp[-1].minor.yy236); } - yymsp[-4].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setTableOption(pCxt, yymsp[-4].minor.yy172, TABLE_OPTION_SMA, yymsp[-1].minor.yy60); } + yymsp[-4].minor.yy172 = yylhsminor.yy172; break; case 170: /* alter_table_options ::= alter_table_option */ -{ yylhsminor.yy636 = createAlterTableOptions(pCxt); yylhsminor.yy636 = setTableOption(pCxt, yylhsminor.yy636, yymsp[0].minor.yy25.type, &yymsp[0].minor.yy25.val); } - yymsp[0].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createAlterTableOptions(pCxt); yylhsminor.yy172 = setTableOption(pCxt, yylhsminor.yy172, yymsp[0].minor.yy609.type, &yymsp[0].minor.yy609.val); } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; case 171: /* alter_table_options ::= alter_table_options alter_table_option */ -{ yylhsminor.yy636 = setTableOption(pCxt, yymsp[-1].minor.yy636, yymsp[0].minor.yy25.type, &yymsp[0].minor.yy25.val); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = setTableOption(pCxt, yymsp[-1].minor.yy172, yymsp[0].minor.yy609.type, &yymsp[0].minor.yy609.val); } + yymsp[-1].minor.yy172 = yylhsminor.yy172; break; case 172: /* alter_table_option ::= COMMENT NK_STRING */ -{ yymsp[-1].minor.yy25.type = TABLE_OPTION_COMMENT; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy609.type = TABLE_OPTION_COMMENT; yymsp[-1].minor.yy609.val = yymsp[0].minor.yy0; } break; case 173: /* alter_table_option ::= TTL NK_INTEGER */ -{ yymsp[-1].minor.yy25.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy609.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy609.val = yymsp[0].minor.yy0; } break; case 176: /* col_name ::= column_name */ -{ yylhsminor.yy636 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy53); } - yymsp[0].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy105); } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; case 177: /* cmd ::= SHOW DNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DNODES_STMT, NULL, NULL); } @@ -3693,13 +3693,13 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DATABASES_STMT, NULL, NULL); } break; case 180: /* cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */ -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TABLES_STMT, yymsp[-2].minor.yy636, yymsp[0].minor.yy636); } +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TABLES_STMT, yymsp[-2].minor.yy172, yymsp[0].minor.yy172); } break; case 181: /* cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_STABLES_STMT, yymsp[-2].minor.yy636, yymsp[0].minor.yy636); } +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_STABLES_STMT, yymsp[-2].minor.yy172, yymsp[0].minor.yy172); } break; case 182: /* cmd ::= SHOW db_name_cond_opt VGROUPS */ -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, yymsp[-1].minor.yy636, NULL); } +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, yymsp[-1].minor.yy172, NULL); } break; case 183: /* cmd ::= SHOW MNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_MNODES_STMT, NULL, NULL); } @@ -3714,7 +3714,7 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_FUNCTIONS_STMT, NULL, NULL); } break; case 187: /* cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, yymsp[-1].minor.yy636, yymsp[0].minor.yy636); } +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, yymsp[-1].minor.yy172, yymsp[0].minor.yy172); } break; case 188: /* cmd ::= SHOW STREAMS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_STREAMS_STMT, NULL, NULL); } @@ -3733,13 +3733,13 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_LICENCE_STMT, NULL, NULL); } break; case 194: /* cmd ::= SHOW CREATE DATABASE db_name */ -{ pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &yymsp[0].minor.yy53); } +{ pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &yymsp[0].minor.yy105); } break; case 195: /* cmd ::= SHOW CREATE TABLE full_table_name */ -{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, yymsp[0].minor.yy636); } +{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, yymsp[0].minor.yy172); } break; case 196: /* cmd ::= SHOW CREATE STABLE full_table_name */ -{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, yymsp[0].minor.yy636); } +{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, yymsp[0].minor.yy172); } break; case 197: /* cmd ::= SHOW QUERIES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QUERIES_STMT, NULL, NULL); } @@ -3767,678 +3767,666 @@ static YYACTIONTYPE yy_reduce( break; case 205: /* db_name_cond_opt ::= */ case 210: /* from_db_opt ::= */ yytestcase(yyruleno==210); -{ yymsp[1].minor.yy636 = createDefaultDatabaseCondValue(pCxt); } +{ yymsp[1].minor.yy172 = createDefaultDatabaseCondValue(pCxt); } break; case 206: /* db_name_cond_opt ::= db_name NK_DOT */ -{ yylhsminor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy53); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy105); } + yymsp[-1].minor.yy172 = yylhsminor.yy172; break; case 207: /* like_pattern_opt ::= */ case 218: /* index_options ::= */ yytestcase(yyruleno==218); - case 250: /* into_opt ::= */ yytestcase(yyruleno==250); - case 403: /* where_clause_opt ::= */ yytestcase(yyruleno==403); - case 407: /* twindow_clause_opt ::= */ yytestcase(yyruleno==407); - case 412: /* sliding_opt ::= */ yytestcase(yyruleno==412); - case 414: /* fill_opt ::= */ yytestcase(yyruleno==414); - case 426: /* having_clause_opt ::= */ yytestcase(yyruleno==426); - case 436: /* slimit_clause_opt ::= */ yytestcase(yyruleno==436); - case 440: /* limit_clause_opt ::= */ yytestcase(yyruleno==440); -{ yymsp[1].minor.yy636 = NULL; } + case 247: /* into_opt ::= */ yytestcase(yyruleno==247); + case 400: /* where_clause_opt ::= */ yytestcase(yyruleno==400); + case 404: /* twindow_clause_opt ::= */ yytestcase(yyruleno==404); + case 409: /* sliding_opt ::= */ yytestcase(yyruleno==409); + case 411: /* fill_opt ::= */ yytestcase(yyruleno==411); + case 423: /* having_clause_opt ::= */ yytestcase(yyruleno==423); + case 433: /* slimit_clause_opt ::= */ yytestcase(yyruleno==433); + case 437: /* limit_clause_opt ::= */ yytestcase(yyruleno==437); +{ yymsp[1].minor.yy172 = NULL; } break; case 208: /* like_pattern_opt ::= LIKE NK_STRING */ -{ yymsp[-1].minor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } +{ yymsp[-1].minor.yy172 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } break; case 209: /* table_name_cond ::= table_name */ -{ yylhsminor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy53); } - yymsp[0].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy105); } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; case 211: /* from_db_opt ::= FROM db_name */ -{ yymsp[-1].minor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy53); } +{ yymsp[-1].minor.yy172 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy105); } break; case 214: /* func_name ::= function_name */ -{ yylhsminor.yy636 = createFunctionNode(pCxt, &yymsp[0].minor.yy53, NULL); } - yymsp[0].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createFunctionNode(pCxt, &yymsp[0].minor.yy105, NULL); } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; case 215: /* cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options */ -{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_SMA, yymsp[-4].minor.yy603, &yymsp[-3].minor.yy53, &yymsp[-1].minor.yy53, NULL, yymsp[0].minor.yy636); } +{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_SMA, yymsp[-4].minor.yy617, &yymsp[-3].minor.yy105, &yymsp[-1].minor.yy105, NULL, yymsp[0].minor.yy172); } break; case 216: /* cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP */ -{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_FULLTEXT, yymsp[-6].minor.yy603, &yymsp[-5].minor.yy53, &yymsp[-3].minor.yy53, yymsp[-1].minor.yy236, NULL); } +{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_FULLTEXT, yymsp[-6].minor.yy617, &yymsp[-5].minor.yy105, &yymsp[-3].minor.yy105, yymsp[-1].minor.yy60, NULL); } break; case 217: /* cmd ::= DROP INDEX exists_opt index_name ON table_name */ -{ pCxt->pRootNode = createDropIndexStmt(pCxt, yymsp[-3].minor.yy603, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy53); } +{ pCxt->pRootNode = createDropIndexStmt(pCxt, yymsp[-3].minor.yy617, &yymsp[-2].minor.yy105, &yymsp[0].minor.yy105); } break; case 219: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt */ -{ yymsp[-8].minor.yy636 = createIndexOption(pCxt, yymsp[-6].minor.yy236, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), NULL, yymsp[0].minor.yy636); } +{ yymsp[-8].minor.yy172 = createIndexOption(pCxt, yymsp[-6].minor.yy60, releaseRawExprNode(pCxt, yymsp[-2].minor.yy172), NULL, yymsp[0].minor.yy172); } break; case 220: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt */ -{ yymsp[-10].minor.yy636 = createIndexOption(pCxt, yymsp[-8].minor.yy236, releaseRawExprNode(pCxt, yymsp[-4].minor.yy636), releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), yymsp[0].minor.yy636); } +{ yymsp[-10].minor.yy172 = createIndexOption(pCxt, yymsp[-8].minor.yy60, releaseRawExprNode(pCxt, yymsp[-4].minor.yy172), releaseRawExprNode(pCxt, yymsp[-2].minor.yy172), yymsp[0].minor.yy172); } break; case 223: /* func ::= function_name NK_LP expression_list NK_RP */ -{ yylhsminor.yy636 = createFunctionNode(pCxt, &yymsp[-3].minor.yy53, yymsp[-1].minor.yy236); } - yymsp[-3].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy172 = createFunctionNode(pCxt, &yymsp[-3].minor.yy105, yymsp[-1].minor.yy60); } + yymsp[-3].minor.yy172 = yylhsminor.yy172; break; - case 224: /* cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS query_expression */ -{ pCxt->pRootNode = createCreateTopicStmt(pCxt, yymsp[-4].minor.yy603, &yymsp[-3].minor.yy53, yymsp[0].minor.yy636, NULL, yymsp[-2].minor.yy636); } + case 224: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression */ +{ pCxt->pRootNode = createCreateTopicStmt(pCxt, yymsp[-3].minor.yy617, &yymsp[-2].minor.yy105, yymsp[0].minor.yy172, NULL, NULL); } break; - case 225: /* cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS db_name */ -{ pCxt->pRootNode = createCreateTopicStmt(pCxt, yymsp[-4].minor.yy603, &yymsp[-3].minor.yy53, NULL, &yymsp[0].minor.yy53, yymsp[-2].minor.yy636); } + case 225: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name */ +{ pCxt->pRootNode = createCreateTopicStmt(pCxt, yymsp[-4].minor.yy617, &yymsp[-3].minor.yy105, NULL, &yymsp[0].minor.yy105, NULL); } break; - case 226: /* cmd ::= DROP TOPIC exists_opt topic_name */ -{ pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy603, &yymsp[0].minor.yy53); } + case 226: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name */ +{ pCxt->pRootNode = createCreateTopicStmt(pCxt, yymsp[-4].minor.yy617, &yymsp[-3].minor.yy105, NULL, NULL, yymsp[0].minor.yy172); } break; - case 227: /* cmd ::= DROP CGROUP exists_opt cgroup_name ON topic_name */ -{ pCxt->pRootNode = createDropCGroupStmt(pCxt, yymsp[-3].minor.yy603, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy53); } + case 227: /* cmd ::= DROP TOPIC exists_opt topic_name */ +{ pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy617, &yymsp[0].minor.yy105); } break; - case 228: /* topic_options ::= */ -{ yymsp[1].minor.yy636 = createTopicOptions(pCxt); } + case 228: /* cmd ::= DROP CGROUP exists_opt cgroup_name ON topic_name */ +{ pCxt->pRootNode = createDropCGroupStmt(pCxt, yymsp[-3].minor.yy617, &yymsp[-2].minor.yy105, &yymsp[0].minor.yy105); } break; - case 229: /* topic_options ::= topic_options WITH TABLE */ -{ ((STopicOptions*)yymsp[-2].minor.yy636)->withTable = true; yylhsminor.yy636 = yymsp[-2].minor.yy636; } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 229: /* cmd ::= DESC full_table_name */ + case 230: /* cmd ::= DESCRIBE full_table_name */ yytestcase(yyruleno==230); +{ pCxt->pRootNode = createDescribeStmt(pCxt, yymsp[0].minor.yy172); } break; - case 230: /* topic_options ::= topic_options WITH SCHEMA */ -{ ((STopicOptions*)yymsp[-2].minor.yy636)->withSchema = true; yylhsminor.yy636 = yymsp[-2].minor.yy636; } - yymsp[-2].minor.yy636 = yylhsminor.yy636; - break; - case 231: /* topic_options ::= topic_options WITH TAG */ -{ ((STopicOptions*)yymsp[-2].minor.yy636)->withTag = true; yylhsminor.yy636 = yymsp[-2].minor.yy636; } - yymsp[-2].minor.yy636 = yylhsminor.yy636; - break; - case 232: /* cmd ::= DESC full_table_name */ - case 233: /* cmd ::= DESCRIBE full_table_name */ yytestcase(yyruleno==233); -{ pCxt->pRootNode = createDescribeStmt(pCxt, yymsp[0].minor.yy636); } - break; - case 234: /* cmd ::= RESET QUERY CACHE */ + case 231: /* cmd ::= RESET QUERY CACHE */ { pCxt->pRootNode = createResetQueryCacheStmt(pCxt); } break; - case 235: /* cmd ::= EXPLAIN analyze_opt explain_options query_expression */ -{ pCxt->pRootNode = createExplainStmt(pCxt, yymsp[-2].minor.yy603, yymsp[-1].minor.yy636, yymsp[0].minor.yy636); } + case 232: /* cmd ::= EXPLAIN analyze_opt explain_options query_expression */ +{ pCxt->pRootNode = createExplainStmt(pCxt, yymsp[-2].minor.yy617, yymsp[-1].minor.yy172, yymsp[0].minor.yy172); } break; - case 237: /* analyze_opt ::= ANALYZE */ - case 245: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==245); - case 393: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==393); -{ yymsp[0].minor.yy603 = true; } + case 234: /* analyze_opt ::= ANALYZE */ + case 242: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==242); + case 390: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==390); +{ yymsp[0].minor.yy617 = true; } break; - case 238: /* explain_options ::= */ -{ yymsp[1].minor.yy636 = createDefaultExplainOptions(pCxt); } + case 235: /* explain_options ::= */ +{ yymsp[1].minor.yy172 = createDefaultExplainOptions(pCxt); } break; - case 239: /* explain_options ::= explain_options VERBOSE NK_BOOL */ -{ yylhsminor.yy636 = setExplainVerbose(pCxt, yymsp[-2].minor.yy636, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 236: /* explain_options ::= explain_options VERBOSE NK_BOOL */ +{ yylhsminor.yy172 = setExplainVerbose(pCxt, yymsp[-2].minor.yy172, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 240: /* explain_options ::= explain_options RATIO NK_FLOAT */ -{ yylhsminor.yy636 = setExplainRatio(pCxt, yymsp[-2].minor.yy636, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 237: /* explain_options ::= explain_options RATIO NK_FLOAT */ +{ yylhsminor.yy172 = setExplainRatio(pCxt, yymsp[-2].minor.yy172, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 241: /* cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP */ -{ pCxt->pRootNode = createCompactStmt(pCxt, yymsp[-1].minor.yy236); } + case 238: /* cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP */ +{ pCxt->pRootNode = createCompactStmt(pCxt, yymsp[-1].minor.yy60); } break; - case 242: /* cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */ -{ pCxt->pRootNode = createCreateFunctionStmt(pCxt, yymsp[-6].minor.yy603, yymsp[-8].minor.yy603, &yymsp[-5].minor.yy53, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy450, yymsp[0].minor.yy158); } + case 239: /* cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */ +{ pCxt->pRootNode = createCreateFunctionStmt(pCxt, yymsp[-6].minor.yy617, yymsp[-8].minor.yy617, &yymsp[-5].minor.yy105, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy248, yymsp[0].minor.yy140); } break; - case 243: /* cmd ::= DROP FUNCTION exists_opt function_name */ -{ pCxt->pRootNode = createDropFunctionStmt(pCxt, yymsp[-1].minor.yy603, &yymsp[0].minor.yy53); } + case 240: /* cmd ::= DROP FUNCTION exists_opt function_name */ +{ pCxt->pRootNode = createDropFunctionStmt(pCxt, yymsp[-1].minor.yy617, &yymsp[0].minor.yy105); } break; - case 246: /* bufsize_opt ::= */ -{ yymsp[1].minor.yy158 = 0; } + case 243: /* bufsize_opt ::= */ +{ yymsp[1].minor.yy140 = 0; } break; - case 247: /* bufsize_opt ::= BUFSIZE NK_INTEGER */ -{ yymsp[-1].minor.yy158 = taosStr2Int32(yymsp[0].minor.yy0.z, NULL, 10); } + case 244: /* bufsize_opt ::= BUFSIZE NK_INTEGER */ +{ yymsp[-1].minor.yy140 = taosStr2Int32(yymsp[0].minor.yy0.z, NULL, 10); } break; - case 248: /* cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression */ -{ pCxt->pRootNode = createCreateStreamStmt(pCxt, yymsp[-5].minor.yy603, &yymsp[-4].minor.yy53, yymsp[-2].minor.yy636, yymsp[-3].minor.yy636, yymsp[0].minor.yy636); } + case 245: /* cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression */ +{ pCxt->pRootNode = createCreateStreamStmt(pCxt, yymsp[-5].minor.yy617, &yymsp[-4].minor.yy105, yymsp[-2].minor.yy172, yymsp[-3].minor.yy172, yymsp[0].minor.yy172); } break; - case 249: /* cmd ::= DROP STREAM exists_opt stream_name */ -{ pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy603, &yymsp[0].minor.yy53); } + case 246: /* cmd ::= DROP STREAM exists_opt stream_name */ +{ pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy617, &yymsp[0].minor.yy105); } break; - case 251: /* into_opt ::= INTO full_table_name */ - case 374: /* from_clause ::= FROM table_reference_list */ yytestcase(yyruleno==374); - case 404: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==404); - case 427: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==427); -{ yymsp[-1].minor.yy636 = yymsp[0].minor.yy636; } + case 248: /* into_opt ::= INTO full_table_name */ + case 371: /* from_clause ::= FROM table_reference_list */ yytestcase(yyruleno==371); + case 401: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==401); + case 424: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==424); +{ yymsp[-1].minor.yy172 = yymsp[0].minor.yy172; } break; - case 252: /* stream_options ::= */ -{ yymsp[1].minor.yy636 = createStreamOptions(pCxt); } + case 249: /* stream_options ::= */ +{ yymsp[1].minor.yy172 = createStreamOptions(pCxt); } break; - case 253: /* stream_options ::= stream_options TRIGGER AT_ONCE */ -{ ((SStreamOptions*)yymsp[-2].minor.yy636)->triggerType = STREAM_TRIGGER_AT_ONCE; yylhsminor.yy636 = yymsp[-2].minor.yy636; } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 250: /* stream_options ::= stream_options TRIGGER AT_ONCE */ +{ ((SStreamOptions*)yymsp[-2].minor.yy172)->triggerType = STREAM_TRIGGER_AT_ONCE; yylhsminor.yy172 = yymsp[-2].minor.yy172; } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 254: /* stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ -{ ((SStreamOptions*)yymsp[-2].minor.yy636)->triggerType = STREAM_TRIGGER_WINDOW_CLOSE; yylhsminor.yy636 = yymsp[-2].minor.yy636; } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 251: /* stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ +{ ((SStreamOptions*)yymsp[-2].minor.yy172)->triggerType = STREAM_TRIGGER_WINDOW_CLOSE; yylhsminor.yy172 = yymsp[-2].minor.yy172; } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 255: /* stream_options ::= stream_options WATERMARK duration_literal */ -{ ((SStreamOptions*)yymsp[-2].minor.yy636)->pWatermark = releaseRawExprNode(pCxt, yymsp[0].minor.yy636); yylhsminor.yy636 = yymsp[-2].minor.yy636; } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 252: /* stream_options ::= stream_options WATERMARK duration_literal */ +{ ((SStreamOptions*)yymsp[-2].minor.yy172)->pWatermark = releaseRawExprNode(pCxt, yymsp[0].minor.yy172); yylhsminor.yy172 = yymsp[-2].minor.yy172; } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 256: /* cmd ::= KILL CONNECTION NK_INTEGER */ + case 253: /* cmd ::= KILL CONNECTION NK_INTEGER */ { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_CONNECTION_STMT, &yymsp[0].minor.yy0); } break; - case 257: /* cmd ::= KILL QUERY NK_INTEGER */ + case 254: /* cmd ::= KILL QUERY NK_INTEGER */ { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_QUERY_STMT, &yymsp[0].minor.yy0); } break; - case 258: /* cmd ::= KILL TRANSACTION NK_INTEGER */ + case 255: /* cmd ::= KILL TRANSACTION NK_INTEGER */ { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_TRANSACTION_STMT, &yymsp[0].minor.yy0); } break; - case 259: /* cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ + case 256: /* cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ { pCxt->pRootNode = createMergeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } break; - case 260: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ -{ pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy236); } + case 257: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ +{ pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy60); } break; - case 261: /* cmd ::= SPLIT VGROUP NK_INTEGER */ + case 258: /* cmd ::= SPLIT VGROUP NK_INTEGER */ { pCxt->pRootNode = createSplitVgroupStmt(pCxt, &yymsp[0].minor.yy0); } break; - case 262: /* dnode_list ::= DNODE NK_INTEGER */ -{ yymsp[-1].minor.yy236 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } + case 259: /* dnode_list ::= DNODE NK_INTEGER */ +{ yymsp[-1].minor.yy60 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } break; - case 264: /* cmd ::= SYNCDB db_name REPLICA */ -{ pCxt->pRootNode = createSyncdbStmt(pCxt, &yymsp[-1].minor.yy53); } + case 261: /* cmd ::= SYNCDB db_name REPLICA */ +{ pCxt->pRootNode = createSyncdbStmt(pCxt, &yymsp[-1].minor.yy105); } break; - case 266: /* literal ::= NK_INTEGER */ -{ yylhsminor.yy636 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 263: /* literal ::= NK_INTEGER */ +{ yylhsminor.yy172 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; - case 267: /* literal ::= NK_FLOAT */ -{ yylhsminor.yy636 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 264: /* literal ::= NK_FLOAT */ +{ yylhsminor.yy172 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; - case 268: /* literal ::= NK_STRING */ -{ yylhsminor.yy636 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 265: /* literal ::= NK_STRING */ +{ yylhsminor.yy172 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; - case 269: /* literal ::= NK_BOOL */ -{ yylhsminor.yy636 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 266: /* literal ::= NK_BOOL */ +{ yylhsminor.yy172 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; - case 270: /* literal ::= TIMESTAMP NK_STRING */ -{ yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; + case 267: /* literal ::= TIMESTAMP NK_STRING */ +{ yylhsminor.yy172 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); } + yymsp[-1].minor.yy172 = yylhsminor.yy172; break; - case 271: /* literal ::= duration_literal */ - case 281: /* signed_literal ::= signed */ yytestcase(yyruleno==281); - case 301: /* expression ::= literal */ yytestcase(yyruleno==301); - case 302: /* expression ::= pseudo_column */ yytestcase(yyruleno==302); - case 303: /* expression ::= column_reference */ yytestcase(yyruleno==303); - case 304: /* expression ::= function_expression */ yytestcase(yyruleno==304); - case 305: /* expression ::= subquery */ yytestcase(yyruleno==305); - case 330: /* function_expression ::= literal_func */ yytestcase(yyruleno==330); - case 366: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==366); - case 370: /* boolean_primary ::= predicate */ yytestcase(yyruleno==370); - case 372: /* common_expression ::= expression */ yytestcase(yyruleno==372); - case 373: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==373); - case 375: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==375); - case 377: /* table_reference ::= table_primary */ yytestcase(yyruleno==377); - case 378: /* table_reference ::= joined_table */ yytestcase(yyruleno==378); - case 382: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==382); - case 429: /* query_expression_body ::= query_primary */ yytestcase(yyruleno==429); - case 432: /* query_primary ::= query_specification */ yytestcase(yyruleno==432); -{ yylhsminor.yy636 = yymsp[0].minor.yy636; } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 268: /* literal ::= duration_literal */ + case 278: /* signed_literal ::= signed */ yytestcase(yyruleno==278); + case 298: /* expression ::= literal */ yytestcase(yyruleno==298); + case 299: /* expression ::= pseudo_column */ yytestcase(yyruleno==299); + case 300: /* expression ::= column_reference */ yytestcase(yyruleno==300); + case 301: /* expression ::= function_expression */ yytestcase(yyruleno==301); + case 302: /* expression ::= subquery */ yytestcase(yyruleno==302); + case 327: /* function_expression ::= literal_func */ yytestcase(yyruleno==327); + case 363: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==363); + case 367: /* boolean_primary ::= predicate */ yytestcase(yyruleno==367); + case 369: /* common_expression ::= expression */ yytestcase(yyruleno==369); + case 370: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==370); + case 372: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==372); + case 374: /* table_reference ::= table_primary */ yytestcase(yyruleno==374); + case 375: /* table_reference ::= joined_table */ yytestcase(yyruleno==375); + case 379: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==379); + case 426: /* query_expression_body ::= query_primary */ yytestcase(yyruleno==426); + case 429: /* query_primary ::= query_specification */ yytestcase(yyruleno==429); +{ yylhsminor.yy172 = yymsp[0].minor.yy172; } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; - case 272: /* literal ::= NULL */ -{ yylhsminor.yy636 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 269: /* literal ::= NULL */ +{ yylhsminor.yy172 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; - case 273: /* literal ::= NK_QUESTION */ -{ yylhsminor.yy636 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 270: /* literal ::= NK_QUESTION */ +{ yylhsminor.yy172 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; - case 274: /* duration_literal ::= NK_VARIABLE */ -{ yylhsminor.yy636 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 271: /* duration_literal ::= NK_VARIABLE */ +{ yylhsminor.yy172 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; - case 275: /* signed ::= NK_INTEGER */ -{ yylhsminor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 272: /* signed ::= NK_INTEGER */ +{ yylhsminor.yy172 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; - case 276: /* signed ::= NK_PLUS NK_INTEGER */ -{ yymsp[-1].minor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); } + case 273: /* signed ::= NK_PLUS NK_INTEGER */ +{ yymsp[-1].minor.yy172 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); } break; - case 277: /* signed ::= NK_MINUS NK_INTEGER */ + case 274: /* 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.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &t); + yylhsminor.yy172 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &t); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; + yymsp[-1].minor.yy172 = yylhsminor.yy172; break; - case 278: /* signed ::= NK_FLOAT */ -{ yylhsminor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 275: /* signed ::= NK_FLOAT */ +{ yylhsminor.yy172 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; - case 279: /* signed ::= NK_PLUS NK_FLOAT */ -{ yymsp[-1].minor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } + case 276: /* signed ::= NK_PLUS NK_FLOAT */ +{ yymsp[-1].minor.yy172 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } break; - case 280: /* signed ::= NK_MINUS NK_FLOAT */ + case 277: /* 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.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t); + yylhsminor.yy172 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; + yymsp[-1].minor.yy172 = yylhsminor.yy172; break; - case 282: /* signed_literal ::= NK_STRING */ -{ yylhsminor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 279: /* signed_literal ::= NK_STRING */ +{ yylhsminor.yy172 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; - case 283: /* signed_literal ::= NK_BOOL */ -{ yylhsminor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 280: /* signed_literal ::= NK_BOOL */ +{ yylhsminor.yy172 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; - case 284: /* signed_literal ::= TIMESTAMP NK_STRING */ -{ yymsp[-1].minor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } + case 281: /* signed_literal ::= TIMESTAMP NK_STRING */ +{ yymsp[-1].minor.yy172 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } break; - case 285: /* signed_literal ::= duration_literal */ - case 287: /* signed_literal ::= literal_func */ yytestcase(yyruleno==287); - case 344: /* star_func_para ::= expression */ yytestcase(yyruleno==344); - case 399: /* select_item ::= common_expression */ yytestcase(yyruleno==399); - case 445: /* search_condition ::= common_expression */ yytestcase(yyruleno==445); -{ yylhsminor.yy636 = releaseRawExprNode(pCxt, yymsp[0].minor.yy636); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 282: /* signed_literal ::= duration_literal */ + case 284: /* signed_literal ::= literal_func */ yytestcase(yyruleno==284); + case 341: /* star_func_para ::= expression */ yytestcase(yyruleno==341); + case 396: /* select_item ::= common_expression */ yytestcase(yyruleno==396); + case 442: /* search_condition ::= common_expression */ yytestcase(yyruleno==442); +{ yylhsminor.yy172 = releaseRawExprNode(pCxt, yymsp[0].minor.yy172); } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; - case 286: /* signed_literal ::= NULL */ -{ yylhsminor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 283: /* signed_literal ::= NULL */ +{ yylhsminor.yy172 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; - case 306: /* expression ::= NK_LP expression NK_RP */ - case 371: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==371); -{ yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy636)); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 303: /* expression ::= NK_LP expression NK_RP */ + case 368: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==368); +{ yylhsminor.yy172 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy172)); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 307: /* expression ::= NK_PLUS expression */ + case 304: /* expression ::= NK_PLUS expression */ { - SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy636)); + SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy172); + yylhsminor.yy172 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy172)); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; + yymsp[-1].minor.yy172 = yylhsminor.yy172; break; - case 308: /* expression ::= NK_MINUS expression */ + case 305: /* expression ::= NK_MINUS expression */ { - SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy636), NULL)); + SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy172); + yylhsminor.yy172 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy172), NULL)); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; + yymsp[-1].minor.yy172 = yylhsminor.yy172; break; - case 309: /* expression ::= expression NK_PLUS expression */ + case 306: /* expression ::= expression NK_PLUS expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy636); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_ADD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy172); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy172); + yylhsminor.yy172 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_ADD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy172), releaseRawExprNode(pCxt, yymsp[0].minor.yy172))); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 310: /* expression ::= expression NK_MINUS expression */ + case 307: /* expression ::= expression NK_MINUS expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy636); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_SUB, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy172); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy172); + yylhsminor.yy172 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_SUB, releaseRawExprNode(pCxt, yymsp[-2].minor.yy172), releaseRawExprNode(pCxt, yymsp[0].minor.yy172))); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 311: /* expression ::= expression NK_STAR expression */ + case 308: /* expression ::= expression NK_STAR expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy636); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MULTI, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy172); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy172); + yylhsminor.yy172 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MULTI, releaseRawExprNode(pCxt, yymsp[-2].minor.yy172), releaseRawExprNode(pCxt, yymsp[0].minor.yy172))); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 312: /* expression ::= expression NK_SLASH expression */ + case 309: /* expression ::= expression NK_SLASH expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy636); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_DIV, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy172); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy172); + yylhsminor.yy172 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_DIV, releaseRawExprNode(pCxt, yymsp[-2].minor.yy172), releaseRawExprNode(pCxt, yymsp[0].minor.yy172))); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 313: /* expression ::= expression NK_REM expression */ + case 310: /* expression ::= expression NK_REM expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy636); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MOD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy172); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy172); + yylhsminor.yy172 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MOD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy172), releaseRawExprNode(pCxt, yymsp[0].minor.yy172))); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 314: /* expression ::= column_reference NK_ARROW NK_STRING */ + case 311: /* expression ::= column_reference NK_ARROW NK_STRING */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy172); + yylhsminor.yy172 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy172), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0))); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 315: /* expression_list ::= expression */ -{ yylhsminor.yy236 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy636)); } - yymsp[0].minor.yy236 = yylhsminor.yy236; + case 312: /* expression_list ::= expression */ +{ yylhsminor.yy60 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy172)); } + yymsp[0].minor.yy60 = yylhsminor.yy60; break; - case 316: /* expression_list ::= expression_list NK_COMMA expression */ -{ yylhsminor.yy236 = addNodeToList(pCxt, yymsp[-2].minor.yy236, releaseRawExprNode(pCxt, yymsp[0].minor.yy636)); } - yymsp[-2].minor.yy236 = yylhsminor.yy236; + case 313: /* expression_list ::= expression_list NK_COMMA expression */ +{ yylhsminor.yy60 = addNodeToList(pCxt, yymsp[-2].minor.yy60, releaseRawExprNode(pCxt, yymsp[0].minor.yy172)); } + yymsp[-2].minor.yy60 = yylhsminor.yy60; break; - case 317: /* column_reference ::= column_name */ -{ yylhsminor.yy636 = createRawExprNode(pCxt, &yymsp[0].minor.yy53, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy53)); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 314: /* column_reference ::= column_name */ +{ yylhsminor.yy172 = createRawExprNode(pCxt, &yymsp[0].minor.yy105, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy105)); } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; - case 318: /* column_reference ::= table_name NK_DOT column_name */ -{ yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy53, createColumnNode(pCxt, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy53)); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 315: /* column_reference ::= table_name NK_DOT column_name */ +{ yylhsminor.yy172 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy105, &yymsp[0].minor.yy105, createColumnNode(pCxt, &yymsp[-2].minor.yy105, &yymsp[0].minor.yy105)); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 319: /* pseudo_column ::= ROWTS */ - case 320: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==320); - case 322: /* pseudo_column ::= QSTARTTS */ yytestcase(yyruleno==322); - case 323: /* pseudo_column ::= QENDTS */ yytestcase(yyruleno==323); - case 324: /* pseudo_column ::= WSTARTTS */ yytestcase(yyruleno==324); - case 325: /* pseudo_column ::= WENDTS */ yytestcase(yyruleno==325); - case 326: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==326); - case 332: /* literal_func ::= NOW */ yytestcase(yyruleno==332); -{ yylhsminor.yy636 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 316: /* pseudo_column ::= ROWTS */ + case 317: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==317); + case 319: /* pseudo_column ::= QSTARTTS */ yytestcase(yyruleno==319); + case 320: /* pseudo_column ::= QENDTS */ yytestcase(yyruleno==320); + case 321: /* pseudo_column ::= WSTARTTS */ yytestcase(yyruleno==321); + case 322: /* pseudo_column ::= WENDTS */ yytestcase(yyruleno==322); + case 323: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==323); + case 329: /* literal_func ::= NOW */ yytestcase(yyruleno==329); +{ yylhsminor.yy172 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); } + yymsp[0].minor.yy172 = yylhsminor.yy172; break; - case 321: /* pseudo_column ::= table_name NK_DOT TBNAME */ -{ yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy53)))); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 318: /* pseudo_column ::= table_name NK_DOT TBNAME */ +{ yylhsminor.yy172 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy105, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy105)))); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 327: /* function_expression ::= function_name NK_LP expression_list NK_RP */ - case 328: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==328); -{ yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy53, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy53, yymsp[-1].minor.yy236)); } - yymsp[-3].minor.yy636 = yylhsminor.yy636; + case 324: /* function_expression ::= function_name NK_LP expression_list NK_RP */ + case 325: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==325); +{ yylhsminor.yy172 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy105, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy105, yymsp[-1].minor.yy60)); } + yymsp[-3].minor.yy172 = yylhsminor.yy172; break; - case 329: /* function_expression ::= CAST NK_LP expression AS type_name NK_RP */ -{ yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy636), yymsp[-1].minor.yy450)); } - yymsp[-5].minor.yy636 = yylhsminor.yy636; + case 326: /* function_expression ::= CAST NK_LP expression AS type_name NK_RP */ +{ yylhsminor.yy172 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy172), yymsp[-1].minor.yy248)); } + yymsp[-5].minor.yy172 = yylhsminor.yy172; break; - case 331: /* literal_func ::= noarg_func NK_LP NK_RP */ -{ yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy53, NULL)); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 328: /* literal_func ::= noarg_func NK_LP NK_RP */ +{ yylhsminor.yy172 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy105, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy105, NULL)); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 340: /* star_func_para_list ::= NK_STAR */ -{ yylhsminor.yy236 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy236 = yylhsminor.yy236; + case 337: /* star_func_para_list ::= NK_STAR */ +{ yylhsminor.yy60 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy60 = yylhsminor.yy60; break; - case 345: /* star_func_para ::= table_name NK_DOT NK_STAR */ - case 402: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==402); -{ yylhsminor.yy636 = createColumnNode(pCxt, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 342: /* star_func_para ::= table_name NK_DOT NK_STAR */ + case 399: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==399); +{ yylhsminor.yy172 = createColumnNode(pCxt, &yymsp[-2].minor.yy105, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 346: /* predicate ::= expression compare_op expression */ - case 351: /* predicate ::= expression in_op in_predicate_value */ yytestcase(yyruleno==351); + case 343: /* predicate ::= expression compare_op expression */ + case 348: /* predicate ::= expression in_op in_predicate_value */ yytestcase(yyruleno==348); { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy636); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, yymsp[-1].minor.yy136, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy172); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy172); + yylhsminor.yy172 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, yymsp[-1].minor.yy572, releaseRawExprNode(pCxt, yymsp[-2].minor.yy172), releaseRawExprNode(pCxt, yymsp[0].minor.yy172))); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 347: /* predicate ::= expression BETWEEN expression AND expression */ + case 344: /* predicate ::= expression BETWEEN expression AND expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy636); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &e, createBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-4].minor.yy636), releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy172); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy172); + yylhsminor.yy172 = createRawExprNodeExt(pCxt, &s, &e, createBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-4].minor.yy172), releaseRawExprNode(pCxt, yymsp[-2].minor.yy172), releaseRawExprNode(pCxt, yymsp[0].minor.yy172))); } - yymsp[-4].minor.yy636 = yylhsminor.yy636; + yymsp[-4].minor.yy172 = yylhsminor.yy172; break; - case 348: /* predicate ::= expression NOT BETWEEN expression AND expression */ + case 345: /* predicate ::= expression NOT BETWEEN expression AND expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy636); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &e, createNotBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy636), releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy172); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy172); + yylhsminor.yy172 = createRawExprNodeExt(pCxt, &s, &e, createNotBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy172), releaseRawExprNode(pCxt, yymsp[-2].minor.yy172), releaseRawExprNode(pCxt, yymsp[0].minor.yy172))); } - yymsp[-5].minor.yy636 = yylhsminor.yy636; + yymsp[-5].minor.yy172 = yylhsminor.yy172; break; - case 349: /* predicate ::= expression IS NULL */ + case 346: /* predicate ::= expression IS NULL */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), NULL)); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy172); + yylhsminor.yy172 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy172), NULL)); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 350: /* predicate ::= expression IS NOT NULL */ + case 347: /* predicate ::= expression IS NOT NULL */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy636), NULL)); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy172); + yylhsminor.yy172 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy172), NULL)); } - yymsp[-3].minor.yy636 = yylhsminor.yy636; + yymsp[-3].minor.yy172 = yylhsminor.yy172; break; - case 352: /* compare_op ::= NK_LT */ -{ yymsp[0].minor.yy136 = OP_TYPE_LOWER_THAN; } + case 349: /* compare_op ::= NK_LT */ +{ yymsp[0].minor.yy572 = OP_TYPE_LOWER_THAN; } break; - case 353: /* compare_op ::= NK_GT */ -{ yymsp[0].minor.yy136 = OP_TYPE_GREATER_THAN; } + case 350: /* compare_op ::= NK_GT */ +{ yymsp[0].minor.yy572 = OP_TYPE_GREATER_THAN; } break; - case 354: /* compare_op ::= NK_LE */ -{ yymsp[0].minor.yy136 = OP_TYPE_LOWER_EQUAL; } + case 351: /* compare_op ::= NK_LE */ +{ yymsp[0].minor.yy572 = OP_TYPE_LOWER_EQUAL; } break; - case 355: /* compare_op ::= NK_GE */ -{ yymsp[0].minor.yy136 = OP_TYPE_GREATER_EQUAL; } + case 352: /* compare_op ::= NK_GE */ +{ yymsp[0].minor.yy572 = OP_TYPE_GREATER_EQUAL; } break; - case 356: /* compare_op ::= NK_NE */ -{ yymsp[0].minor.yy136 = OP_TYPE_NOT_EQUAL; } + case 353: /* compare_op ::= NK_NE */ +{ yymsp[0].minor.yy572 = OP_TYPE_NOT_EQUAL; } break; - case 357: /* compare_op ::= NK_EQ */ -{ yymsp[0].minor.yy136 = OP_TYPE_EQUAL; } + case 354: /* compare_op ::= NK_EQ */ +{ yymsp[0].minor.yy572 = OP_TYPE_EQUAL; } break; - case 358: /* compare_op ::= LIKE */ -{ yymsp[0].minor.yy136 = OP_TYPE_LIKE; } + case 355: /* compare_op ::= LIKE */ +{ yymsp[0].minor.yy572 = OP_TYPE_LIKE; } break; - case 359: /* compare_op ::= NOT LIKE */ -{ yymsp[-1].minor.yy136 = OP_TYPE_NOT_LIKE; } + case 356: /* compare_op ::= NOT LIKE */ +{ yymsp[-1].minor.yy572 = OP_TYPE_NOT_LIKE; } break; - case 360: /* compare_op ::= MATCH */ -{ yymsp[0].minor.yy136 = OP_TYPE_MATCH; } + case 357: /* compare_op ::= MATCH */ +{ yymsp[0].minor.yy572 = OP_TYPE_MATCH; } break; - case 361: /* compare_op ::= NMATCH */ -{ yymsp[0].minor.yy136 = OP_TYPE_NMATCH; } + case 358: /* compare_op ::= NMATCH */ +{ yymsp[0].minor.yy572 = OP_TYPE_NMATCH; } break; - case 362: /* compare_op ::= CONTAINS */ -{ yymsp[0].minor.yy136 = OP_TYPE_JSON_CONTAINS; } + case 359: /* compare_op ::= CONTAINS */ +{ yymsp[0].minor.yy572 = OP_TYPE_JSON_CONTAINS; } break; - case 363: /* in_op ::= IN */ -{ yymsp[0].minor.yy136 = OP_TYPE_IN; } + case 360: /* in_op ::= IN */ +{ yymsp[0].minor.yy572 = OP_TYPE_IN; } break; - case 364: /* in_op ::= NOT IN */ -{ yymsp[-1].minor.yy136 = OP_TYPE_NOT_IN; } + case 361: /* in_op ::= NOT IN */ +{ yymsp[-1].minor.yy572 = OP_TYPE_NOT_IN; } break; - case 365: /* in_predicate_value ::= NK_LP expression_list NK_RP */ -{ yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy236)); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 362: /* in_predicate_value ::= NK_LP expression_list NK_RP */ +{ yylhsminor.yy172 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy60)); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 367: /* boolean_value_expression ::= NOT boolean_primary */ + case 364: /* boolean_value_expression ::= NOT boolean_primary */ { - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy636), NULL)); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy172); + yylhsminor.yy172 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy172), NULL)); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; + yymsp[-1].minor.yy172 = yylhsminor.yy172; break; - case 368: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ + case 365: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy636); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy172); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy172); + yylhsminor.yy172 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy172), releaseRawExprNode(pCxt, yymsp[0].minor.yy172))); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 369: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ + case 366: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy636); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy172); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy172); + yylhsminor.yy172 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy172), releaseRawExprNode(pCxt, yymsp[0].minor.yy172))); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 376: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */ -{ yylhsminor.yy636 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy636, yymsp[0].minor.yy636, NULL); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 373: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */ +{ yylhsminor.yy172 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy172, yymsp[0].minor.yy172, NULL); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 379: /* table_primary ::= table_name alias_opt */ -{ yylhsminor.yy636 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy53, &yymsp[0].minor.yy53); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; + case 376: /* table_primary ::= table_name alias_opt */ +{ yylhsminor.yy172 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy105, &yymsp[0].minor.yy105); } + yymsp[-1].minor.yy172 = yylhsminor.yy172; break; - case 380: /* table_primary ::= db_name NK_DOT table_name alias_opt */ -{ yylhsminor.yy636 = createRealTableNode(pCxt, &yymsp[-3].minor.yy53, &yymsp[-1].minor.yy53, &yymsp[0].minor.yy53); } - yymsp[-3].minor.yy636 = yylhsminor.yy636; + case 377: /* table_primary ::= db_name NK_DOT table_name alias_opt */ +{ yylhsminor.yy172 = createRealTableNode(pCxt, &yymsp[-3].minor.yy105, &yymsp[-1].minor.yy105, &yymsp[0].minor.yy105); } + yymsp[-3].minor.yy172 = yylhsminor.yy172; break; - case 381: /* table_primary ::= subquery alias_opt */ -{ yylhsminor.yy636 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy636), &yymsp[0].minor.yy53); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; + case 378: /* table_primary ::= subquery alias_opt */ +{ yylhsminor.yy172 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy172), &yymsp[0].minor.yy105); } + yymsp[-1].minor.yy172 = yylhsminor.yy172; break; - case 383: /* alias_opt ::= */ -{ yymsp[1].minor.yy53 = nil_token; } + case 380: /* alias_opt ::= */ +{ yymsp[1].minor.yy105 = nil_token; } break; - case 384: /* alias_opt ::= table_alias */ -{ yylhsminor.yy53 = yymsp[0].minor.yy53; } - yymsp[0].minor.yy53 = yylhsminor.yy53; + case 381: /* alias_opt ::= table_alias */ +{ yylhsminor.yy105 = yymsp[0].minor.yy105; } + yymsp[0].minor.yy105 = yylhsminor.yy105; break; - case 385: /* alias_opt ::= AS table_alias */ -{ yymsp[-1].minor.yy53 = yymsp[0].minor.yy53; } + case 382: /* alias_opt ::= AS table_alias */ +{ yymsp[-1].minor.yy105 = yymsp[0].minor.yy105; } break; - case 386: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - case 387: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==387); -{ yymsp[-2].minor.yy636 = yymsp[-1].minor.yy636; } + case 383: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */ + case 384: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==384); +{ yymsp[-2].minor.yy172 = yymsp[-1].minor.yy172; } break; - case 388: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ -{ yylhsminor.yy636 = createJoinTableNode(pCxt, yymsp[-4].minor.yy342, yymsp[-5].minor.yy636, yymsp[-2].minor.yy636, yymsp[0].minor.yy636); } - yymsp[-5].minor.yy636 = yylhsminor.yy636; + case 385: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ +{ yylhsminor.yy172 = createJoinTableNode(pCxt, yymsp[-4].minor.yy636, yymsp[-5].minor.yy172, yymsp[-2].minor.yy172, yymsp[0].minor.yy172); } + yymsp[-5].minor.yy172 = yylhsminor.yy172; break; - case 389: /* join_type ::= */ -{ yymsp[1].minor.yy342 = JOIN_TYPE_INNER; } + case 386: /* join_type ::= */ +{ yymsp[1].minor.yy636 = JOIN_TYPE_INNER; } break; - case 390: /* join_type ::= INNER */ -{ yymsp[0].minor.yy342 = JOIN_TYPE_INNER; } + case 387: /* join_type ::= INNER */ +{ yymsp[0].minor.yy636 = JOIN_TYPE_INNER; } break; - case 391: /* query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ + case 388: /* query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ { - yymsp[-8].minor.yy636 = createSelectStmt(pCxt, yymsp[-7].minor.yy603, yymsp[-6].minor.yy236, yymsp[-5].minor.yy636); - yymsp[-8].minor.yy636 = addWhereClause(pCxt, yymsp[-8].minor.yy636, yymsp[-4].minor.yy636); - yymsp[-8].minor.yy636 = addPartitionByClause(pCxt, yymsp[-8].minor.yy636, yymsp[-3].minor.yy236); - yymsp[-8].minor.yy636 = addWindowClauseClause(pCxt, yymsp[-8].minor.yy636, yymsp[-2].minor.yy636); - yymsp[-8].minor.yy636 = addGroupByClause(pCxt, yymsp[-8].minor.yy636, yymsp[-1].minor.yy236); - yymsp[-8].minor.yy636 = addHavingClause(pCxt, yymsp[-8].minor.yy636, yymsp[0].minor.yy636); + yymsp[-8].minor.yy172 = createSelectStmt(pCxt, yymsp[-7].minor.yy617, yymsp[-6].minor.yy60, yymsp[-5].minor.yy172); + yymsp[-8].minor.yy172 = addWhereClause(pCxt, yymsp[-8].minor.yy172, yymsp[-4].minor.yy172); + yymsp[-8].minor.yy172 = addPartitionByClause(pCxt, yymsp[-8].minor.yy172, yymsp[-3].minor.yy60); + yymsp[-8].minor.yy172 = addWindowClauseClause(pCxt, yymsp[-8].minor.yy172, yymsp[-2].minor.yy172); + yymsp[-8].minor.yy172 = addGroupByClause(pCxt, yymsp[-8].minor.yy172, yymsp[-1].minor.yy60); + yymsp[-8].minor.yy172 = addHavingClause(pCxt, yymsp[-8].minor.yy172, yymsp[0].minor.yy172); } break; - case 394: /* set_quantifier_opt ::= ALL */ -{ yymsp[0].minor.yy603 = false; } + case 391: /* set_quantifier_opt ::= ALL */ +{ yymsp[0].minor.yy617 = false; } break; - case 395: /* select_list ::= NK_STAR */ -{ yymsp[0].minor.yy236 = NULL; } + case 392: /* select_list ::= NK_STAR */ +{ yymsp[0].minor.yy60 = NULL; } break; - case 400: /* select_item ::= common_expression column_alias */ -{ yylhsminor.yy636 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy636), &yymsp[0].minor.yy53); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; + case 397: /* select_item ::= common_expression column_alias */ +{ yylhsminor.yy172 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy172), &yymsp[0].minor.yy105); } + yymsp[-1].minor.yy172 = yylhsminor.yy172; break; - case 401: /* select_item ::= common_expression AS column_alias */ -{ yylhsminor.yy636 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), &yymsp[0].minor.yy53); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 398: /* select_item ::= common_expression AS column_alias */ +{ yylhsminor.yy172 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy172), &yymsp[0].minor.yy105); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 406: /* partition_by_clause_opt ::= PARTITION BY expression_list */ - case 423: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==423); - case 435: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==435); -{ yymsp[-2].minor.yy236 = yymsp[0].minor.yy236; } + case 403: /* partition_by_clause_opt ::= PARTITION BY expression_list */ + case 420: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==420); + case 432: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==432); +{ yymsp[-2].minor.yy60 = yymsp[0].minor.yy60; } break; - case 408: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ -{ yymsp[-5].minor.yy636 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy636), releaseRawExprNode(pCxt, yymsp[-1].minor.yy636)); } + case 405: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ +{ yymsp[-5].minor.yy172 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy172), releaseRawExprNode(pCxt, yymsp[-1].minor.yy172)); } break; - case 409: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */ -{ yymsp[-3].minor.yy636 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy636)); } + case 406: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */ +{ yymsp[-3].minor.yy172 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy172)); } break; - case 410: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ -{ yymsp[-5].minor.yy636 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy636), NULL, yymsp[-1].minor.yy636, yymsp[0].minor.yy636); } + case 407: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ +{ yymsp[-5].minor.yy172 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy172), NULL, yymsp[-1].minor.yy172, yymsp[0].minor.yy172); } break; - case 411: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ -{ yymsp[-7].minor.yy636 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy636), releaseRawExprNode(pCxt, yymsp[-3].minor.yy636), yymsp[-1].minor.yy636, yymsp[0].minor.yy636); } + case 408: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ +{ yymsp[-7].minor.yy172 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy172), releaseRawExprNode(pCxt, yymsp[-3].minor.yy172), yymsp[-1].minor.yy172, yymsp[0].minor.yy172); } break; - case 413: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ -{ yymsp[-3].minor.yy636 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy636); } + case 410: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ +{ yymsp[-3].minor.yy172 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy172); } break; - case 415: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ -{ yymsp[-3].minor.yy636 = createFillNode(pCxt, yymsp[-1].minor.yy18, NULL); } + case 412: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ +{ yymsp[-3].minor.yy172 = createFillNode(pCxt, yymsp[-1].minor.yy202, NULL); } break; - case 416: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ -{ yymsp[-5].minor.yy636 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy236)); } + case 413: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ +{ yymsp[-5].minor.yy172 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy60)); } break; - case 417: /* fill_mode ::= NONE */ -{ yymsp[0].minor.yy18 = FILL_MODE_NONE; } + case 414: /* fill_mode ::= NONE */ +{ yymsp[0].minor.yy202 = FILL_MODE_NONE; } break; - case 418: /* fill_mode ::= PREV */ -{ yymsp[0].minor.yy18 = FILL_MODE_PREV; } + case 415: /* fill_mode ::= PREV */ +{ yymsp[0].minor.yy202 = FILL_MODE_PREV; } break; - case 419: /* fill_mode ::= NULL */ -{ yymsp[0].minor.yy18 = FILL_MODE_NULL; } + case 416: /* fill_mode ::= NULL */ +{ yymsp[0].minor.yy202 = FILL_MODE_NULL; } break; - case 420: /* fill_mode ::= LINEAR */ -{ yymsp[0].minor.yy18 = FILL_MODE_LINEAR; } + case 417: /* fill_mode ::= LINEAR */ +{ yymsp[0].minor.yy202 = FILL_MODE_LINEAR; } break; - case 421: /* fill_mode ::= NEXT */ -{ yymsp[0].minor.yy18 = FILL_MODE_NEXT; } + case 418: /* fill_mode ::= NEXT */ +{ yymsp[0].minor.yy202 = FILL_MODE_NEXT; } break; - case 424: /* group_by_list ::= expression */ -{ yylhsminor.yy236 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); } - yymsp[0].minor.yy236 = yylhsminor.yy236; + case 421: /* group_by_list ::= expression */ +{ yylhsminor.yy60 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy172))); } + yymsp[0].minor.yy60 = yylhsminor.yy60; break; - case 425: /* group_by_list ::= group_by_list NK_COMMA expression */ -{ yylhsminor.yy236 = addNodeToList(pCxt, yymsp[-2].minor.yy236, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); } - yymsp[-2].minor.yy236 = yylhsminor.yy236; + case 422: /* group_by_list ::= group_by_list NK_COMMA expression */ +{ yylhsminor.yy60 = addNodeToList(pCxt, yymsp[-2].minor.yy60, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy172))); } + yymsp[-2].minor.yy60 = yylhsminor.yy60; break; - case 428: /* query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ + case 425: /* query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ { - yylhsminor.yy636 = addOrderByClause(pCxt, yymsp[-3].minor.yy636, yymsp[-2].minor.yy236); - yylhsminor.yy636 = addSlimitClause(pCxt, yylhsminor.yy636, yymsp[-1].minor.yy636); - yylhsminor.yy636 = addLimitClause(pCxt, yylhsminor.yy636, yymsp[0].minor.yy636); + yylhsminor.yy172 = addOrderByClause(pCxt, yymsp[-3].minor.yy172, yymsp[-2].minor.yy60); + yylhsminor.yy172 = addSlimitClause(pCxt, yylhsminor.yy172, yymsp[-1].minor.yy172); + yylhsminor.yy172 = addLimitClause(pCxt, yylhsminor.yy172, yymsp[0].minor.yy172); } - yymsp[-3].minor.yy636 = yylhsminor.yy636; + yymsp[-3].minor.yy172 = yylhsminor.yy172; break; - case 430: /* query_expression_body ::= query_expression_body UNION ALL query_expression_body */ -{ yylhsminor.yy636 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy636, yymsp[0].minor.yy636); } - yymsp[-3].minor.yy636 = yylhsminor.yy636; + case 427: /* query_expression_body ::= query_expression_body UNION ALL query_expression_body */ +{ yylhsminor.yy172 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy172, yymsp[0].minor.yy172); } + yymsp[-3].minor.yy172 = yylhsminor.yy172; break; - case 431: /* query_expression_body ::= query_expression_body UNION query_expression_body */ -{ yylhsminor.yy636 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy636, yymsp[0].minor.yy636); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 428: /* query_expression_body ::= query_expression_body UNION query_expression_body */ +{ yylhsminor.yy172 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy172, yymsp[0].minor.yy172); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 433: /* query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */ -{ yymsp[-5].minor.yy636 = yymsp[-4].minor.yy636; } - yy_destructor(yypParser,353,&yymsp[-3].minor); - yy_destructor(yypParser,354,&yymsp[-2].minor); - yy_destructor(yypParser,355,&yymsp[-1].minor); + case 430: /* query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */ +{ yymsp[-5].minor.yy172 = yymsp[-4].minor.yy172; } + yy_destructor(yypParser,350,&yymsp[-3].minor); + yy_destructor(yypParser,351,&yymsp[-2].minor); + yy_destructor(yypParser,352,&yymsp[-1].minor); break; - case 437: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ - case 441: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==441); -{ yymsp[-1].minor.yy636 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); } + case 434: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ + case 438: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==438); +{ yymsp[-1].minor.yy172 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); } break; - case 438: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - case 442: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==442); -{ yymsp[-3].minor.yy636 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } + case 435: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + case 439: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==439); +{ yymsp[-3].minor.yy172 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } break; - case 439: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - case 443: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==443); -{ yymsp[-3].minor.yy636 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); } + case 436: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + case 440: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==440); +{ yymsp[-3].minor.yy172 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); } break; - case 444: /* subquery ::= NK_LP query_expression NK_RP */ -{ yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy636); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 441: /* subquery ::= NK_LP query_expression NK_RP */ +{ yylhsminor.yy172 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy172); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 448: /* sort_specification ::= expression ordering_specification_opt null_ordering_opt */ -{ yylhsminor.yy636 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), yymsp[-1].minor.yy430, yymsp[0].minor.yy185); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 445: /* sort_specification ::= expression ordering_specification_opt null_ordering_opt */ +{ yylhsminor.yy172 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy172), yymsp[-1].minor.yy14, yymsp[0].minor.yy17); } + yymsp[-2].minor.yy172 = yylhsminor.yy172; break; - case 449: /* ordering_specification_opt ::= */ -{ yymsp[1].minor.yy430 = ORDER_ASC; } + case 446: /* ordering_specification_opt ::= */ +{ yymsp[1].minor.yy14 = ORDER_ASC; } break; - case 450: /* ordering_specification_opt ::= ASC */ -{ yymsp[0].minor.yy430 = ORDER_ASC; } + case 447: /* ordering_specification_opt ::= ASC */ +{ yymsp[0].minor.yy14 = ORDER_ASC; } break; - case 451: /* ordering_specification_opt ::= DESC */ -{ yymsp[0].minor.yy430 = ORDER_DESC; } + case 448: /* ordering_specification_opt ::= DESC */ +{ yymsp[0].minor.yy14 = ORDER_DESC; } break; - case 452: /* null_ordering_opt ::= */ -{ yymsp[1].minor.yy185 = NULL_ORDER_DEFAULT; } + case 449: /* null_ordering_opt ::= */ +{ yymsp[1].minor.yy17 = NULL_ORDER_DEFAULT; } break; - case 453: /* null_ordering_opt ::= NULLS FIRST */ -{ yymsp[-1].minor.yy185 = NULL_ORDER_FIRST; } + case 450: /* null_ordering_opt ::= NULLS FIRST */ +{ yymsp[-1].minor.yy17 = NULL_ORDER_FIRST; } break; - case 454: /* null_ordering_opt ::= NULLS LAST */ -{ yymsp[-1].minor.yy185 = NULL_ORDER_LAST; } + case 451: /* null_ordering_opt ::= NULLS LAST */ +{ yymsp[-1].minor.yy17 = NULL_ORDER_LAST; } break; default: break; diff --git a/source/libs/parser/test/parInitialCTest.cpp b/source/libs/parser/test/parInitialCTest.cpp index a5e7ef51a7..02f4647ae7 100644 --- a/source/libs/parser/test/parInitialCTest.cpp +++ b/source/libs/parser/test/parInitialCTest.cpp @@ -440,13 +440,62 @@ TEST_F(ParserInitialCTest, createTable) { TEST_F(ParserInitialCTest, createTopic) { useDb("root", "test"); + SCMCreateTopicReq expect = {0}; + + auto setCreateTopicReqFunc = [&](const char* pTopicName, int8_t igExists, const char* pSql, const char* pAst, + const char* pDbName = nullptr, const char* pTbname = nullptr) { + memset(&expect, 0, sizeof(SMCreateStbReq)); + snprintf(expect.name, sizeof(expect.name), "0.%s", pTopicName); + expect.igExists = igExists; + expect.sql = (char*)pSql; + if (nullptr != pTbname) { + expect.subType = TOPIC_SUB_TYPE__TABLE; + snprintf(expect.subStbName, sizeof(expect.subStbName), "0.%s.%s", pDbName, pTbname); + } else if (nullptr != pAst) { + expect.subType = TOPIC_SUB_TYPE__COLUMN; + expect.ast = (char*)pAst; + } else { + expect.subType = TOPIC_SUB_TYPE__DB; + snprintf(expect.subStbName, sizeof(expect.subStbName), "0.%s", pDbName); + } + }; + + setCheckDdlFunc([&](const SQuery* pQuery, ParserStage stage) { + ASSERT_EQ(nodeType(pQuery->pRoot), QUERY_NODE_CREATE_TOPIC_STMT); + SCMCreateTopicReq req = {0}; + ASSERT_TRUE(TSDB_CODE_SUCCESS == + tDeserializeSCMCreateTopicReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req)); + + ASSERT_EQ(std::string(req.name), std::string(expect.name)); + ASSERT_EQ(req.igExists, expect.igExists); + ASSERT_EQ(req.subType, expect.subType); + ASSERT_EQ(std::string(req.sql), std::string(expect.sql)); + switch (expect.subType) { + case TOPIC_SUB_TYPE__DB: + ASSERT_EQ(std::string(req.subDbName), std::string(expect.subDbName)); + break; + case TOPIC_SUB_TYPE__TABLE: + ASSERT_EQ(std::string(req.subStbName), std::string(expect.subStbName)); + break; + case TOPIC_SUB_TYPE__COLUMN: + ASSERT_NE(req.ast, nullptr); + break; + default: + ASSERT_TRUE(false); + } + }); + + setCreateTopicReqFunc("tp1", 0, "create topic tp1 as select * from t1", "ast"); run("CREATE TOPIC tp1 AS SELECT * FROM t1"); - run("CREATE TOPIC IF NOT EXISTS tp1 AS SELECT * FROM t1"); + setCreateTopicReqFunc("tp1", 1, "create topic if not exists tp1 as select ts, ceil(c1) from t1", "ast"); + run("CREATE TOPIC IF NOT EXISTS tp1 AS SELECT ts, CEIL(c1) FROM t1"); - run("CREATE TOPIC tp1 AS test"); + setCreateTopicReqFunc("tp1", 0, "create topic tp1 as database test", nullptr, "test"); + run("CREATE TOPIC tp1 AS DATABASE test"); - run("CREATE TOPIC IF NOT EXISTS tp1 AS test"); + setCreateTopicReqFunc("tp1", 1, "create topic if not exists tp1 as stable st1", nullptr, "test", "st1"); + run("CREATE TOPIC IF NOT EXISTS tp1 AS STABLE st1"); } TEST_F(ParserInitialCTest, createUser) { From 451d19f98653208a6f67b5536d661053ee97dc06 Mon Sep 17 00:00:00 2001 From: Liu Jicong Date: Tue, 31 May 2022 16:20:40 +0800 Subject: [PATCH 04/14] feat(tmq): create topic new grammar --- example/src/tmq.c | 4 +- include/common/tmsg.h | 24 +- source/dnode/mnode/impl/inc/mndDef.h | 38 +- source/dnode/mnode/impl/src/mndDef.c | 18 +- source/dnode/mnode/impl/src/mndScheduler.c | 4 +- source/dnode/mnode/impl/src/mndSubscribe.c | 12 +- source/dnode/mnode/impl/src/mndTopic.c | 44 ++- source/dnode/vnode/CMakeLists.txt | 1 + source/dnode/vnode/src/inc/tq.h | 95 ++++- source/dnode/vnode/src/tq/tq.c | 440 ++++++++------------- source/dnode/vnode/src/tq/tqExec.c | 124 ++++++ source/dnode/vnode/src/tq/tqMeta.c | 14 + source/dnode/vnode/src/tq/tqRead.c | 52 ++- tests/system-test/7-tmq/subscribeDb.py | 10 +- tests/system-test/7-tmq/subscribeDb0.py | 12 +- tests/system-test/7-tmq/subscribeDb1.py | 8 +- 16 files changed, 513 insertions(+), 387 deletions(-) create mode 100644 source/dnode/vnode/src/tq/tqExec.c create mode 100644 source/dnode/vnode/src/tq/tqMeta.c diff --git a/example/src/tmq.c b/example/src/tmq.c index 913096ee90..8d64bd3e79 100644 --- a/example/src/tmq.c +++ b/example/src/tmq.c @@ -106,8 +106,8 @@ int32_t create_topic() { } taos_free_result(pRes); - /*pRes = taos_query(pConn, "create topic topic_ctb_column as abc1");*/ - pRes = taos_query(pConn, "create topic topic_ctb_column as select ts, c1, c2, c3 from st1"); + pRes = taos_query(pConn, "create topic topic_ctb_column as database abc1"); + /*pRes = taos_query(pConn, "create topic topic_ctb_column as select ts, c1, c2, c3 from st1");*/ if (taos_errno(pRes) != 0) { printf("failed to create topic topic_ctb_column, reason:%s\n", taos_errstr(pRes)); return -1; diff --git a/include/common/tmsg.h b/include/common/tmsg.h index 37faf90898..e870eefd77 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -2170,10 +2170,10 @@ typedef struct { int64_t newConsumerId; char subKey[TSDB_SUBSCRIBE_KEY_LEN]; int8_t subType; - int8_t withTbName; - int8_t withSchema; - int8_t withTag; - char* qmsg; + // int8_t withTbName; + // int8_t withSchema; + // int8_t withTag; + char* qmsg; } SMqRebVgReq; static FORCE_INLINE int32_t tEncodeSMqRebVgReq(void** buf, const SMqRebVgReq* pReq) { @@ -2184,10 +2184,10 @@ static FORCE_INLINE int32_t tEncodeSMqRebVgReq(void** buf, const SMqRebVgReq* pR tlen += taosEncodeFixedI64(buf, pReq->newConsumerId); tlen += taosEncodeString(buf, pReq->subKey); tlen += taosEncodeFixedI8(buf, pReq->subType); - tlen += taosEncodeFixedI8(buf, pReq->withTbName); - tlen += taosEncodeFixedI8(buf, pReq->withSchema); - tlen += taosEncodeFixedI8(buf, pReq->withTag); - if (pReq->subType == TOPIC_SUB_TYPE__TABLE) { + // tlen += taosEncodeFixedI8(buf, pReq->withTbName); + // tlen += taosEncodeFixedI8(buf, pReq->withSchema); + // tlen += taosEncodeFixedI8(buf, pReq->withTag); + if (pReq->subType == TOPIC_SUB_TYPE__COLUMN) { tlen += taosEncodeString(buf, pReq->qmsg); } return tlen; @@ -2200,10 +2200,10 @@ static FORCE_INLINE void* tDecodeSMqRebVgReq(const void* buf, SMqRebVgReq* pReq) buf = taosDecodeFixedI64(buf, &pReq->newConsumerId); buf = taosDecodeStringTo(buf, pReq->subKey); buf = taosDecodeFixedI8(buf, &pReq->subType); - buf = taosDecodeFixedI8(buf, &pReq->withTbName); - buf = taosDecodeFixedI8(buf, &pReq->withSchema); - buf = taosDecodeFixedI8(buf, &pReq->withTag); - if (pReq->subType == TOPIC_SUB_TYPE__TABLE) { + // buf = taosDecodeFixedI8(buf, &pReq->withTbName); + // buf = taosDecodeFixedI8(buf, &pReq->withSchema); + // buf = taosDecodeFixedI8(buf, &pReq->withTag); + if (pReq->subType == TOPIC_SUB_TYPE__COLUMN) { buf = taosDecodeString(buf, &pReq->qmsg); } return (void*)buf; diff --git a/source/dnode/mnode/impl/inc/mndDef.h b/source/dnode/mnode/impl/inc/mndDef.h index 2164c98c83..8a8d2d5dc4 100644 --- a/source/dnode/mnode/impl/inc/mndDef.h +++ b/source/dnode/mnode/impl/inc/mndDef.h @@ -454,17 +454,17 @@ int32_t tEncodeSMqOffsetObj(void** buf, const SMqOffsetObj* pOffset); void* tDecodeSMqOffsetObj(void* buf, SMqOffsetObj* pOffset); typedef struct { - char name[TSDB_TOPIC_FNAME_LEN]; - char db[TSDB_DB_FNAME_LEN]; - int64_t createTime; - int64_t updateTime; - int64_t uid; - int64_t dbUid; - int32_t version; - int8_t subType; // db or table - int8_t withTbName; - int8_t withSchema; - int8_t withTag; + char name[TSDB_TOPIC_FNAME_LEN]; + char db[TSDB_DB_FNAME_LEN]; + int64_t createTime; + int64_t updateTime; + int64_t uid; + int64_t dbUid; + int32_t version; + int8_t subType; // column, db or stable + // int8_t withTbName; + // int8_t withSchema; + // int8_t withTag; SRWLatch lock; int32_t consumerCnt; int32_t sqlLen; @@ -527,14 +527,14 @@ int32_t tEncodeSMqConsumerEp(void** buf, const SMqConsumerEp* pEp); void* tDecodeSMqConsumerEp(const void* buf, SMqConsumerEp* pEp); typedef struct { - char key[TSDB_SUBSCRIBE_KEY_LEN]; - SRWLatch lock; - int64_t dbUid; - int32_t vgNum; - int8_t subType; - int8_t withTbName; - int8_t withSchema; - int8_t withTag; + char key[TSDB_SUBSCRIBE_KEY_LEN]; + SRWLatch lock; + int64_t dbUid; + int32_t vgNum; + int8_t subType; + // int8_t withTbName; + // int8_t withSchema; + // int8_t withTag; SHashObj* consumerHash; // consumerId -> SMqConsumerEp SArray* unassignedVgs; // SArray } SMqSubscribeObj; diff --git a/source/dnode/mnode/impl/src/mndDef.c b/source/dnode/mnode/impl/src/mndDef.c index 35ba25acd5..b45b6f9ee9 100644 --- a/source/dnode/mnode/impl/src/mndDef.c +++ b/source/dnode/mnode/impl/src/mndDef.c @@ -396,9 +396,9 @@ SMqSubscribeObj *tCloneSubscribeObj(const SMqSubscribeObj *pSub) { pSubNew->dbUid = pSub->dbUid; pSubNew->subType = pSub->subType; - pSubNew->withTbName = pSub->withTbName; - pSubNew->withSchema = pSub->withSchema; - pSubNew->withTag = pSub->withTag; + /*pSubNew->withTbName = pSub->withTbName;*/ + /*pSubNew->withSchema = pSub->withSchema;*/ + /*pSubNew->withTag = pSub->withTag;*/ pSubNew->vgNum = pSub->vgNum; pSubNew->consumerHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK); @@ -431,9 +431,9 @@ int32_t tEncodeSubscribeObj(void **buf, const SMqSubscribeObj *pSub) { tlen += taosEncodeFixedI64(buf, pSub->dbUid); tlen += taosEncodeFixedI32(buf, pSub->vgNum); tlen += taosEncodeFixedI8(buf, pSub->subType); - tlen += taosEncodeFixedI8(buf, pSub->withTbName); - tlen += taosEncodeFixedI8(buf, pSub->withSchema); - tlen += taosEncodeFixedI8(buf, pSub->withTag); + /*tlen += taosEncodeFixedI8(buf, pSub->withTbName);*/ + /*tlen += taosEncodeFixedI8(buf, pSub->withSchema);*/ + /*tlen += taosEncodeFixedI8(buf, pSub->withTag);*/ void *pIter = NULL; int32_t sz = taosHashGetSize(pSub->consumerHash); @@ -458,9 +458,9 @@ void *tDecodeSubscribeObj(const void *buf, SMqSubscribeObj *pSub) { buf = taosDecodeFixedI64(buf, &pSub->dbUid); buf = taosDecodeFixedI32(buf, &pSub->vgNum); buf = taosDecodeFixedI8(buf, &pSub->subType); - buf = taosDecodeFixedI8(buf, &pSub->withTbName); - buf = taosDecodeFixedI8(buf, &pSub->withSchema); - buf = taosDecodeFixedI8(buf, &pSub->withTag); + /*buf = taosDecodeFixedI8(buf, &pSub->withTbName);*/ + /*buf = taosDecodeFixedI8(buf, &pSub->withSchema);*/ + /*buf = taosDecodeFixedI8(buf, &pSub->withTag);*/ int32_t sz; buf = taosDecodeFixedI32(buf, &sz); diff --git a/source/dnode/mnode/impl/src/mndScheduler.c b/source/dnode/mnode/impl/src/mndScheduler.c index d1404b96fe..a457183e0b 100644 --- a/source/dnode/mnode/impl/src/mndScheduler.c +++ b/source/dnode/mnode/impl/src/mndScheduler.c @@ -506,7 +506,7 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib SQueryPlan* pPlan = NULL; SSubplan* plan = NULL; - if (pTopic->subType == TOPIC_SUB_TYPE__TABLE) { + if (pTopic->subType == TOPIC_SUB_TYPE__COLUMN) { pPlan = qStringToQueryPlan(pTopic->physicalPlan); if (pPlan == NULL) { terrno = TSDB_CODE_QRY_INVALID_INPUT; @@ -552,7 +552,7 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib mDebug("init subscription %s, assign vg: %d", pSub->key, pVgEp->vgId); - if (pTopic->subType == TOPIC_SUB_TYPE__TABLE) { + if (pTopic->subType == TOPIC_SUB_TYPE__COLUMN) { int32_t msgLen; plan->execNode.epSet = pVgEp->epSet; diff --git a/source/dnode/mnode/impl/src/mndSubscribe.c b/source/dnode/mnode/impl/src/mndSubscribe.c index f360f34e14..05029f27c0 100644 --- a/source/dnode/mnode/impl/src/mndSubscribe.c +++ b/source/dnode/mnode/impl/src/mndSubscribe.c @@ -93,9 +93,9 @@ static SMqSubscribeObj *mndCreateSub(SMnode *pMnode, const SMqTopicObj *pTopic, } pSub->dbUid = pTopic->dbUid; pSub->subType = pTopic->subType; - pSub->withTbName = pTopic->withTbName; - pSub->withSchema = pTopic->withSchema; - pSub->withTag = pTopic->withTag; + /*pSub->withTbName = pTopic->withTbName;*/ + /*pSub->withSchema = pTopic->withSchema;*/ + /*pSub->withTag = pTopic->withTag;*/ ASSERT(pSub->unassignedVgs->size == 0); ASSERT(taosHashGetSize(pSub->consumerHash) == 0); @@ -120,9 +120,9 @@ static int32_t mndBuildSubChangeReq(void **pBuf, int32_t *pLen, const SMqSubscri req.vgId = pRebVg->pVgEp->vgId; req.qmsg = pRebVg->pVgEp->qmsg; req.subType = pSub->subType; - req.withTbName = pSub->withTbName; - req.withSchema = pSub->withSchema; - req.withTag = pSub->withTag; + /*req.withTbName = pSub->withTbName;*/ + /*req.withSchema = pSub->withSchema;*/ + /*req.withTag = pSub->withTag;*/ strncpy(req.subKey, pSub->key, TSDB_SUBSCRIBE_KEY_LEN); int32_t tlen = sizeof(SMsgHead) + tEncodeSMqRebVgReq(NULL, &req); diff --git a/source/dnode/mnode/impl/src/mndTopic.c b/source/dnode/mnode/impl/src/mndTopic.c index d271f91cd4..02f06a0de8 100644 --- a/source/dnode/mnode/impl/src/mndTopic.c +++ b/source/dnode/mnode/impl/src/mndTopic.c @@ -96,9 +96,9 @@ SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic) { SDB_SET_INT64(pRaw, dataPos, pTopic->dbUid, TOPIC_ENCODE_OVER); SDB_SET_INT32(pRaw, dataPos, pTopic->version, TOPIC_ENCODE_OVER); SDB_SET_INT8(pRaw, dataPos, pTopic->subType, TOPIC_ENCODE_OVER); - SDB_SET_INT8(pRaw, dataPos, pTopic->withTbName, TOPIC_ENCODE_OVER); - SDB_SET_INT8(pRaw, dataPos, pTopic->withSchema, TOPIC_ENCODE_OVER); - SDB_SET_INT8(pRaw, dataPos, pTopic->withTag, TOPIC_ENCODE_OVER); + /*SDB_SET_INT8(pRaw, dataPos, pTopic->withTbName, TOPIC_ENCODE_OVER);*/ + /*SDB_SET_INT8(pRaw, dataPos, pTopic->withSchema, TOPIC_ENCODE_OVER);*/ + /*SDB_SET_INT8(pRaw, dataPos, pTopic->withTag, TOPIC_ENCODE_OVER);*/ SDB_SET_INT32(pRaw, dataPos, pTopic->consumerCnt, TOPIC_ENCODE_OVER); SDB_SET_INT32(pRaw, dataPos, pTopic->sqlLen, TOPIC_ENCODE_OVER); @@ -168,9 +168,9 @@ SSdbRow *mndTopicActionDecode(SSdbRaw *pRaw) { SDB_GET_INT64(pRaw, dataPos, &pTopic->dbUid, TOPIC_DECODE_OVER); SDB_GET_INT32(pRaw, dataPos, &pTopic->version, TOPIC_DECODE_OVER); SDB_GET_INT8(pRaw, dataPos, &pTopic->subType, TOPIC_DECODE_OVER); - SDB_GET_INT8(pRaw, dataPos, &pTopic->withTbName, TOPIC_DECODE_OVER); - SDB_GET_INT8(pRaw, dataPos, &pTopic->withSchema, TOPIC_DECODE_OVER); - SDB_GET_INT8(pRaw, dataPos, &pTopic->withTag, TOPIC_DECODE_OVER); + /*SDB_GET_INT8(pRaw, dataPos, &pTopic->withTbName, TOPIC_DECODE_OVER);*/ + /*SDB_GET_INT8(pRaw, dataPos, &pTopic->withSchema, TOPIC_DECODE_OVER);*/ + /*SDB_GET_INT8(pRaw, dataPos, &pTopic->withTag, TOPIC_DECODE_OVER);*/ SDB_GET_INT32(pRaw, dataPos, &pTopic->consumerCnt, TOPIC_DECODE_OVER); @@ -308,11 +308,19 @@ static SDDropTopicReq *mndBuildDropTopicMsg(SMnode *pMnode, SVgObj *pVgroup, SMq } static int32_t mndCheckCreateTopicReq(SCMCreateTopicReq *pCreate) { - if (pCreate->name[0] == 0 || pCreate->sql == NULL || pCreate->sql[0] == 0 || pCreate->subDbName[0] == 0) { - terrno = TSDB_CODE_MND_INVALID_TOPIC; - return -1; + terrno = TSDB_CODE_MND_INVALID_TOPIC; + + if (pCreate->sql == NULL) return -1; + + if (pCreate->subType == TOPIC_SUB_TYPE__COLUMN) { + if (pCreate->ast == NULL || pCreate->ast[0] == 0) return -1; + } else if (pCreate->subType == TOPIC_SUB_TYPE__TABLE) { + if (pCreate->subStbName[0] == 0) return -1; + } else if (pCreate->subType == TOPIC_SUB_TYPE__DB) { + if (pCreate->subDbName[0] == 0) return -1; } + terrno = TSDB_CODE_SUCCESS; return 0; } @@ -328,12 +336,11 @@ static int32_t mndCreateTopic(SMnode *pMnode, SRpcMsg *pReq, SCMCreateTopicReq * topicObj.version = 1; topicObj.sql = strdup(pCreate->sql); topicObj.sqlLen = strlen(pCreate->sql) + 1; - /*topicObj.refConsumerCnt = 0;*/ + topicObj.subType = pCreate->subType; - if (pCreate->ast && pCreate->ast[0]) { + if (pCreate->subType == TOPIC_SUB_TYPE__COLUMN) { topicObj.ast = strdup(pCreate->ast); topicObj.astLen = strlen(pCreate->ast) + 1; - topicObj.subType = TOPIC_SUB_TYPE__TABLE; /*topicObj.withTbName = pCreate->withTbName;*/ /*topicObj.withSchema = pCreate->withSchema;*/ @@ -368,13 +375,12 @@ static int32_t mndCreateTopic(SMnode *pMnode, SRpcMsg *pReq, SCMCreateTopicReq * taosMemoryFree(topicObj.sql); return -1; } - } else { - topicObj.ast = NULL; - topicObj.astLen = 0; - topicObj.physicalPlan = NULL; - topicObj.subType = TOPIC_SUB_TYPE__DB; - topicObj.withTbName = 1; - topicObj.withSchema = 1; + /*} else if (pCreate->subType == TOPIC_SUB_TYPE__DB) {*/ + /*topicObj.ast = NULL;*/ + /*topicObj.astLen = 0;*/ + /*topicObj.physicalPlan = NULL;*/ + /*topicObj.withTbName = 1;*/ + /*topicObj.withSchema = 1;*/ } STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_CREATE_TOPIC, pReq); diff --git a/source/dnode/vnode/CMakeLists.txt b/source/dnode/vnode/CMakeLists.txt index d988f97188..17445b7abe 100644 --- a/source/dnode/vnode/CMakeLists.txt +++ b/source/dnode/vnode/CMakeLists.txt @@ -51,6 +51,7 @@ target_sources( # tq "src/tq/tq.c" + "src/tq/tqExec.c" "src/tq/tqCommit.c" "src/tq/tqOffset.c" "src/tq/tqPush.c" diff --git a/source/dnode/vnode/src/inc/tq.h b/source/dnode/vnode/src/inc/tq.h index 06ff6329e0..72138926aa 100644 --- a/source/dnode/vnode/src/inc/tq.h +++ b/source/dnode/vnode/src/inc/tq.h @@ -44,21 +44,27 @@ extern "C" { typedef struct STqOffsetCfg STqOffsetCfg; typedef struct STqOffsetStore STqOffsetStore; +// tqRead + struct STqReadHandle { int64_t ver; - SHashObj* tbIdHash; const SSubmitReq* pMsg; SSubmitBlk* pBlock; SSubmitMsgIter msgIter; SSubmitBlkIter blkIter; - SMeta* pVnodeMeta; - SArray* pColIdList; // SArray - int32_t sver; - int64_t cachedSchemaUid; - SSchemaWrapper* pSchemaWrapper; - STSchema* pSchema; + + SMeta* pVnodeMeta; + SHashObj* tbIdHash; + SArray* pColIdList; // SArray + + int32_t cachedSchemaVer; + int64_t cachedSchemaUid; + SSchemaWrapper* pSchemaWrapper; + STSchema* pSchema; }; +// tqPush + typedef struct { int64_t consumerId; int32_t epoch; @@ -68,14 +74,15 @@ typedef struct { SRpcMsg* handle; } STqPushHandle; +#if 0 typedef struct { - char subKey[TSDB_SUBSCRIBE_KEY_LEN]; - int64_t consumerId; - int32_t epoch; - int8_t subType; - int8_t withTbName; - int8_t withSchema; - int8_t withTag; + char subKey[TSDB_SUBSCRIBE_KEY_LEN]; + int64_t consumerId; + int32_t epoch; + int8_t subType; + // int8_t withTbName; + // int8_t withSchema; + // int8_t withTag; char* qmsg; SHashObj* pDropTbUid; STqPushHandle pushHandle; @@ -85,15 +92,55 @@ typedef struct { STqReadHandle* pExecReader[5]; qTaskInfo_t task[5]; } STqExec; +#endif -int32_t tEncodeSTqExec(SEncoder* pEncoder, const STqExec* pExec); -int32_t tDecodeSTqExec(SDecoder* pDecoder, STqExec* pExec); +// tqExec + +typedef struct { + char* qmsg; + qTaskInfo_t task[5]; +} STqExecCol; + +typedef struct { + int64_t suid; +} STqExecTb; + +typedef struct { + SHashObj* pFilterOutTbUid; +} STqExecDb; + +typedef struct { + int8_t subType; + + STqReadHandle* pExecReader[5]; + union { + STqExecCol execCol; + STqExecTb execTb; + STqExecDb execDb; + } exec; +} STqExecHandle; + +typedef struct { + // info + char subKey[TSDB_SUBSCRIBE_KEY_LEN]; + int64_t consumerId; + int32_t epoch; + + // reader + SWalReadHandle* pWalReader; + + // push + STqPushHandle pushHandle; + + // exec + STqExecHandle execHandle; +} STqHandle; struct STQ { char* path; - SHashObj* pushMgr; // consumerId -> STqExec* - SHashObj* execs; // subKey -> STqExec - SHashObj* pStreamTasks; + SHashObj* pushMgr; // consumerId -> STqHandle* + SHashObj* handles; // subKey -> STqHandle + SHashObj* pStreamTasks; // taksId -> SStreamTask SVnode* pVnode; SWal* pWal; TDB* pMetaStore; @@ -111,6 +158,16 @@ static STqMgmt tqMgmt = {0}; int tqInit(); void tqCleanUp(); +// int32_t tEncodeSTqExec(SEncoder* pEncoder, const STqExec* pExec); +// int32_t tDecodeSTqExec(SDecoder* pDecoder, STqExec* pExec); + +int32_t tEncodeSTqHandle(SEncoder* pEncoder, const STqHandle* pHandle); +int32_t tDecodeSTqHandle(SDecoder* pDecoder, STqHandle* pHandle); + +int64_t tqFetchLog(STQ* pTq, STqHandle* pHandle, int64_t* fetchOffset, SWalHead** pHeadWithCkSum); + +int32_t tqDataExec(STQ* pTq, STqExecHandle* pExec, SSubmitReq* pReq, SMqDataBlkRsp* pRsp, int32_t workerId); + // tqOffset STqOffsetStore* STqOffsetOpen(STqOffsetCfg*); void STqOffsetClose(STqOffsetStore*); diff --git a/source/dnode/vnode/src/tq/tq.c b/source/dnode/vnode/src/tq/tq.c index e3cdbaa44b..16201994f0 100644 --- a/source/dnode/vnode/src/tq/tq.c +++ b/source/dnode/vnode/src/tq/tq.c @@ -51,10 +51,10 @@ int tqExecKeyCompare(const void* pKey1, int32_t kLen1, const void* pKey2, int32_ return strcmp(pKey1, pKey2); } -int32_t tqStoreExec(STQ* pTq, const char* key, const STqExec* pExec) { +int32_t tqStoreHandle(STQ* pTq, const char* key, const STqHandle* pHandle) { int32_t code; int32_t vlen; - tEncodeSize(tEncodeSTqExec, pExec, vlen, code); + tEncodeSize(tEncodeSTqHandle, pHandle, vlen, code); ASSERT(code == 0); void* buf = taosMemoryCalloc(1, vlen); @@ -65,7 +65,7 @@ int32_t tqStoreExec(STQ* pTq, const char* key, const STqExec* pExec) { SEncoder encoder; tEncoderInit(&encoder, buf, vlen); - if (tEncodeSTqExec(&encoder, pExec) < 0) { + if (tEncodeSTqHandle(&encoder, pHandle) < 0) { ASSERT(0); } @@ -102,7 +102,7 @@ STQ* tqOpen(const char* path, SVnode* pVnode, SWal* pWal) { pTq->pVnode = pVnode; pTq->pWal = pWal; - pTq->execs = taosHashInit(64, MurmurHash3_32, true, HASH_ENTRY_LOCK); + pTq->handles = taosHashInit(64, MurmurHash3_32, true, HASH_ENTRY_LOCK); pTq->pStreamTasks = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_NO_LOCK); @@ -112,7 +112,7 @@ STQ* tqOpen(const char* path, SVnode* pVnode, SWal* pWal) { ASSERT(0); } - if (tdbTbOpen("exec", -1, -1, tqExecKeyCompare, pTq->pMetaStore, &pTq->pExecStore) < 0) { + if (tdbTbOpen("handles", -1, -1, tqExecKeyCompare, pTq->pMetaStore, &pTq->pExecStore) < 0) { ASSERT(0); } @@ -134,30 +134,31 @@ STQ* tqOpen(const char* path, SVnode* pVnode, SWal* pWal) { tdbTbcMoveToFirst(pCur); SDecoder decoder; - while (tdbTbcNext(pCur, &pKey, &kLen, &pVal, &vLen) == 0) { - STqExec exec; - tDecoderInit(&decoder, (uint8_t*)pVal, vLen); - tDecodeSTqExec(&decoder, &exec); - exec.pWalReader = walOpenReadHandle(pTq->pVnode->pWal); - if (exec.subType == TOPIC_SUB_TYPE__TABLE) { - for (int32_t i = 0; i < 5; i++) { - exec.pExecReader[i] = tqInitSubmitMsgScanner(pTq->pVnode->pMeta); - SReadHandle handle = { - .reader = exec.pExecReader[i], + while (tdbTbcNext(pCur, &pKey, &kLen, &pVal, &vLen) == 0) { + STqHandle handle; + tDecoderInit(&decoder, (uint8_t*)pVal, vLen); + tDecodeSTqHandle(&decoder, &handle); + handle.pWalReader = walOpenReadHandle(pTq->pVnode->pWal); + for (int32_t i = 0; i < 5; i++) { + handle.execHandle.pExecReader[i] = tqInitSubmitMsgScanner(pTq->pVnode->pMeta); + } + if (handle.execHandle.subType == TOPIC_SUB_TYPE__COLUMN) { + for (int32_t i = 0; i < 5; i++) { + SReadHandle reader = { + .reader = handle.execHandle.pExecReader[i], .meta = pTq->pVnode->pMeta, .pMsgCb = &pTq->pVnode->msgCb, }; - exec.task[i] = qCreateStreamExecTaskInfo(exec.qmsg, &handle); - ASSERT(exec.task[i]); + handle.execHandle.exec.execCol.task[i] = + qCreateStreamExecTaskInfo(handle.execHandle.exec.execCol.qmsg, &reader); + ASSERT(handle.execHandle.exec.execCol.task[i]); } } else { - for (int32_t i = 0; i < 5; i++) { - exec.pExecReader[i] = tqInitSubmitMsgScanner(pTq->pVnode->pMeta); - } - exec.pDropTbUid = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK); + handle.execHandle.exec.execDb.pFilterOutTbUid = + taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK); } - taosHashPut(pTq->execs, pKey, kLen, &exec, sizeof(STqExec)); + taosHashPut(pTq->handles, pKey, kLen, &handle, sizeof(STqHandle)); } if (tdbTxnClose(&txn) < 0) { @@ -170,7 +171,7 @@ STQ* tqOpen(const char* path, SVnode* pVnode, SWal* pWal) { void tqClose(STQ* pTq) { if (pTq) { taosMemoryFreeClear(pTq->path); - taosHashCleanup(pTq->execs); + taosHashCleanup(pTq->handles); taosHashCleanup(pTq->pStreamTasks); taosHashCleanup(pTq->pushMgr); tdbClose(pTq->pMetaStore); @@ -179,16 +180,17 @@ void tqClose(STQ* pTq) { // TODO } +#if 0 int32_t tEncodeSTqExec(SEncoder* pEncoder, const STqExec* pExec) { if (tStartEncode(pEncoder) < 0) return -1; if (tEncodeCStr(pEncoder, pExec->subKey) < 0) return -1; if (tEncodeI64(pEncoder, pExec->consumerId) < 0) return -1; if (tEncodeI32(pEncoder, pExec->epoch) < 0) return -1; if (tEncodeI8(pEncoder, pExec->subType) < 0) return -1; - if (tEncodeI8(pEncoder, pExec->withTbName) < 0) return -1; - if (tEncodeI8(pEncoder, pExec->withSchema) < 0) return -1; - if (tEncodeI8(pEncoder, pExec->withTag) < 0) return -1; - if (pExec->subType == TOPIC_SUB_TYPE__TABLE) { + /*if (tEncodeI8(pEncoder, pExec->withTbName) < 0) return -1;*/ + /*if (tEncodeI8(pEncoder, pExec->withSchema) < 0) return -1;*/ + /*if (tEncodeI8(pEncoder, pExec->withTag) < 0) return -1;*/ + if (pExec->subType == TOPIC_SUB_TYPE__COLUMN) { if (tEncodeCStr(pEncoder, pExec->qmsg) < 0) return -1; } tEndEncode(pEncoder); @@ -201,34 +203,64 @@ int32_t tDecodeSTqExec(SDecoder* pDecoder, STqExec* pExec) { if (tDecodeI64(pDecoder, &pExec->consumerId) < 0) return -1; if (tDecodeI32(pDecoder, &pExec->epoch) < 0) return -1; if (tDecodeI8(pDecoder, &pExec->subType) < 0) return -1; - if (tDecodeI8(pDecoder, &pExec->withTbName) < 0) return -1; - if (tDecodeI8(pDecoder, &pExec->withSchema) < 0) return -1; - if (tDecodeI8(pDecoder, &pExec->withTag) < 0) return -1; - if (pExec->subType == TOPIC_SUB_TYPE__TABLE) { + /*if (tDecodeI8(pDecoder, &pExec->withTbName) < 0) return -1;*/ + /*if (tDecodeI8(pDecoder, &pExec->withSchema) < 0) return -1;*/ + /*if (tDecodeI8(pDecoder, &pExec->withTag) < 0) return -1;*/ + if (pExec->subType == TOPIC_SUB_TYPE__COLUMN) { if (tDecodeCStrAlloc(pDecoder, &pExec->qmsg) < 0) return -1; } tEndDecode(pDecoder); return 0; } +#endif + +int32_t tEncodeSTqHandle(SEncoder* pEncoder, const STqHandle* pHandle) { + if (tStartEncode(pEncoder) < 0) return -1; + if (tEncodeCStr(pEncoder, pHandle->subKey) < 0) return -1; + if (tEncodeI64(pEncoder, pHandle->consumerId) < 0) return -1; + if (tEncodeI32(pEncoder, pHandle->epoch) < 0) return -1; + if (tEncodeI8(pEncoder, pHandle->execHandle.subType) < 0) return -1; + if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) { + if (tEncodeCStr(pEncoder, pHandle->execHandle.exec.execCol.qmsg) < 0) return -1; + } + tEndEncode(pEncoder); + return pEncoder->pos; +} + +int32_t tDecodeSTqHandle(SDecoder* pDecoder, STqHandle* pHandle) { + if (tStartDecode(pDecoder) < 0) return -1; + if (tDecodeCStrTo(pDecoder, pHandle->subKey) < 0) return -1; + if (tDecodeI64(pDecoder, &pHandle->consumerId) < 0) return -1; + if (tDecodeI32(pDecoder, &pHandle->epoch) < 0) return -1; + if (tDecodeI8(pDecoder, &pHandle->execHandle.subType) < 0) return -1; + if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) { + if (tDecodeCStrAlloc(pDecoder, &pHandle->execHandle.exec.execCol.qmsg) < 0) return -1; + } + tEndDecode(pDecoder); + return 0; +} + int32_t tqUpdateTbUidList(STQ* pTq, const SArray* tbUidList, bool isAdd) { void* pIter = NULL; while (1) { - pIter = taosHashIterate(pTq->execs, pIter); + pIter = taosHashIterate(pTq->handles, pIter); if (pIter == NULL) break; - STqExec* pExec = (STqExec*)pIter; - if (pExec->subType == TOPIC_SUB_TYPE__DB) { + STqHandle* pExec = (STqHandle*)pIter; + if (pExec->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) { + for (int32_t i = 0; i < 5; i++) { + int32_t code = qUpdateQualifiedTableId(pExec->execHandle.exec.execCol.task[i], tbUidList, isAdd); + ASSERT(code == 0); + } + } else if (pExec->execHandle.subType == TOPIC_SUB_TYPE__DB) { if (!isAdd) { int32_t sz = taosArrayGetSize(tbUidList); for (int32_t i = 0; i < sz; i++) { int64_t tbUid = *(int64_t*)taosArrayGet(tbUidList, i); - taosHashPut(pExec->pDropTbUid, &tbUid, sizeof(int64_t), NULL, 0); + taosHashPut(pExec->execHandle.exec.execDb.pFilterOutTbUid, &tbUid, sizeof(int64_t), NULL, 0); } } } else { - for (int32_t i = 0; i < 5; i++) { - int32_t code = qUpdateQualifiedTableId(pExec->task[i], tbUidList, isAdd); - ASSERT(code == 0); - } + // tq update id } } while (1) { @@ -246,7 +278,7 @@ int32_t tqUpdateTbUidList(STQ* pTq, const SArray* tbUidList, bool isAdd) { int32_t tqPushMsgNew(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_t ver, SRpcHandleInfo handleInfo) { if (msgType != TDMT_VND_SUBMIT) return 0; void* pIter = NULL; - STqExec* pExec = NULL; + STqHandle* pHandle = NULL; SSubmitReq* pReq = (SSubmitReq*)msg; int32_t workerId = 4; int64_t fetchOffset = ver; @@ -254,84 +286,27 @@ int32_t tqPushMsgNew(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_ while (1) { pIter = taosHashIterate(pTq->pushMgr, pIter); if (pIter == NULL) break; - pExec = *(STqExec**)pIter; + pHandle = *(STqHandle**)pIter; - taosWLockLatch(&pExec->pushHandle.lock); + taosWLockLatch(&pHandle->pushHandle.lock); - SRpcMsg* pMsg = atomic_load_ptr(&pExec->pushHandle.handle); + SRpcMsg* pMsg = atomic_load_ptr(&pHandle->pushHandle.handle); ASSERT(pMsg); SMqDataBlkRsp rsp = {0}; - rsp.reqOffset = pExec->pushHandle.reqOffset; + rsp.reqOffset = pHandle->pushHandle.reqOffset; rsp.blockData = taosArrayInit(0, sizeof(void*)); rsp.blockDataLen = taosArrayInit(0, sizeof(int32_t)); - if (pExec->subType == TOPIC_SUB_TYPE__TABLE) { - qTaskInfo_t task = pExec->task[workerId]; - ASSERT(task); - qSetStreamInput(task, pReq, STREAM_DATA_TYPE_SUBMIT_BLOCK, false); - while (1) { - SSDataBlock* pDataBlock = NULL; - uint64_t ts = 0; - if (qExecTask(task, &pDataBlock, &ts) < 0) { - ASSERT(0); - } - if (pDataBlock == NULL) break; - - ASSERT(pDataBlock->info.rows != 0); - ASSERT(pDataBlock->info.numOfCols != 0); - - int32_t dataStrLen = sizeof(SRetrieveTableRsp) + blockGetEncodeSize(pDataBlock); - void* buf = taosMemoryCalloc(1, dataStrLen); - SRetrieveTableRsp* pRetrieve = (SRetrieveTableRsp*)buf; - pRetrieve->useconds = ts; - pRetrieve->precision = TSDB_DEFAULT_PRECISION; - pRetrieve->compressed = 0; - pRetrieve->completed = 1; - pRetrieve->numOfRows = htonl(pDataBlock->info.rows); - - // TODO enable compress - int32_t actualLen = 0; - blockCompressEncode(pDataBlock, pRetrieve->data, &actualLen, pDataBlock->info.numOfCols, false); - actualLen += sizeof(SRetrieveTableRsp); - ASSERT(actualLen <= dataStrLen); - taosArrayPush(rsp.blockDataLen, &actualLen); - taosArrayPush(rsp.blockData, &buf); - rsp.blockNum++; - } - } else if (pExec->subType == TOPIC_SUB_TYPE__DB) { - STqReadHandle* pReader = pExec->pExecReader[workerId]; - tqReadHandleSetMsg(pReader, pReq, 0); - while (tqNextDataBlock(pReader)) { - SSDataBlock block = {0}; - if (tqRetrieveDataBlock(&block.pDataBlock, pReader, &block.info.groupId, &block.info.uid, &block.info.rows, - &block.info.numOfCols) < 0) { - ASSERT(0); - } - int32_t dataStrLen = sizeof(SRetrieveTableRsp) + blockGetEncodeSize(&block); - void* buf = taosMemoryCalloc(1, dataStrLen); - SRetrieveTableRsp* pRetrieve = (SRetrieveTableRsp*)buf; - /*pRetrieve->useconds = 0;*/ - pRetrieve->precision = TSDB_DEFAULT_PRECISION; - pRetrieve->compressed = 0; - pRetrieve->completed = 1; - pRetrieve->numOfRows = htonl(block.info.rows); - - // TODO enable compress - int32_t actualLen = 0; - blockCompressEncode(&block, pRetrieve->data, &actualLen, block.info.numOfCols, false); - actualLen += sizeof(SRetrieveTableRsp); - ASSERT(actualLen <= dataStrLen); - taosArrayPush(rsp.blockDataLen, &actualLen); - taosArrayPush(rsp.blockData, &buf); - rsp.blockNum++; - } + if (msgType == TDMT_VND_SUBMIT) { + tqDataExec(pTq, &pHandle->execHandle, pReq, &rsp, workerId); } else { + // TODO ASSERT(0); } if (rsp.blockNum == 0) { - taosWUnLockLatch(&pExec->pushHandle.lock); + taosWUnLockLatch(&pHandle->pushHandle.lock); continue; } @@ -348,8 +323,8 @@ int32_t tqPushMsgNew(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_ } ((SMqRspHead*)buf)->mqMsgType = TMQ_MSG_TYPE__POLL_RSP; - ((SMqRspHead*)buf)->epoch = pExec->pushHandle.epoch; - ((SMqRspHead*)buf)->consumerId = pExec->pushHandle.consumerId; + ((SMqRspHead*)buf)->epoch = pHandle->pushHandle.epoch; + ((SMqRspHead*)buf)->consumerId = pHandle->pushHandle.consumerId; void* abuf = POINTER_SHIFT(buf, sizeof(SMqRspHead)); tEncodeSMqDataBlkRsp(&abuf, &rsp); @@ -357,11 +332,11 @@ int32_t tqPushMsgNew(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_ SRpcMsg resp = {.info = handleInfo, .pCont = buf, .contLen = tlen, .code = 0}; tmsgSendRsp(&resp); - atomic_store_ptr(&pExec->pushHandle.handle, NULL); - taosWUnLockLatch(&pExec->pushHandle.lock); + atomic_store_ptr(&pHandle->pushHandle.handle, NULL); + taosWUnLockLatch(&pHandle->pushHandle.lock); tqDebug("vg %d offset %ld from consumer %ld (epoch %d) send rsp, block num: %d, reqOffset: %ld, rspOffset: %ld", - TD_VID(pTq->pVnode), fetchOffset, pExec->pushHandle.consumerId, pExec->pushHandle.epoch, rsp.blockNum, + TD_VID(pTq->pVnode), fetchOffset, pHandle->pushHandle.consumerId, pHandle->pushHandle.epoch, rsp.blockNum, rsp.reqOffset, rsp.rspOffset); // TODO destroy @@ -415,12 +390,12 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) { tqDebug("tmq poll: consumer %ld (epoch %d) recv poll req in vg %d, req %ld %ld", consumerId, pReq->epoch, TD_VID(pTq->pVnode), pReq->currentOffset, fetchOffset); - STqExec* pExec = taosHashGet(pTq->execs, pReq->subKey, strlen(pReq->subKey)); - ASSERT(pExec); + STqHandle* pHandle = taosHashGet(pTq->handles, pReq->subKey, strlen(pReq->subKey)); + ASSERT(pHandle); - int32_t consumerEpoch = atomic_load_32(&pExec->epoch); + int32_t consumerEpoch = atomic_load_32(&pHandle->epoch); while (consumerEpoch < reqEpoch) { - consumerEpoch = atomic_val_compare_exchange_32(&pExec->epoch, consumerEpoch, reqEpoch); + consumerEpoch = atomic_val_compare_exchange_32(&pHandle->epoch, consumerEpoch, reqEpoch); } SWalHead* pHeadWithCkSum = taosMemoryMalloc(sizeof(SWalHead) + 2048); @@ -428,49 +403,51 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) { return -1; } - walSetReaderCapacity(pExec->pWalReader, 2048); + walSetReaderCapacity(pHandle->pWalReader, 2048); SMqDataBlkRsp rsp = {0}; rsp.reqOffset = pReq->currentOffset; - rsp.withSchema = pExec->withSchema; rsp.blockData = taosArrayInit(0, sizeof(void*)); rsp.blockDataLen = taosArrayInit(0, sizeof(int32_t)); rsp.blockSchema = taosArrayInit(0, sizeof(void*)); rsp.blockTbName = taosArrayInit(0, sizeof(void*)); - int8_t withTbName = pExec->withTbName; - if (pReq->withTbName != -1) { - withTbName = pReq->withTbName; + rsp.withTbName = pReq->withTbName; + if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) { + rsp.withSchema = false; + rsp.withTag = false; + } else { + rsp.withSchema = true; + rsp.withTag = false; } - rsp.withTbName = withTbName; + + /*int8_t withTbName = pExec->withTbName;*/ + /*if (pReq->withTbName != -1) {*/ + /*withTbName = pReq->withTbName;*/ + /*}*/ + /*rsp.withTbName = withTbName;*/ while (1) { - consumerEpoch = atomic_load_32(&pExec->epoch); + consumerEpoch = atomic_load_32(&pHandle->epoch); if (consumerEpoch > reqEpoch) { tqDebug("tmq poll: consumer %ld (epoch %d) vg %d offset %ld, found new consumer epoch %d discard req epoch %d", consumerId, pReq->epoch, TD_VID(pTq->pVnode), fetchOffset, consumerEpoch, reqEpoch); break; } - taosThreadMutexLock(&pExec->pWalReader->mutex); - - if (walFetchHead(pExec->pWalReader, fetchOffset, pHeadWithCkSum) < 0) { - tqDebug("tmq poll: consumer %ld (epoch %d) vg %d offset %ld, no more log to return", consumerId, pReq->epoch, - TD_VID(pTq->pVnode), fetchOffset); - taosThreadMutexUnlock(&pExec->pWalReader->mutex); + if (tqFetchLog(pTq, pHandle, &fetchOffset, &pHeadWithCkSum) < 0) { + // TODO add push mgr break; } - if (pHeadWithCkSum->head.msgType != TDMT_VND_SUBMIT) { - ASSERT(walSkipFetchBody(pExec->pWalReader, pHeadWithCkSum) == 0); - } else { - ASSERT(walFetchBody(pExec->pWalReader, &pHeadWithCkSum) == 0); - } + tqDebug("tmq poll vg %d: offset %ld msgType %d", pTq->pVnode->config.vgId, fetchOffset, + pHeadWithCkSum->head.msgType); SWalReadHead* pHead = &pHeadWithCkSum->head; - taosThreadMutexUnlock(&pExec->pWalReader->mutex); + tqDebug("tmq poll vg %d: offset %ld msgType %d", pTq->pVnode->config.vgId, fetchOffset, + pHeadWithCkSum->head.msgType); #if 0 SWalReadHead* pHead; @@ -511,122 +488,26 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) { if (pHead->msgType == TDMT_VND_SUBMIT) { SSubmitReq* pCont = (SSubmitReq*)&pHead->body; - // table subscribe - if (pExec->subType == TOPIC_SUB_TYPE__TABLE) { - qTaskInfo_t task = pExec->task[workerId]; - ASSERT(task); - qSetStreamInput(task, pCont, STREAM_DATA_TYPE_SUBMIT_BLOCK, false); - while (1) { - SSDataBlock* pDataBlock = NULL; - uint64_t ts = 0; - if (qExecTask(task, &pDataBlock, &ts) < 0) { - ASSERT(0); - } - if (pDataBlock == NULL) break; - ASSERT(pDataBlock->info.rows != 0); - ASSERT(pDataBlock->info.numOfCols != 0); - - int32_t dataStrLen = sizeof(SRetrieveTableRsp) + blockGetEncodeSize(pDataBlock); - void* buf = taosMemoryCalloc(1, dataStrLen); - SRetrieveTableRsp* pRetrieve = (SRetrieveTableRsp*)buf; - pRetrieve->useconds = ts; - pRetrieve->precision = TSDB_DEFAULT_PRECISION; - pRetrieve->compressed = 0; - pRetrieve->completed = 1; - pRetrieve->numOfRows = htonl(pDataBlock->info.rows); - - // TODO enable compress - int32_t actualLen = 0; - blockCompressEncode(pDataBlock, pRetrieve->data, &actualLen, pDataBlock->info.numOfCols, false); - actualLen += sizeof(SRetrieveTableRsp); - ASSERT(actualLen <= dataStrLen); - taosArrayPush(rsp.blockDataLen, &actualLen); - taosArrayPush(rsp.blockData, &buf); - - if (pExec->withSchema) { - SSchemaWrapper* pSW = tCloneSSchemaWrapper(pExec->pExecReader[workerId]->pSchemaWrapper); - taosArrayPush(rsp.blockSchema, &pSW); - } - - if (withTbName) { - SMetaReader mr = {0}; - metaReaderInit(&mr, pTq->pVnode->pMeta, 0); - int64_t uid = pExec->pExecReader[workerId]->msgIter.uid; - if (metaGetTableEntryByUid(&mr, uid) < 0) { - ASSERT(0); - } - char* tbName = strdup(mr.me.name); - taosArrayPush(rsp.blockTbName, &tbName); - metaReaderClear(&mr); - } - - rsp.blockNum++; - } - // db subscribe - } else if (pExec->subType == TOPIC_SUB_TYPE__DB) { - rsp.withSchema = 1; - STqReadHandle* pReader = pExec->pExecReader[workerId]; - tqReadHandleSetMsg(pReader, pCont, 0); - while (tqNextDataBlockFilterOut(pReader, pExec->pDropTbUid)) { - SSDataBlock block = {0}; - if (tqRetrieveDataBlock(&block.pDataBlock, pReader, &block.info.groupId, &block.info.uid, &block.info.rows, - &block.info.numOfCols) < 0) { - if (terrno == TSDB_CODE_TQ_TABLE_SCHEMA_NOT_FOUND) continue; - ASSERT(0); - } - int32_t dataStrLen = sizeof(SRetrieveTableRsp) + blockGetEncodeSize(&block); - void* buf = taosMemoryCalloc(1, dataStrLen); - SRetrieveTableRsp* pRetrieve = (SRetrieveTableRsp*)buf; - /*pRetrieve->useconds = 0;*/ - pRetrieve->precision = TSDB_DEFAULT_PRECISION; - pRetrieve->compressed = 0; - pRetrieve->completed = 1; - pRetrieve->numOfRows = htonl(block.info.rows); - - // TODO enable compress - int32_t actualLen = 0; - blockCompressEncode(&block, pRetrieve->data, &actualLen, block.info.numOfCols, false); - actualLen += sizeof(SRetrieveTableRsp); - ASSERT(actualLen <= dataStrLen); - taosArrayPush(rsp.blockDataLen, &actualLen); - taosArrayPush(rsp.blockData, &buf); - if (withTbName) { - SMetaReader mr = {0}; - metaReaderInit(&mr, pTq->pVnode->pMeta, 0); - if (metaGetTableEntryByUid(&mr, block.info.uid) < 0) { - ASSERT(0); - } - char* tbName = strdup(mr.me.name); - taosArrayPush(rsp.blockTbName, &tbName); - metaReaderClear(&mr); - } - - SSchemaWrapper* pSW = tCloneSSchemaWrapper(pExec->pExecReader[workerId]->pSchemaWrapper); - taosArrayPush(rsp.blockSchema, &pSW); - - rsp.blockNum++; - } - } else { - ASSERT(0); - } + tqDataExec(pTq, &pHandle->execHandle, pCont, &rsp, workerId); + } else { + // TODO + ASSERT(0); } // TODO batch optimization: // TODO continue scan until meeting batch requirement - if (rsp.blockNum != 0) break; - rsp.skipLogNum++; - fetchOffset++; + if (rsp.blockNum > 0 /* threshold */) { + break; + } } taosMemoryFree(pHeadWithCkSum); + ASSERT(taosArrayGetSize(rsp.blockData) == rsp.blockNum); ASSERT(taosArrayGetSize(rsp.blockDataLen) == rsp.blockNum); - if (rsp.blockNum != 0) - rsp.rspOffset = fetchOffset; - else - rsp.rspOffset = fetchOffset - 1; + rsp.rspOffset = fetchOffset; int32_t tlen = sizeof(SMqRspHead) + tEncodeSMqDataBlkRsp(NULL, &rsp); void* buf = rpcMallocCont(tlen); @@ -642,13 +523,18 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) { void* abuf = POINTER_SHIFT(buf, sizeof(SMqRspHead)); tEncodeSMqDataBlkRsp(&abuf, &rsp); - SRpcMsg resp = {.info = pMsg->info, .pCont = buf, .contLen = tlen, .code = 0}; + SRpcMsg resp = { + .info = pMsg->info, + .pCont = buf, + .contLen = tlen, + .code = 0, + }; tmsgSendRsp(&resp); tqDebug("vg %d offset %ld from consumer %ld (epoch %d) send rsp, block num: %d, reqOffset: %ld, rspOffset: %ld", TD_VID(pTq->pVnode), fetchOffset, consumerId, pReq->epoch, rsp.blockNum, rsp.reqOffset, rsp.rspOffset); - // TODO destroy + // TODO wrap in destroy func taosArrayDestroy(rsp.blockData); taosArrayDestroy(rsp.blockDataLen); taosArrayDestroyP(rsp.blockSchema, (FDelete)tDeleteSSchemaWrapper); @@ -660,7 +546,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) { int32_t tqProcessVgDeleteReq(STQ* pTq, char* msg, int32_t msgLen) { SMqVDeleteReq* pReq = (SMqVDeleteReq*)msg; - int32_t code = taosHashRemove(pTq->execs, pReq->subKey, strlen(pReq->subKey)); + int32_t code = taosHashRemove(pTq->handles, pReq->subKey, strlen(pReq->subKey)); ASSERT(code == 0); TXN txn; @@ -689,63 +575,59 @@ int32_t tqProcessVgChangeReq(STQ* pTq, char* msg, int32_t msgLen) { SMqRebVgReq req = {0}; tDecodeSMqRebVgReq(msg, &req); // todo lock - STqExec* pExec = taosHashGet(pTq->execs, req.subKey, strlen(req.subKey)); - if (pExec == NULL) { + STqHandle* pHandle = taosHashGet(pTq->handles, req.subKey, strlen(req.subKey)); + if (pHandle == NULL) { ASSERT(req.oldConsumerId == -1); ASSERT(req.newConsumerId != -1); - STqExec exec = {0}; - pExec = &exec; + STqHandle tqHandle = {0}; + pHandle = &tqHandle; /*taosInitRWLatch(&pExec->lock);*/ - memcpy(pExec->subKey, req.subKey, TSDB_SUBSCRIBE_KEY_LEN); - pExec->consumerId = req.newConsumerId; - pExec->epoch = -1; + memcpy(pHandle->subKey, req.subKey, TSDB_SUBSCRIBE_KEY_LEN); + pHandle->consumerId = req.newConsumerId; + pHandle->epoch = -1; - pExec->subType = req.subType; - pExec->withTbName = req.withTbName; - pExec->withSchema = req.withSchema; - pExec->withTag = req.withTag; + pHandle->execHandle.subType = req.subType; + /*pExec->withTbName = req.withTbName;*/ + /*pExec->withSchema = req.withSchema;*/ + /*pExec->withTag = req.withTag;*/ - pExec->qmsg = req.qmsg; + pHandle->execHandle.exec.execCol.qmsg = req.qmsg; req.qmsg = NULL; - pExec->pWalReader = walOpenReadHandle(pTq->pVnode->pWal); - if (pExec->subType == TOPIC_SUB_TYPE__TABLE) { + pHandle->pWalReader = walOpenReadHandle(pTq->pVnode->pWal); + for (int32_t i = 0; i < 5; i++) { + pHandle->execHandle.pExecReader[i] = tqInitSubmitMsgScanner(pTq->pVnode->pMeta); + } + if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) { for (int32_t i = 0; i < 5; i++) { - pExec->pExecReader[i] = tqInitSubmitMsgScanner(pTq->pVnode->pMeta); - SReadHandle handle = { - .reader = pExec->pExecReader[i], + .reader = pHandle->execHandle.pExecReader[i], .meta = pTq->pVnode->pMeta, .pMsgCb = &pTq->pVnode->msgCb, }; - pExec->task[i] = qCreateStreamExecTaskInfo(pExec->qmsg, &handle); - ASSERT(pExec->task[i]); + pHandle->execHandle.exec.execCol.task[i] = + qCreateStreamExecTaskInfo(pHandle->execHandle.exec.execCol.qmsg, &handle); + ASSERT(pHandle->execHandle.exec.execCol.task[i]); } - } else { - for (int32_t i = 0; i < 5; i++) { - pExec->pExecReader[i] = tqInitSubmitMsgScanner(pTq->pVnode->pMeta); - } - pExec->pDropTbUid = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK); + } else if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__DB) { + pHandle->execHandle.exec.execDb.pFilterOutTbUid = + taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK); + } else if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__TABLE) { } - taosHashPut(pTq->execs, req.subKey, strlen(req.subKey), pExec, sizeof(STqExec)); - - if (tqStoreExec(pTq, req.subKey, pExec) < 0) { - // TODO - } - return 0; + taosHashPut(pTq->handles, req.subKey, strlen(req.subKey), pHandle, sizeof(STqHandle)); } else { /*ASSERT(pExec->consumerId == req.oldConsumerId);*/ // TODO handle qmsg and exec modification - atomic_store_32(&pExec->epoch, -1); - atomic_store_64(&pExec->consumerId, req.newConsumerId); - atomic_add_fetch_32(&pExec->epoch, 1); - - if (tqStoreExec(pTq, req.subKey, pExec) < 0) { - // TODO - } - return 0; + atomic_store_32(&pHandle->epoch, -1); + atomic_store_64(&pHandle->consumerId, req.newConsumerId); + atomic_add_fetch_32(&pHandle->epoch, 1); } + + if (tqStoreHandle(pTq, req.subKey, pHandle) < 0) { + // TODO + } + return 0; } void tqTableSink(SStreamTask* pTask, void* vnode, int64_t ver, void* data) { diff --git a/source/dnode/vnode/src/tq/tqExec.c b/source/dnode/vnode/src/tq/tqExec.c new file mode 100644 index 0000000000..b8fec34b57 --- /dev/null +++ b/source/dnode/vnode/src/tq/tqExec.c @@ -0,0 +1,124 @@ +/* + * 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 "tq.h" + +static int32_t tqAddBlockDataToRsp(const SSDataBlock* pBlock, SMqDataBlkRsp* pRsp) { + int32_t dataStrLen = sizeof(SRetrieveTableRsp) + blockGetEncodeSize(pBlock); + void* buf = taosMemoryCalloc(1, dataStrLen); + if (buf == NULL) return -1; + + SRetrieveTableRsp* pRetrieve = (SRetrieveTableRsp*)buf; + pRetrieve->useconds = 0; + pRetrieve->precision = TSDB_DEFAULT_PRECISION; + pRetrieve->compressed = 0; + pRetrieve->completed = 1; + pRetrieve->numOfRows = htonl(pBlock->info.rows); + + // TODO enable compress + int32_t actualLen = 0; + blockCompressEncode(pBlock, pRetrieve->data, &actualLen, pBlock->info.numOfCols, false); + actualLen += sizeof(SRetrieveTableRsp); + ASSERT(actualLen <= dataStrLen); + taosArrayPush(pRsp->blockDataLen, &actualLen); + taosArrayPush(pRsp->blockData, &buf); + return 0; +} + +static int32_t tqAddBlockSchemaToRsp(const STqExecHandle* pExec, int32_t workerId, SMqDataBlkRsp* pRsp) { + SSchemaWrapper* pSW = tCloneSSchemaWrapper(pExec->pExecReader[workerId]->pSchemaWrapper); + taosArrayPush(pRsp->blockSchema, &pSW); + return 0; +} + +static int32_t tqAddTbNameToRsp(const STQ* pTq, const STqExecHandle* pExec, SMqDataBlkRsp* pRsp, int32_t workerId) { + SMetaReader mr = {0}; + metaReaderInit(&mr, pTq->pVnode->pMeta, 0); + int64_t uid = pExec->pExecReader[workerId]->msgIter.uid; + if (metaGetTableEntryByUid(&mr, uid) < 0) { + ASSERT(0); + return -1; + } + char* tbName = strdup(mr.me.name); + taosArrayPush(pRsp->blockTbName, &tbName); + metaReaderClear(&mr); + return 0; +} + +int32_t tqDataExec(STQ* pTq, STqExecHandle* pExec, SSubmitReq* pReq, SMqDataBlkRsp* pRsp, int32_t workerId) { + if (pExec->subType == TOPIC_SUB_TYPE__COLUMN) { + qTaskInfo_t task = pExec->exec.execCol.task[workerId]; + ASSERT(task); + qSetStreamInput(task, pReq, STREAM_DATA_TYPE_SUBMIT_BLOCK, false); + while (1) { + SSDataBlock* pDataBlock = NULL; + uint64_t ts = 0; + if (qExecTask(task, &pDataBlock, &ts) < 0) { + ASSERT(0); + } + if (pDataBlock == NULL) break; + + ASSERT(pDataBlock->info.rows != 0); + ASSERT(pDataBlock->info.numOfCols != 0); + + tqAddBlockDataToRsp(pDataBlock, pRsp); + if (pRsp->withTbName) { + tqAddTbNameToRsp(pTq, pExec, pRsp, workerId); + } + pRsp->blockNum++; + } + } else if (pExec->subType == TOPIC_SUB_TYPE__TABLE) { + pRsp->withSchema = 1; + STqReadHandle* pReader = pExec->pExecReader[workerId]; + tqReadHandleSetMsg(pReader, pReq, 0); + while (tqNextDataBlock(pReader)) { + SSDataBlock block = {0}; + if (tqRetrieveDataBlock(&block.pDataBlock, pReader, &block.info.groupId, &block.info.uid, &block.info.rows, + &block.info.numOfCols) < 0) { + if (terrno == TSDB_CODE_TQ_TABLE_SCHEMA_NOT_FOUND) continue; + ASSERT(0); + } + tqAddBlockDataToRsp(&block, pRsp); + if (pRsp->withTbName) { + tqAddTbNameToRsp(pTq, pExec, pRsp, workerId); + } + tqAddBlockSchemaToRsp(pExec, workerId, pRsp); + pRsp->blockNum++; + } + } else if (pExec->subType == TOPIC_SUB_TYPE__DB) { + pRsp->withSchema = 1; + STqReadHandle* pReader = pExec->pExecReader[workerId]; + tqReadHandleSetMsg(pReader, pReq, 0); + while (tqNextDataBlockFilterOut(pReader, pExec->exec.execDb.pFilterOutTbUid)) { + SSDataBlock block = {0}; + if (tqRetrieveDataBlock(&block.pDataBlock, pReader, &block.info.groupId, &block.info.uid, &block.info.rows, + &block.info.numOfCols) < 0) { + if (terrno == TSDB_CODE_TQ_TABLE_SCHEMA_NOT_FOUND) continue; + ASSERT(0); + } + tqAddBlockDataToRsp(&block, pRsp); + if (pRsp->withTbName) { + tqAddTbNameToRsp(pTq, pExec, pRsp, workerId); + } + tqAddBlockSchemaToRsp(pExec, workerId, pRsp); + pRsp->blockNum++; + } + } + if (pRsp->blockNum == 0) { + pRsp->skipLogNum++; + return -1; + } + return 0; +} diff --git a/source/dnode/vnode/src/tq/tqMeta.c b/source/dnode/vnode/src/tq/tqMeta.c new file mode 100644 index 0000000000..f2f48bbc8a --- /dev/null +++ b/source/dnode/vnode/src/tq/tqMeta.c @@ -0,0 +1,14 @@ +/* + * 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 . + */ diff --git a/source/dnode/vnode/src/tq/tqRead.c b/source/dnode/vnode/src/tq/tqRead.c index 9f4c5fc81e..1f5d3b7f53 100644 --- a/source/dnode/vnode/src/tq/tqRead.c +++ b/source/dnode/vnode/src/tq/tqRead.c @@ -15,6 +15,48 @@ #include "tq.h" +int64_t tqFetchLog(STQ* pTq, STqHandle* pHandle, int64_t* fetchOffset, SWalHead** ppHeadWithCkSum) { + int32_t code = 0; + taosThreadMutexLock(&pHandle->pWalReader->mutex); + int64_t offset = *fetchOffset; + + while (1) { + if (walFetchHead(pHandle->pWalReader, offset, *ppHeadWithCkSum) < 0) { + tqDebug("tmq poll: consumer %ld (epoch %d) vg %d offset %ld, no more log to return", pHandle->consumerId, + pHandle->epoch, TD_VID(pTq->pVnode), offset); + *fetchOffset = offset - 1; + code = -1; + goto END; + } + + if ((*ppHeadWithCkSum)->head.msgType == TDMT_VND_SUBMIT) { + code = walFetchBody(pHandle->pWalReader, ppHeadWithCkSum); + + if (code < 0) { + ASSERT(0); + *fetchOffset = offset; + code = -1; + goto END; + } + *fetchOffset = offset; + code = 0; + goto END; + } else { + code = walSkipFetchBody(pHandle->pWalReader, *ppHeadWithCkSum); + if (code < 0) { + ASSERT(0); + *fetchOffset = offset; + code = -1; + goto END; + } + offset++; + } + } +END: + taosThreadMutexUnlock(&pHandle->pWalReader->mutex); + return code; +} + STqReadHandle* tqInitSubmitMsgScanner(SMeta* pMeta) { STqReadHandle* pReadHandle = taosMemoryMalloc(sizeof(STqReadHandle)); if (pReadHandle == NULL) { @@ -24,7 +66,7 @@ STqReadHandle* tqInitSubmitMsgScanner(SMeta* pMeta) { pReadHandle->pMsg = NULL; pReadHandle->ver = -1; pReadHandle->pColIdList = NULL; - pReadHandle->sver = -1; + pReadHandle->cachedSchemaVer = -1; pReadHandle->cachedSchemaUid = -1; pReadHandle->pSchema = NULL; pReadHandle->pSchemaWrapper = NULL; @@ -88,11 +130,11 @@ int32_t tqRetrieveDataBlock(SArray** ppCols, STqReadHandle* pHandle, uint64_t* p // TODO set to real sversion /*int32_t sversion = 1;*/ int32_t sversion = htonl(pHandle->pBlock->sversion); - if (pHandle->sver != sversion || pHandle->cachedSchemaUid != pHandle->msgIter.suid) { + if (pHandle->cachedSchemaVer != sversion || pHandle->cachedSchemaUid != pHandle->msgIter.suid) { pHandle->pSchema = metaGetTbTSchema(pHandle->pVnodeMeta, pHandle->msgIter.uid, sversion); if (pHandle->pSchema == NULL) { tqWarn("cannot found tsschema for table: uid: %ld (suid: %ld), version %d, possibly dropped table", - pHandle->msgIter.uid, pHandle->msgIter.suid, pHandle->sver); + pHandle->msgIter.uid, pHandle->msgIter.suid, pHandle->cachedSchemaVer); /*ASSERT(0);*/ terrno = TSDB_CODE_TQ_TABLE_SCHEMA_NOT_FOUND; return -1; @@ -102,12 +144,12 @@ int32_t tqRetrieveDataBlock(SArray** ppCols, STqReadHandle* pHandle, uint64_t* p pHandle->pSchemaWrapper = metaGetTableSchema(pHandle->pVnodeMeta, pHandle->msgIter.suid, sversion, true); if (pHandle->pSchemaWrapper == NULL) { tqWarn("cannot found schema wrapper for table: suid: %ld, version %d, possibly dropped table", - pHandle->msgIter.suid, pHandle->sver); + pHandle->msgIter.suid, pHandle->cachedSchemaVer); /*ASSERT(0);*/ terrno = TSDB_CODE_TQ_TABLE_SCHEMA_NOT_FOUND; return -1; } - pHandle->sver = sversion; + pHandle->cachedSchemaVer = sversion; pHandle->cachedSchemaUid = pHandle->msgIter.suid; } diff --git a/tests/system-test/7-tmq/subscribeDb.py b/tests/system-test/7-tmq/subscribeDb.py index 157bc7928b..43b707e651 100644 --- a/tests/system-test/7-tmq/subscribeDb.py +++ b/tests/system-test/7-tmq/subscribeDb.py @@ -182,7 +182,7 @@ class TDTestCase: tdLog.info("create topics from db") topicName1 = 'topic_db1' - tdSql.execute("create topic %s as %s" %(topicName1, parameterDict['dbName'])) + tdSql.execute("create topic %s as database %s" %(topicName1, parameterDict['dbName'])) consumerId = 0 expectrowcnt = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"] topicList = topicName1 @@ -223,7 +223,7 @@ class TDTestCase: tdLog.info("create topics from db") topicName1 = 'topic_db1' - tdSql.execute("create topic %s as %s" %(topicName1, parameterDict['dbName'])) + tdSql.execute("create topic %s as database %s" %(topicName1, parameterDict['dbName'])) consumerId = 0 expectrowcnt = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"] topicList = topicName1 @@ -279,7 +279,7 @@ class TDTestCase: tdLog.info("create topics from db") topicName1 = 'topic_db1' - tdSql.execute("create topic %s as %s" %(topicName1, parameterDict['dbName'])) + tdSql.execute("create topic %s as database %s" %(topicName1, parameterDict['dbName'])) consumerId = 0 expectrowcnt = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"] @@ -343,7 +343,7 @@ class TDTestCase: tdLog.info("create topics from db") topicName1 = 'topic_db1' - tdSql.execute("create topic %s as %s" %(topicName1, parameterDict['dbName'])) + tdSql.execute("create topic %s as database %s" %(topicName1, parameterDict['dbName'])) consumerId = 0 expectrowcnt = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"] @@ -427,7 +427,7 @@ class TDTestCase: tdLog.info("create topics from db") topicName1 = 'topic_db1' - tdSql.execute("create topic %s as %s" %(topicName1, parameterDict['dbName'])) + tdSql.execute("create topic %s as database %s" %(topicName1, parameterDict['dbName'])) consumerId = 0 expectrowcnt = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"] + parameterDict2["rowsPerTbl"] * parameterDict2["ctbNum"] diff --git a/tests/system-test/7-tmq/subscribeDb0.py b/tests/system-test/7-tmq/subscribeDb0.py index d6f93acfd6..ce273367c7 100644 --- a/tests/system-test/7-tmq/subscribeDb0.py +++ b/tests/system-test/7-tmq/subscribeDb0.py @@ -195,7 +195,7 @@ class TDTestCase: tdLog.info("create topics from db") topicName1 = 'topic_db1' - tdSql.execute("create topic %s as %s" %(topicName1, parameterDict['dbName'])) + tdSql.execute("create topic %s as database %s" %(topicName1, parameterDict['dbName'])) consumerId = 0 expectrowcnt = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"] + parameterDict2["rowsPerTbl"] * parameterDict2["ctbNum"] @@ -272,7 +272,7 @@ class TDTestCase: tdLog.info("create topics from db") topicName1 = 'topic_db1' - tdSql.execute("create topic %s as %s" %(topicName1, parameterDict['dbName'])) + tdSql.execute("create topic %s as database %s" %(topicName1, parameterDict['dbName'])) consumerId = 0 expectrowcnt = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"] + parameterDict2["rowsPerTbl"] * parameterDict2["ctbNum"] @@ -358,8 +358,8 @@ class TDTestCase: topicName1 = 'topic_db60' topicName2 = 'topic_db61' - tdSql.execute("create topic %s as %s" %(topicName1, parameterDict['dbName'])) - tdSql.execute("create topic %s as %s" %(topicName2, parameterDict2['dbName'])) + tdSql.execute("create topic %s as database %s" %(topicName1, parameterDict['dbName'])) + tdSql.execute("create topic %s as database %s" %(topicName2, parameterDict2['dbName'])) consumerId = 0 expectrowcnt = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"] + parameterDict2["rowsPerTbl"] * parameterDict2["ctbNum"] @@ -443,8 +443,8 @@ class TDTestCase: topicName1 = 'topic_db60' topicName2 = 'topic_db61' - tdSql.execute("create topic %s as %s" %(topicName1, parameterDict['dbName'])) - tdSql.execute("create topic %s as %s" %(topicName2, parameterDict2['dbName'])) + tdSql.execute("create topic %s as database %s" %(topicName1, parameterDict['dbName'])) + tdSql.execute("create topic %s as database %s" %(topicName2, parameterDict2['dbName'])) consumerId = 0 expectrowcnt = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"] + parameterDict2["rowsPerTbl"] * parameterDict2["ctbNum"] diff --git a/tests/system-test/7-tmq/subscribeDb1.py b/tests/system-test/7-tmq/subscribeDb1.py index b86364b9c3..ca87f0dba5 100644 --- a/tests/system-test/7-tmq/subscribeDb1.py +++ b/tests/system-test/7-tmq/subscribeDb1.py @@ -183,7 +183,7 @@ class TDTestCase: tdLog.info("create topics from db") topicName1 = 'topic_db1' - tdSql.execute("create topic %s as %s" %(topicName1, parameterDict['dbName'])) + tdSql.execute("create topic %s as database %s" %(topicName1, parameterDict['dbName'])) consumerId = 0 expectrowcnt = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"] / 2 topicList = topicName1 @@ -261,7 +261,7 @@ class TDTestCase: tdLog.info("create topics from db") topicName1 = 'topic_db1' - tdSql.execute("create topic %s as %s" %(topicName1, parameterDict['dbName'])) + tdSql.execute("create topic %s as database %s" %(topicName1, parameterDict['dbName'])) consumerId = 0 expectrowcnt = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"] / 2 topicList = topicName1 @@ -339,7 +339,7 @@ class TDTestCase: tdLog.info("create topics from db") topicName1 = 'topic_db1' - tdSql.execute("create topic %s as %s" %(topicName1, parameterDict['dbName'])) + tdSql.execute("create topic %s as database %s" %(topicName1, parameterDict['dbName'])) consumerId = 0 expectrowcnt = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"] topicList = topicName1 @@ -411,7 +411,7 @@ class TDTestCase: tdLog.info("create topics from db") topicName1 = 'topic_db1' - tdSql.execute("create topic %s as %s" %(topicName1, parameterDict['dbName'])) + tdSql.execute("create topic %s as database %s" %(topicName1, parameterDict['dbName'])) consumerId = 0 expectrowcnt = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"] topicList = topicName1 From 0fdb225d7eea68dfd4005dc874aea573cb535e65 Mon Sep 17 00:00:00 2001 From: Liu Jicong Date: Tue, 31 May 2022 16:49:52 +0800 Subject: [PATCH 05/14] fix: parser --- source/libs/parser/src/parTranslater.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index 9fff330ef0..af2c13946d 100644 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -3317,9 +3317,8 @@ static int32_t buildCreateTopicReq(STranslateContext* pCxt, SCreateTopicStmt* pS tNameGetFullDbName(&name, pReq->subDbName); } else { pReq->subType = TOPIC_SUB_TYPE__COLUMN; - tNameSetDbName(&name, pCxt->pParseCxt->acctId, - ((SRealTableNode*)(((SSelectStmt*)pStmt->pQuery)->pFromTable))->table.dbName, - strlen(pStmt->subDbName)); + char* dbName = ((SRealTableNode*)(((SSelectStmt*)pStmt->pQuery)->pFromTable))->table.dbName; + tNameSetDbName(&name, pCxt->pParseCxt->acctId, dbName, strlen(dbName)); tNameGetFullDbName(&name, pReq->subDbName); pCxt->pParseCxt->topicQuery = true; code = translateQuery(pCxt, pStmt->pQuery); From 4169eb559a2e08a39a97db6376640384601475de Mon Sep 17 00:00:00 2001 From: Liu Jicong Date: Tue, 31 May 2022 17:02:43 +0800 Subject: [PATCH 06/14] fix(tmq): skip log --- source/dnode/vnode/src/tq/tq.c | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/source/dnode/vnode/src/tq/tq.c b/source/dnode/vnode/src/tq/tq.c index 16201994f0..b4747f2264 100644 --- a/source/dnode/vnode/src/tq/tq.c +++ b/source/dnode/vnode/src/tq/tq.c @@ -441,14 +441,8 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) { break; } - tqDebug("tmq poll vg %d: offset %ld msgType %d", pTq->pVnode->config.vgId, fetchOffset, - pHeadWithCkSum->head.msgType); - SWalReadHead* pHead = &pHeadWithCkSum->head; - tqDebug("tmq poll vg %d: offset %ld msgType %d", pTq->pVnode->config.vgId, fetchOffset, - pHeadWithCkSum->head.msgType); - #if 0 SWalReadHead* pHead; if (walReadWithHandle_s(pExec->pWalReader, fetchOffset, &pHead) < 0) { @@ -499,6 +493,8 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) { // TODO continue scan until meeting batch requirement if (rsp.blockNum > 0 /* threshold */) { break; + } else { + fetchOffset++; } } From 5c8d59e562e590e6682a78673014c731933a03fa Mon Sep 17 00:00:00 2001 From: Liu Jicong Date: Tue, 31 May 2022 17:15:23 +0800 Subject: [PATCH 07/14] fix(parser): create topic ut --- source/libs/parser/test/parInitialCTest.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/libs/parser/test/parInitialCTest.cpp b/source/libs/parser/test/parInitialCTest.cpp index 8b545b3cb4..65d5194936 100644 --- a/source/libs/parser/test/parInitialCTest.cpp +++ b/source/libs/parser/test/parInitialCTest.cpp @@ -491,7 +491,7 @@ TEST_F(ParserInitialCTest, createTopic) { expect.ast = (char*)pAst; } else { expect.subType = TOPIC_SUB_TYPE__DB; - snprintf(expect.subStbName, sizeof(expect.subStbName), "0.%s", pDbName); + snprintf(expect.subDbName, sizeof(expect.subDbName), "0.%s", pDbName); } }; From d805439568b260c7685c35563b9f248bac8d24d6 Mon Sep 17 00:00:00 2001 From: Xiaoyu Wang Date: Tue, 31 May 2022 18:09:19 +0800 Subject: [PATCH 08/14] fix: compile error --- source/libs/parser/src/sql.c | 1792 ++++++++++------------------------ 1 file changed, 543 insertions(+), 1249 deletions(-) diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c index d180b4892f..7fb89bdd7c 100644 --- a/source/libs/parser/src/sql.c +++ b/source/libs/parser/src/sql.c @@ -1,5 +1,3 @@ -/* This file is automatically generated by Lemon from input grammar -** source file "sql.y". */ /* ** 2000-05-29 ** @@ -24,7 +22,10 @@ ** The following is the concatenation of all %include directives from the ** input grammar file: */ +#include +#include /************ Begin %include sections from the grammar ************************/ + #include #include #include @@ -37,247 +38,11 @@ #include "ttokendef.h" #include "parAst.h" /**************** End of %include directives **********************************/ -/* These constants specify the various numeric values for terminal symbols. -***************** Begin token definitions *************************************/ -#ifndef TK_OR -#define TK_OR 1 -#define TK_AND 2 -#define TK_UNION 3 -#define TK_ALL 4 -#define TK_MINUS 5 -#define TK_EXCEPT 6 -#define TK_INTERSECT 7 -#define TK_NK_BITAND 8 -#define TK_NK_BITOR 9 -#define TK_NK_LSHIFT 10 -#define TK_NK_RSHIFT 11 -#define TK_NK_PLUS 12 -#define TK_NK_MINUS 13 -#define TK_NK_STAR 14 -#define TK_NK_SLASH 15 -#define TK_NK_REM 16 -#define TK_NK_CONCAT 17 -#define TK_CREATE 18 -#define TK_ACCOUNT 19 -#define TK_NK_ID 20 -#define TK_PASS 21 -#define TK_NK_STRING 22 -#define TK_ALTER 23 -#define TK_PPS 24 -#define TK_TSERIES 25 -#define TK_STORAGE 26 -#define TK_STREAMS 27 -#define TK_QTIME 28 -#define TK_DBS 29 -#define TK_USERS 30 -#define TK_CONNS 31 -#define TK_STATE 32 -#define TK_USER 33 -#define TK_PRIVILEGE 34 -#define TK_DROP 35 -#define TK_GRANT 36 -#define TK_ON 37 -#define TK_TO 38 -#define TK_REVOKE 39 -#define TK_FROM 40 -#define TK_NK_COMMA 41 -#define TK_READ 42 -#define TK_WRITE 43 -#define TK_NK_DOT 44 -#define TK_DNODE 45 -#define TK_PORT 46 -#define TK_NK_INTEGER 47 -#define TK_DNODES 48 -#define TK_NK_IPTOKEN 49 -#define TK_LOCAL 50 -#define TK_QNODE 51 -#define TK_BNODE 52 -#define TK_SNODE 53 -#define TK_MNODE 54 -#define TK_DATABASE 55 -#define TK_USE 56 -#define TK_IF 57 -#define TK_NOT 58 -#define TK_EXISTS 59 -#define TK_BUFFER 60 -#define TK_CACHELAST 61 -#define TK_COMP 62 -#define TK_DAYS 63 -#define TK_NK_VARIABLE 64 -#define TK_FSYNC 65 -#define TK_MAXROWS 66 -#define TK_MINROWS 67 -#define TK_KEEP 68 -#define TK_PAGES 69 -#define TK_PAGESIZE 70 -#define TK_PRECISION 71 -#define TK_REPLICA 72 -#define TK_STRICT 73 -#define TK_WAL 74 -#define TK_VGROUPS 75 -#define TK_SINGLE_STABLE 76 -#define TK_RETENTIONS 77 -#define TK_SCHEMALESS 78 -#define TK_NK_COLON 79 -#define TK_TABLE 80 -#define TK_NK_LP 81 -#define TK_NK_RP 82 -#define TK_STABLE 83 -#define TK_ADD 84 -#define TK_COLUMN 85 -#define TK_MODIFY 86 -#define TK_RENAME 87 -#define TK_TAG 88 -#define TK_SET 89 -#define TK_NK_EQ 90 -#define TK_USING 91 -#define TK_TAGS 92 -#define TK_COMMENT 93 -#define TK_BOOL 94 -#define TK_TINYINT 95 -#define TK_SMALLINT 96 -#define TK_INT 97 -#define TK_INTEGER 98 -#define TK_BIGINT 99 -#define TK_FLOAT 100 -#define TK_DOUBLE 101 -#define TK_BINARY 102 -#define TK_TIMESTAMP 103 -#define TK_NCHAR 104 -#define TK_UNSIGNED 105 -#define TK_JSON 106 -#define TK_VARCHAR 107 -#define TK_MEDIUMBLOB 108 -#define TK_BLOB 109 -#define TK_VARBINARY 110 -#define TK_DECIMAL 111 -#define TK_FILE_FACTOR 112 -#define TK_NK_FLOAT 113 -#define TK_ROLLUP 114 -#define TK_TTL 115 -#define TK_SMA 116 -#define TK_SHOW 117 -#define TK_DATABASES 118 -#define TK_TABLES 119 -#define TK_STABLES 120 -#define TK_MNODES 121 -#define TK_MODULES 122 -#define TK_QNODES 123 -#define TK_FUNCTIONS 124 -#define TK_INDEXES 125 -#define TK_ACCOUNTS 126 -#define TK_APPS 127 -#define TK_CONNECTIONS 128 -#define TK_LICENCE 129 -#define TK_GRANTS 130 -#define TK_QUERIES 131 -#define TK_SCORES 132 -#define TK_TOPICS 133 -#define TK_VARIABLES 134 -#define TK_BNODES 135 -#define TK_SNODES 136 -#define TK_CLUSTER 137 -#define TK_TRANSACTIONS 138 -#define TK_LIKE 139 -#define TK_INDEX 140 -#define TK_FULLTEXT 141 -#define TK_FUNCTION 142 -#define TK_INTERVAL 143 -#define TK_TOPIC 144 -#define TK_AS 145 -#define TK_CONSUMER 146 -#define TK_GROUP 147 -#define TK_DESC 148 -#define TK_DESCRIBE 149 -#define TK_RESET 150 -#define TK_QUERY 151 -#define TK_CACHE 152 -#define TK_EXPLAIN 153 -#define TK_ANALYZE 154 -#define TK_VERBOSE 155 -#define TK_NK_BOOL 156 -#define TK_RATIO 157 -#define TK_COMPACT 158 -#define TK_VNODES 159 -#define TK_IN 160 -#define TK_OUTPUTTYPE 161 -#define TK_AGGREGATE 162 -#define TK_BUFSIZE 163 -#define TK_STREAM 164 -#define TK_INTO 165 -#define TK_TRIGGER 166 -#define TK_AT_ONCE 167 -#define TK_WINDOW_CLOSE 168 -#define TK_WATERMARK 169 -#define TK_KILL 170 -#define TK_CONNECTION 171 -#define TK_TRANSACTION 172 -#define TK_MERGE 173 -#define TK_VGROUP 174 -#define TK_REDISTRIBUTE 175 -#define TK_SPLIT 176 -#define TK_SYNCDB 177 -#define TK_NULL 178 -#define TK_NK_QUESTION 179 -#define TK_NK_ARROW 180 -#define TK_ROWTS 181 -#define TK_TBNAME 182 -#define TK_QSTARTTS 183 -#define TK_QENDTS 184 -#define TK_WSTARTTS 185 -#define TK_WENDTS 186 -#define TK_WDURATION 187 -#define TK_CAST 188 -#define TK_NOW 189 -#define TK_TODAY 190 -#define TK_TIMEZONE 191 -#define TK_COUNT 192 -#define TK_FIRST 193 -#define TK_LAST 194 -#define TK_LAST_ROW 195 -#define TK_BETWEEN 196 -#define TK_IS 197 -#define TK_NK_LT 198 -#define TK_NK_GT 199 -#define TK_NK_LE 200 -#define TK_NK_GE 201 -#define TK_NK_NE 202 -#define TK_MATCH 203 -#define TK_NMATCH 204 -#define TK_CONTAINS 205 -#define TK_JOIN 206 -#define TK_INNER 207 -#define TK_SELECT 208 -#define TK_DISTINCT 209 -#define TK_WHERE 210 -#define TK_PARTITION 211 -#define TK_BY 212 -#define TK_SESSION 213 -#define TK_STATE_WINDOW 214 -#define TK_SLIDING 215 -#define TK_FILL 216 -#define TK_VALUE 217 -#define TK_NONE 218 -#define TK_PREV 219 -#define TK_LINEAR 220 -#define TK_NEXT 221 -#define TK_HAVING 222 -#define TK_ORDER 223 -#define TK_SLIMIT 224 -#define TK_SOFFSET 225 -#define TK_LIMIT 226 -#define TK_OFFSET 227 -#define TK_ASC 228 -#define TK_NULLS 229 -#define TK_ID 230 -#define TK_NK_BITNOT 231 -#define TK_INSERT 232 -#define TK_VALUES 233 -#define TK_IMPORT 234 -#define TK_NK_SEMI 235 -#define TK_FILE 236 -#endif -/**************** End token definitions ***************************************/ +/* These constants specify the various numeric values for terminal symbols +** in a format understandable to "makeheaders". This section is blank unless +** "lemon" is run with the "-m" command-line option. +***************** Begin makeheaders token definitions *************************/ +/**************** End makeheaders token definitions ***************************/ /* The next sections is a series of control #defines. ** various aspects of the generated parser. @@ -371,7 +136,6 @@ typedef union { #define YYFALLBACK 1 #define YYNSTATE 612 #define YYNRULE 451 -#define YYNRULE_WITH_ACTION 451 #define YYNTOKEN 237 #define YY_MAX_SHIFT 611 #define YY_MIN_SHIFTREDUCE 898 @@ -876,31 +640,7 @@ static const YYCODETYPE yy_lookahead[] = { /* 2090 */ 357, 357, 357, 357, 357, 357, 357, 357, 357, 357, /* 2100 */ 328, 329, 330, 357, 332, 357, 357, 335, 357, 357, /* 2110 */ 357, 357, 357, 357, 357, 357, 357, 357, 357, 357, - /* 2120 */ 348, 357, 357, 357, 352, 237, 237, 237, 237, 237, - /* 2130 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2140 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2150 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2160 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2170 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2180 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2190 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2200 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2210 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2220 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2230 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2240 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2250 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2260 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2270 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2280 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2290 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2300 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2310 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2320 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2330 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2340 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2350 */ 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - /* 2360 */ 237, 237, + /* 2120 */ 348, 357, 357, 357, 352, }; #define YY_SHIFT_COUNT (611) #define YY_SHIFT_MIN (0) @@ -1370,7 +1110,6 @@ struct yyParser { }; typedef struct yyParser yyParser; -#include #ifndef NDEBUG #include static FILE *yyTraceFILE = 0; @@ -2643,18 +2382,15 @@ static YYACTIONTYPE yy_find_shift_action( do{ i = yy_shift_ofst[stateno]; assert( i>=0 ); - assert( i<=YY_ACTTAB_COUNT ); - assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD ); + /* assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD ); */ assert( iLookAhead!=YYNOCODE ); assert( iLookAhead < YYNTOKEN ); i += iLookAhead; - assert( i<(int)YY_NLOOKAHEAD ); - if( yy_lookahead[i]!=iLookAhead ){ + if( i>=YY_NLOOKAHEAD || yy_lookahead[i]!=iLookAhead ){ #ifdef YYFALLBACK YYCODETYPE iFallback; /* Fallback token */ - assert( iLookAhead %s\n", @@ -2669,8 +2405,16 @@ static YYACTIONTYPE yy_find_shift_action( #ifdef YYWILDCARD { int j = i - iLookAhead + YYWILDCARD; - assert( j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) ); - if( yy_lookahead[j]==YYWILDCARD && iLookAhead>0 ){ + if( +#if YY_SHIFT_MIN+YYWILDCARD<0 + j>=0 && +#endif +#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT + j0 + ){ #ifndef NDEBUG if( yyTraceFILE ){ fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n", @@ -2684,7 +2428,6 @@ static YYACTIONTYPE yy_find_shift_action( #endif /* YYWILDCARD */ return yy_default[stateno]; }else{ - assert( i>=0 && i<(int)(sizeof(yy_action)/sizeof(yy_action[0])) ); return yy_action[i]; } }while(1); @@ -2803,916 +2546,464 @@ static void yy_shift( yyTraceShift(yypParser, yyNewState, "Shift"); } -/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side -** of that rule */ -static const YYCODETYPE yyRuleInfoLhs[] = { - 237, /* (0) cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */ - 237, /* (1) cmd ::= ALTER ACCOUNT NK_ID alter_account_options */ - 238, /* (2) account_options ::= */ - 238, /* (3) account_options ::= account_options PPS literal */ - 238, /* (4) account_options ::= account_options TSERIES literal */ - 238, /* (5) account_options ::= account_options STORAGE literal */ - 238, /* (6) account_options ::= account_options STREAMS literal */ - 238, /* (7) account_options ::= account_options QTIME literal */ - 238, /* (8) account_options ::= account_options DBS literal */ - 238, /* (9) account_options ::= account_options USERS literal */ - 238, /* (10) account_options ::= account_options CONNS literal */ - 238, /* (11) account_options ::= account_options STATE literal */ - 239, /* (12) alter_account_options ::= alter_account_option */ - 239, /* (13) alter_account_options ::= alter_account_options alter_account_option */ - 241, /* (14) alter_account_option ::= PASS literal */ - 241, /* (15) alter_account_option ::= PPS literal */ - 241, /* (16) alter_account_option ::= TSERIES literal */ - 241, /* (17) alter_account_option ::= STORAGE literal */ - 241, /* (18) alter_account_option ::= STREAMS literal */ - 241, /* (19) alter_account_option ::= QTIME literal */ - 241, /* (20) alter_account_option ::= DBS literal */ - 241, /* (21) alter_account_option ::= USERS literal */ - 241, /* (22) alter_account_option ::= CONNS literal */ - 241, /* (23) alter_account_option ::= STATE literal */ - 237, /* (24) cmd ::= CREATE USER user_name PASS NK_STRING */ - 237, /* (25) cmd ::= ALTER USER user_name PASS NK_STRING */ - 237, /* (26) cmd ::= ALTER USER user_name PRIVILEGE NK_STRING */ - 237, /* (27) cmd ::= DROP USER user_name */ - 237, /* (28) cmd ::= GRANT privileges ON priv_level TO user_name */ - 237, /* (29) cmd ::= REVOKE privileges ON priv_level FROM user_name */ - 243, /* (30) privileges ::= ALL */ - 243, /* (31) privileges ::= priv_type_list */ - 245, /* (32) priv_type_list ::= priv_type */ - 245, /* (33) priv_type_list ::= priv_type_list NK_COMMA priv_type */ - 246, /* (34) priv_type ::= READ */ - 246, /* (35) priv_type ::= WRITE */ - 244, /* (36) priv_level ::= NK_STAR NK_DOT NK_STAR */ - 244, /* (37) priv_level ::= db_name NK_DOT NK_STAR */ - 237, /* (38) cmd ::= CREATE DNODE dnode_endpoint */ - 237, /* (39) cmd ::= CREATE DNODE dnode_host_name PORT NK_INTEGER */ - 237, /* (40) cmd ::= DROP DNODE NK_INTEGER */ - 237, /* (41) cmd ::= DROP DNODE dnode_endpoint */ - 237, /* (42) cmd ::= ALTER DNODE NK_INTEGER NK_STRING */ - 237, /* (43) cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */ - 237, /* (44) cmd ::= ALTER ALL DNODES NK_STRING */ - 237, /* (45) cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */ - 248, /* (46) dnode_endpoint ::= NK_STRING */ - 249, /* (47) dnode_host_name ::= NK_ID */ - 249, /* (48) dnode_host_name ::= NK_IPTOKEN */ - 237, /* (49) cmd ::= ALTER LOCAL NK_STRING */ - 237, /* (50) cmd ::= ALTER LOCAL NK_STRING NK_STRING */ - 237, /* (51) cmd ::= CREATE QNODE ON DNODE NK_INTEGER */ - 237, /* (52) cmd ::= DROP QNODE ON DNODE NK_INTEGER */ - 237, /* (53) cmd ::= CREATE BNODE ON DNODE NK_INTEGER */ - 237, /* (54) cmd ::= DROP BNODE ON DNODE NK_INTEGER */ - 237, /* (55) cmd ::= CREATE SNODE ON DNODE NK_INTEGER */ - 237, /* (56) cmd ::= DROP SNODE ON DNODE NK_INTEGER */ - 237, /* (57) cmd ::= CREATE MNODE ON DNODE NK_INTEGER */ - 237, /* (58) cmd ::= DROP MNODE ON DNODE NK_INTEGER */ - 237, /* (59) cmd ::= CREATE DATABASE not_exists_opt db_name db_options */ - 237, /* (60) cmd ::= DROP DATABASE exists_opt db_name */ - 237, /* (61) cmd ::= USE db_name */ - 237, /* (62) cmd ::= ALTER DATABASE db_name alter_db_options */ - 250, /* (63) not_exists_opt ::= IF NOT EXISTS */ - 250, /* (64) not_exists_opt ::= */ - 252, /* (65) exists_opt ::= IF EXISTS */ - 252, /* (66) exists_opt ::= */ - 251, /* (67) db_options ::= */ - 251, /* (68) db_options ::= db_options BUFFER NK_INTEGER */ - 251, /* (69) db_options ::= db_options CACHELAST NK_INTEGER */ - 251, /* (70) db_options ::= db_options COMP NK_INTEGER */ - 251, /* (71) db_options ::= db_options DAYS NK_INTEGER */ - 251, /* (72) db_options ::= db_options DAYS NK_VARIABLE */ - 251, /* (73) db_options ::= db_options FSYNC NK_INTEGER */ - 251, /* (74) db_options ::= db_options MAXROWS NK_INTEGER */ - 251, /* (75) db_options ::= db_options MINROWS NK_INTEGER */ - 251, /* (76) db_options ::= db_options KEEP integer_list */ - 251, /* (77) db_options ::= db_options KEEP variable_list */ - 251, /* (78) db_options ::= db_options PAGES NK_INTEGER */ - 251, /* (79) db_options ::= db_options PAGESIZE NK_INTEGER */ - 251, /* (80) db_options ::= db_options PRECISION NK_STRING */ - 251, /* (81) db_options ::= db_options REPLICA NK_INTEGER */ - 251, /* (82) db_options ::= db_options STRICT NK_INTEGER */ - 251, /* (83) db_options ::= db_options WAL NK_INTEGER */ - 251, /* (84) db_options ::= db_options VGROUPS NK_INTEGER */ - 251, /* (85) db_options ::= db_options SINGLE_STABLE NK_INTEGER */ - 251, /* (86) db_options ::= db_options RETENTIONS retention_list */ - 251, /* (87) db_options ::= db_options SCHEMALESS NK_INTEGER */ - 253, /* (88) alter_db_options ::= alter_db_option */ - 253, /* (89) alter_db_options ::= alter_db_options alter_db_option */ - 257, /* (90) alter_db_option ::= BUFFER NK_INTEGER */ - 257, /* (91) alter_db_option ::= CACHELAST NK_INTEGER */ - 257, /* (92) alter_db_option ::= FSYNC NK_INTEGER */ - 257, /* (93) alter_db_option ::= KEEP integer_list */ - 257, /* (94) alter_db_option ::= KEEP variable_list */ - 257, /* (95) alter_db_option ::= PAGES NK_INTEGER */ - 257, /* (96) alter_db_option ::= REPLICA NK_INTEGER */ - 257, /* (97) alter_db_option ::= STRICT NK_INTEGER */ - 257, /* (98) alter_db_option ::= WAL NK_INTEGER */ - 254, /* (99) integer_list ::= NK_INTEGER */ - 254, /* (100) integer_list ::= integer_list NK_COMMA NK_INTEGER */ - 255, /* (101) variable_list ::= NK_VARIABLE */ - 255, /* (102) variable_list ::= variable_list NK_COMMA NK_VARIABLE */ - 256, /* (103) retention_list ::= retention */ - 256, /* (104) retention_list ::= retention_list NK_COMMA retention */ - 258, /* (105) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ - 237, /* (106) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ - 237, /* (107) cmd ::= CREATE TABLE multi_create_clause */ - 237, /* (108) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ - 237, /* (109) cmd ::= DROP TABLE multi_drop_clause */ - 237, /* (110) cmd ::= DROP STABLE exists_opt full_table_name */ - 237, /* (111) cmd ::= ALTER TABLE alter_table_clause */ - 237, /* (112) cmd ::= ALTER STABLE alter_table_clause */ - 266, /* (113) alter_table_clause ::= full_table_name alter_table_options */ - 266, /* (114) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ - 266, /* (115) alter_table_clause ::= full_table_name DROP COLUMN column_name */ - 266, /* (116) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ - 266, /* (117) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ - 266, /* (118) alter_table_clause ::= full_table_name ADD TAG column_name type_name */ - 266, /* (119) alter_table_clause ::= full_table_name DROP TAG column_name */ - 266, /* (120) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ - 266, /* (121) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ - 266, /* (122) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ - 263, /* (123) multi_create_clause ::= create_subtable_clause */ - 263, /* (124) multi_create_clause ::= multi_create_clause create_subtable_clause */ - 271, /* (125) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP literal_list NK_RP table_options */ - 265, /* (126) multi_drop_clause ::= drop_table_clause */ - 265, /* (127) multi_drop_clause ::= multi_drop_clause drop_table_clause */ - 274, /* (128) drop_table_clause ::= exists_opt full_table_name */ - 272, /* (129) specific_tags_opt ::= */ - 272, /* (130) specific_tags_opt ::= NK_LP col_name_list NK_RP */ - 259, /* (131) full_table_name ::= table_name */ - 259, /* (132) full_table_name ::= db_name NK_DOT table_name */ - 260, /* (133) column_def_list ::= column_def */ - 260, /* (134) column_def_list ::= column_def_list NK_COMMA column_def */ - 277, /* (135) column_def ::= column_name type_name */ - 277, /* (136) column_def ::= column_name type_name COMMENT NK_STRING */ - 269, /* (137) type_name ::= BOOL */ - 269, /* (138) type_name ::= TINYINT */ - 269, /* (139) type_name ::= SMALLINT */ - 269, /* (140) type_name ::= INT */ - 269, /* (141) type_name ::= INTEGER */ - 269, /* (142) type_name ::= BIGINT */ - 269, /* (143) type_name ::= FLOAT */ - 269, /* (144) type_name ::= DOUBLE */ - 269, /* (145) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ - 269, /* (146) type_name ::= TIMESTAMP */ - 269, /* (147) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ - 269, /* (148) type_name ::= TINYINT UNSIGNED */ - 269, /* (149) type_name ::= SMALLINT UNSIGNED */ - 269, /* (150) type_name ::= INT UNSIGNED */ - 269, /* (151) type_name ::= BIGINT UNSIGNED */ - 269, /* (152) type_name ::= JSON */ - 269, /* (153) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ - 269, /* (154) type_name ::= MEDIUMBLOB */ - 269, /* (155) type_name ::= BLOB */ - 269, /* (156) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ - 269, /* (157) type_name ::= DECIMAL */ - 269, /* (158) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ - 269, /* (159) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ - 261, /* (160) tags_def_opt ::= */ - 261, /* (161) tags_def_opt ::= tags_def */ - 264, /* (162) tags_def ::= TAGS NK_LP column_def_list NK_RP */ - 262, /* (163) table_options ::= */ - 262, /* (164) table_options ::= table_options COMMENT NK_STRING */ - 262, /* (165) table_options ::= table_options FILE_FACTOR NK_FLOAT */ - 262, /* (166) table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP */ - 262, /* (167) table_options ::= table_options TTL NK_INTEGER */ - 262, /* (168) table_options ::= table_options SMA NK_LP col_name_list NK_RP */ - 267, /* (169) alter_table_options ::= alter_table_option */ - 267, /* (170) alter_table_options ::= alter_table_options alter_table_option */ - 279, /* (171) alter_table_option ::= COMMENT NK_STRING */ - 279, /* (172) alter_table_option ::= TTL NK_INTEGER */ - 275, /* (173) col_name_list ::= col_name */ - 275, /* (174) col_name_list ::= col_name_list NK_COMMA col_name */ - 280, /* (175) col_name ::= column_name */ - 237, /* (176) cmd ::= SHOW DNODES */ - 237, /* (177) cmd ::= SHOW USERS */ - 237, /* (178) cmd ::= SHOW DATABASES */ - 237, /* (179) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */ - 237, /* (180) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ - 237, /* (181) cmd ::= SHOW db_name_cond_opt VGROUPS */ - 237, /* (182) cmd ::= SHOW MNODES */ - 237, /* (183) cmd ::= SHOW MODULES */ - 237, /* (184) cmd ::= SHOW QNODES */ - 237, /* (185) cmd ::= SHOW FUNCTIONS */ - 237, /* (186) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ - 237, /* (187) cmd ::= SHOW STREAMS */ - 237, /* (188) cmd ::= SHOW ACCOUNTS */ - 237, /* (189) cmd ::= SHOW APPS */ - 237, /* (190) cmd ::= SHOW CONNECTIONS */ - 237, /* (191) cmd ::= SHOW LICENCE */ - 237, /* (192) cmd ::= SHOW GRANTS */ - 237, /* (193) cmd ::= SHOW CREATE DATABASE db_name */ - 237, /* (194) cmd ::= SHOW CREATE TABLE full_table_name */ - 237, /* (195) cmd ::= SHOW CREATE STABLE full_table_name */ - 237, /* (196) cmd ::= SHOW QUERIES */ - 237, /* (197) cmd ::= SHOW SCORES */ - 237, /* (198) cmd ::= SHOW TOPICS */ - 237, /* (199) cmd ::= SHOW VARIABLES */ - 237, /* (200) cmd ::= SHOW BNODES */ - 237, /* (201) cmd ::= SHOW SNODES */ - 237, /* (202) cmd ::= SHOW CLUSTER */ - 237, /* (203) cmd ::= SHOW TRANSACTIONS */ - 281, /* (204) db_name_cond_opt ::= */ - 281, /* (205) db_name_cond_opt ::= db_name NK_DOT */ - 282, /* (206) like_pattern_opt ::= */ - 282, /* (207) like_pattern_opt ::= LIKE NK_STRING */ - 283, /* (208) table_name_cond ::= table_name */ - 284, /* (209) from_db_opt ::= */ - 284, /* (210) from_db_opt ::= FROM db_name */ - 278, /* (211) func_name_list ::= func_name */ - 278, /* (212) func_name_list ::= func_name_list NK_COMMA func_name */ - 285, /* (213) func_name ::= function_name */ - 237, /* (214) cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options */ - 237, /* (215) cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP */ - 237, /* (216) cmd ::= DROP INDEX exists_opt index_name ON table_name */ - 288, /* (217) index_options ::= */ - 288, /* (218) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt */ - 288, /* (219) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt */ - 289, /* (220) func_list ::= func */ - 289, /* (221) func_list ::= func_list NK_COMMA func */ - 292, /* (222) func ::= function_name NK_LP expression_list NK_RP */ - 237, /* (223) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression */ - 237, /* (224) cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name */ - 237, /* (225) cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name */ - 237, /* (226) cmd ::= DROP TOPIC exists_opt topic_name */ - 237, /* (227) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ - 237, /* (228) cmd ::= DESC full_table_name */ - 237, /* (229) cmd ::= DESCRIBE full_table_name */ - 237, /* (230) cmd ::= RESET QUERY CACHE */ - 237, /* (231) cmd ::= EXPLAIN analyze_opt explain_options query_expression */ - 297, /* (232) analyze_opt ::= */ - 297, /* (233) analyze_opt ::= ANALYZE */ - 298, /* (234) explain_options ::= */ - 298, /* (235) explain_options ::= explain_options VERBOSE NK_BOOL */ - 298, /* (236) explain_options ::= explain_options RATIO NK_FLOAT */ - 237, /* (237) cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP */ - 237, /* (238) cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */ - 237, /* (239) cmd ::= DROP FUNCTION exists_opt function_name */ - 299, /* (240) agg_func_opt ::= */ - 299, /* (241) agg_func_opt ::= AGGREGATE */ - 300, /* (242) bufsize_opt ::= */ - 300, /* (243) bufsize_opt ::= BUFSIZE NK_INTEGER */ - 237, /* (244) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression */ - 237, /* (245) cmd ::= DROP STREAM exists_opt stream_name */ - 303, /* (246) into_opt ::= */ - 303, /* (247) into_opt ::= INTO full_table_name */ - 302, /* (248) stream_options ::= */ - 302, /* (249) stream_options ::= stream_options TRIGGER AT_ONCE */ - 302, /* (250) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ - 302, /* (251) stream_options ::= stream_options WATERMARK duration_literal */ - 237, /* (252) cmd ::= KILL CONNECTION NK_INTEGER */ - 237, /* (253) cmd ::= KILL QUERY NK_INTEGER */ - 237, /* (254) cmd ::= KILL TRANSACTION NK_INTEGER */ - 237, /* (255) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ - 237, /* (256) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ - 237, /* (257) cmd ::= SPLIT VGROUP NK_INTEGER */ - 304, /* (258) dnode_list ::= DNODE NK_INTEGER */ - 304, /* (259) dnode_list ::= dnode_list DNODE NK_INTEGER */ - 237, /* (260) cmd ::= SYNCDB db_name REPLICA */ - 237, /* (261) cmd ::= query_expression */ - 240, /* (262) literal ::= NK_INTEGER */ - 240, /* (263) literal ::= NK_FLOAT */ - 240, /* (264) literal ::= NK_STRING */ - 240, /* (265) literal ::= NK_BOOL */ - 240, /* (266) literal ::= TIMESTAMP NK_STRING */ - 240, /* (267) literal ::= duration_literal */ - 240, /* (268) literal ::= NULL */ - 240, /* (269) literal ::= NK_QUESTION */ - 290, /* (270) duration_literal ::= NK_VARIABLE */ - 305, /* (271) signed ::= NK_INTEGER */ - 305, /* (272) signed ::= NK_PLUS NK_INTEGER */ - 305, /* (273) signed ::= NK_MINUS NK_INTEGER */ - 305, /* (274) signed ::= NK_FLOAT */ - 305, /* (275) signed ::= NK_PLUS NK_FLOAT */ - 305, /* (276) signed ::= NK_MINUS NK_FLOAT */ - 270, /* (277) signed_literal ::= signed */ - 270, /* (278) signed_literal ::= NK_STRING */ - 270, /* (279) signed_literal ::= NK_BOOL */ - 270, /* (280) signed_literal ::= TIMESTAMP NK_STRING */ - 270, /* (281) signed_literal ::= duration_literal */ - 270, /* (282) signed_literal ::= NULL */ - 270, /* (283) signed_literal ::= literal_func */ - 273, /* (284) literal_list ::= signed_literal */ - 273, /* (285) literal_list ::= literal_list NK_COMMA signed_literal */ - 247, /* (286) db_name ::= NK_ID */ - 276, /* (287) table_name ::= NK_ID */ - 268, /* (288) column_name ::= NK_ID */ - 286, /* (289) function_name ::= NK_ID */ - 307, /* (290) table_alias ::= NK_ID */ - 308, /* (291) column_alias ::= NK_ID */ - 242, /* (292) user_name ::= NK_ID */ - 287, /* (293) index_name ::= NK_ID */ - 294, /* (294) topic_name ::= NK_ID */ - 301, /* (295) stream_name ::= NK_ID */ - 296, /* (296) cgroup_name ::= NK_ID */ - 309, /* (297) expression ::= literal */ - 309, /* (298) expression ::= pseudo_column */ - 309, /* (299) expression ::= column_reference */ - 309, /* (300) expression ::= function_expression */ - 309, /* (301) expression ::= subquery */ - 309, /* (302) expression ::= NK_LP expression NK_RP */ - 309, /* (303) expression ::= NK_PLUS expression */ - 309, /* (304) expression ::= NK_MINUS expression */ - 309, /* (305) expression ::= expression NK_PLUS expression */ - 309, /* (306) expression ::= expression NK_MINUS expression */ - 309, /* (307) expression ::= expression NK_STAR expression */ - 309, /* (308) expression ::= expression NK_SLASH expression */ - 309, /* (309) expression ::= expression NK_REM expression */ - 309, /* (310) expression ::= column_reference NK_ARROW NK_STRING */ - 293, /* (311) expression_list ::= expression */ - 293, /* (312) expression_list ::= expression_list NK_COMMA expression */ - 311, /* (313) column_reference ::= column_name */ - 311, /* (314) column_reference ::= table_name NK_DOT column_name */ - 310, /* (315) pseudo_column ::= ROWTS */ - 310, /* (316) pseudo_column ::= TBNAME */ - 310, /* (317) pseudo_column ::= table_name NK_DOT TBNAME */ - 310, /* (318) pseudo_column ::= QSTARTTS */ - 310, /* (319) pseudo_column ::= QENDTS */ - 310, /* (320) pseudo_column ::= WSTARTTS */ - 310, /* (321) pseudo_column ::= WENDTS */ - 310, /* (322) pseudo_column ::= WDURATION */ - 312, /* (323) function_expression ::= function_name NK_LP expression_list NK_RP */ - 312, /* (324) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ - 312, /* (325) function_expression ::= CAST NK_LP expression AS type_name NK_RP */ - 312, /* (326) function_expression ::= literal_func */ - 306, /* (327) literal_func ::= noarg_func NK_LP NK_RP */ - 306, /* (328) literal_func ::= NOW */ - 316, /* (329) noarg_func ::= NOW */ - 316, /* (330) noarg_func ::= TODAY */ - 316, /* (331) noarg_func ::= TIMEZONE */ - 314, /* (332) star_func ::= COUNT */ - 314, /* (333) star_func ::= FIRST */ - 314, /* (334) star_func ::= LAST */ - 314, /* (335) star_func ::= LAST_ROW */ - 315, /* (336) star_func_para_list ::= NK_STAR */ - 315, /* (337) star_func_para_list ::= other_para_list */ - 317, /* (338) other_para_list ::= star_func_para */ - 317, /* (339) other_para_list ::= other_para_list NK_COMMA star_func_para */ - 318, /* (340) star_func_para ::= expression */ - 318, /* (341) star_func_para ::= table_name NK_DOT NK_STAR */ - 319, /* (342) predicate ::= expression compare_op expression */ - 319, /* (343) predicate ::= expression BETWEEN expression AND expression */ - 319, /* (344) predicate ::= expression NOT BETWEEN expression AND expression */ - 319, /* (345) predicate ::= expression IS NULL */ - 319, /* (346) predicate ::= expression IS NOT NULL */ - 319, /* (347) predicate ::= expression in_op in_predicate_value */ - 320, /* (348) compare_op ::= NK_LT */ - 320, /* (349) compare_op ::= NK_GT */ - 320, /* (350) compare_op ::= NK_LE */ - 320, /* (351) compare_op ::= NK_GE */ - 320, /* (352) compare_op ::= NK_NE */ - 320, /* (353) compare_op ::= NK_EQ */ - 320, /* (354) compare_op ::= LIKE */ - 320, /* (355) compare_op ::= NOT LIKE */ - 320, /* (356) compare_op ::= MATCH */ - 320, /* (357) compare_op ::= NMATCH */ - 320, /* (358) compare_op ::= CONTAINS */ - 321, /* (359) in_op ::= IN */ - 321, /* (360) in_op ::= NOT IN */ - 322, /* (361) in_predicate_value ::= NK_LP expression_list NK_RP */ - 323, /* (362) boolean_value_expression ::= boolean_primary */ - 323, /* (363) boolean_value_expression ::= NOT boolean_primary */ - 323, /* (364) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ - 323, /* (365) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ - 324, /* (366) boolean_primary ::= predicate */ - 324, /* (367) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ - 325, /* (368) common_expression ::= expression */ - 325, /* (369) common_expression ::= boolean_value_expression */ - 326, /* (370) from_clause ::= FROM table_reference_list */ - 327, /* (371) table_reference_list ::= table_reference */ - 327, /* (372) table_reference_list ::= table_reference_list NK_COMMA table_reference */ - 328, /* (373) table_reference ::= table_primary */ - 328, /* (374) table_reference ::= joined_table */ - 329, /* (375) table_primary ::= table_name alias_opt */ - 329, /* (376) table_primary ::= db_name NK_DOT table_name alias_opt */ - 329, /* (377) table_primary ::= subquery alias_opt */ - 329, /* (378) table_primary ::= parenthesized_joined_table */ - 331, /* (379) alias_opt ::= */ - 331, /* (380) alias_opt ::= table_alias */ - 331, /* (381) alias_opt ::= AS table_alias */ - 332, /* (382) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - 332, /* (383) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ - 330, /* (384) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ - 333, /* (385) join_type ::= */ - 333, /* (386) join_type ::= INNER */ - 335, /* (387) query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ - 336, /* (388) set_quantifier_opt ::= */ - 336, /* (389) set_quantifier_opt ::= DISTINCT */ - 336, /* (390) set_quantifier_opt ::= ALL */ - 337, /* (391) select_list ::= NK_STAR */ - 337, /* (392) select_list ::= select_sublist */ - 343, /* (393) select_sublist ::= select_item */ - 343, /* (394) select_sublist ::= select_sublist NK_COMMA select_item */ - 344, /* (395) select_item ::= common_expression */ - 344, /* (396) select_item ::= common_expression column_alias */ - 344, /* (397) select_item ::= common_expression AS column_alias */ - 344, /* (398) select_item ::= table_name NK_DOT NK_STAR */ - 338, /* (399) where_clause_opt ::= */ - 338, /* (400) where_clause_opt ::= WHERE search_condition */ - 339, /* (401) partition_by_clause_opt ::= */ - 339, /* (402) partition_by_clause_opt ::= PARTITION BY expression_list */ - 340, /* (403) twindow_clause_opt ::= */ - 340, /* (404) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ - 340, /* (405) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */ - 340, /* (406) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ - 340, /* (407) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ - 291, /* (408) sliding_opt ::= */ - 291, /* (409) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ - 345, /* (410) fill_opt ::= */ - 345, /* (411) fill_opt ::= FILL NK_LP fill_mode NK_RP */ - 345, /* (412) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ - 346, /* (413) fill_mode ::= NONE */ - 346, /* (414) fill_mode ::= PREV */ - 346, /* (415) fill_mode ::= NULL */ - 346, /* (416) fill_mode ::= LINEAR */ - 346, /* (417) fill_mode ::= NEXT */ - 341, /* (418) group_by_clause_opt ::= */ - 341, /* (419) group_by_clause_opt ::= GROUP BY group_by_list */ - 347, /* (420) group_by_list ::= expression */ - 347, /* (421) group_by_list ::= group_by_list NK_COMMA expression */ - 342, /* (422) having_clause_opt ::= */ - 342, /* (423) having_clause_opt ::= HAVING search_condition */ - 295, /* (424) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ - 348, /* (425) query_expression_body ::= query_primary */ - 348, /* (426) query_expression_body ::= query_expression_body UNION ALL query_expression_body */ - 348, /* (427) query_expression_body ::= query_expression_body UNION query_expression_body */ - 352, /* (428) query_primary ::= query_specification */ - 352, /* (429) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */ - 349, /* (430) order_by_clause_opt ::= */ - 349, /* (431) order_by_clause_opt ::= ORDER BY sort_specification_list */ - 350, /* (432) slimit_clause_opt ::= */ - 350, /* (433) slimit_clause_opt ::= SLIMIT NK_INTEGER */ - 350, /* (434) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - 350, /* (435) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - 351, /* (436) limit_clause_opt ::= */ - 351, /* (437) limit_clause_opt ::= LIMIT NK_INTEGER */ - 351, /* (438) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ - 351, /* (439) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - 313, /* (440) subquery ::= NK_LP query_expression NK_RP */ - 334, /* (441) search_condition ::= common_expression */ - 353, /* (442) sort_specification_list ::= sort_specification */ - 353, /* (443) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ - 354, /* (444) sort_specification ::= expression ordering_specification_opt null_ordering_opt */ - 355, /* (445) ordering_specification_opt ::= */ - 355, /* (446) ordering_specification_opt ::= ASC */ - 355, /* (447) ordering_specification_opt ::= DESC */ - 356, /* (448) null_ordering_opt ::= */ - 356, /* (449) null_ordering_opt ::= NULLS FIRST */ - 356, /* (450) null_ordering_opt ::= NULLS LAST */ -}; - -/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number -** of symbols on the right-hand side of that rule. */ -static const signed char yyRuleInfoNRhs[] = { - -6, /* (0) cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */ - -4, /* (1) cmd ::= ALTER ACCOUNT NK_ID alter_account_options */ - 0, /* (2) account_options ::= */ - -3, /* (3) account_options ::= account_options PPS literal */ - -3, /* (4) account_options ::= account_options TSERIES literal */ - -3, /* (5) account_options ::= account_options STORAGE literal */ - -3, /* (6) account_options ::= account_options STREAMS literal */ - -3, /* (7) account_options ::= account_options QTIME literal */ - -3, /* (8) account_options ::= account_options DBS literal */ - -3, /* (9) account_options ::= account_options USERS literal */ - -3, /* (10) account_options ::= account_options CONNS literal */ - -3, /* (11) account_options ::= account_options STATE literal */ - -1, /* (12) alter_account_options ::= alter_account_option */ - -2, /* (13) alter_account_options ::= alter_account_options alter_account_option */ - -2, /* (14) alter_account_option ::= PASS literal */ - -2, /* (15) alter_account_option ::= PPS literal */ - -2, /* (16) alter_account_option ::= TSERIES literal */ - -2, /* (17) alter_account_option ::= STORAGE literal */ - -2, /* (18) alter_account_option ::= STREAMS literal */ - -2, /* (19) alter_account_option ::= QTIME literal */ - -2, /* (20) alter_account_option ::= DBS literal */ - -2, /* (21) alter_account_option ::= USERS literal */ - -2, /* (22) alter_account_option ::= CONNS literal */ - -2, /* (23) alter_account_option ::= STATE literal */ - -5, /* (24) cmd ::= CREATE USER user_name PASS NK_STRING */ - -5, /* (25) cmd ::= ALTER USER user_name PASS NK_STRING */ - -5, /* (26) cmd ::= ALTER USER user_name PRIVILEGE NK_STRING */ - -3, /* (27) cmd ::= DROP USER user_name */ - -6, /* (28) cmd ::= GRANT privileges ON priv_level TO user_name */ - -6, /* (29) cmd ::= REVOKE privileges ON priv_level FROM user_name */ - -1, /* (30) privileges ::= ALL */ - -1, /* (31) privileges ::= priv_type_list */ - -1, /* (32) priv_type_list ::= priv_type */ - -3, /* (33) priv_type_list ::= priv_type_list NK_COMMA priv_type */ - -1, /* (34) priv_type ::= READ */ - -1, /* (35) priv_type ::= WRITE */ - -3, /* (36) priv_level ::= NK_STAR NK_DOT NK_STAR */ - -3, /* (37) priv_level ::= db_name NK_DOT NK_STAR */ - -3, /* (38) cmd ::= CREATE DNODE dnode_endpoint */ - -5, /* (39) cmd ::= CREATE DNODE dnode_host_name PORT NK_INTEGER */ - -3, /* (40) cmd ::= DROP DNODE NK_INTEGER */ - -3, /* (41) cmd ::= DROP DNODE dnode_endpoint */ - -4, /* (42) cmd ::= ALTER DNODE NK_INTEGER NK_STRING */ - -5, /* (43) cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */ - -4, /* (44) cmd ::= ALTER ALL DNODES NK_STRING */ - -5, /* (45) cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */ - -1, /* (46) dnode_endpoint ::= NK_STRING */ - -1, /* (47) dnode_host_name ::= NK_ID */ - -1, /* (48) dnode_host_name ::= NK_IPTOKEN */ - -3, /* (49) cmd ::= ALTER LOCAL NK_STRING */ - -4, /* (50) cmd ::= ALTER LOCAL NK_STRING NK_STRING */ - -5, /* (51) cmd ::= CREATE QNODE ON DNODE NK_INTEGER */ - -5, /* (52) cmd ::= DROP QNODE ON DNODE NK_INTEGER */ - -5, /* (53) cmd ::= CREATE BNODE ON DNODE NK_INTEGER */ - -5, /* (54) cmd ::= DROP BNODE ON DNODE NK_INTEGER */ - -5, /* (55) cmd ::= CREATE SNODE ON DNODE NK_INTEGER */ - -5, /* (56) cmd ::= DROP SNODE ON DNODE NK_INTEGER */ - -5, /* (57) cmd ::= CREATE MNODE ON DNODE NK_INTEGER */ - -5, /* (58) cmd ::= DROP MNODE ON DNODE NK_INTEGER */ - -5, /* (59) cmd ::= CREATE DATABASE not_exists_opt db_name db_options */ - -4, /* (60) cmd ::= DROP DATABASE exists_opt db_name */ - -2, /* (61) cmd ::= USE db_name */ - -4, /* (62) cmd ::= ALTER DATABASE db_name alter_db_options */ - -3, /* (63) not_exists_opt ::= IF NOT EXISTS */ - 0, /* (64) not_exists_opt ::= */ - -2, /* (65) exists_opt ::= IF EXISTS */ - 0, /* (66) exists_opt ::= */ - 0, /* (67) db_options ::= */ - -3, /* (68) db_options ::= db_options BUFFER NK_INTEGER */ - -3, /* (69) db_options ::= db_options CACHELAST NK_INTEGER */ - -3, /* (70) db_options ::= db_options COMP NK_INTEGER */ - -3, /* (71) db_options ::= db_options DAYS NK_INTEGER */ - -3, /* (72) db_options ::= db_options DAYS NK_VARIABLE */ - -3, /* (73) db_options ::= db_options FSYNC NK_INTEGER */ - -3, /* (74) db_options ::= db_options MAXROWS NK_INTEGER */ - -3, /* (75) db_options ::= db_options MINROWS NK_INTEGER */ - -3, /* (76) db_options ::= db_options KEEP integer_list */ - -3, /* (77) db_options ::= db_options KEEP variable_list */ - -3, /* (78) db_options ::= db_options PAGES NK_INTEGER */ - -3, /* (79) db_options ::= db_options PAGESIZE NK_INTEGER */ - -3, /* (80) db_options ::= db_options PRECISION NK_STRING */ - -3, /* (81) db_options ::= db_options REPLICA NK_INTEGER */ - -3, /* (82) db_options ::= db_options STRICT NK_INTEGER */ - -3, /* (83) db_options ::= db_options WAL NK_INTEGER */ - -3, /* (84) db_options ::= db_options VGROUPS NK_INTEGER */ - -3, /* (85) db_options ::= db_options SINGLE_STABLE NK_INTEGER */ - -3, /* (86) db_options ::= db_options RETENTIONS retention_list */ - -3, /* (87) db_options ::= db_options SCHEMALESS NK_INTEGER */ - -1, /* (88) alter_db_options ::= alter_db_option */ - -2, /* (89) alter_db_options ::= alter_db_options alter_db_option */ - -2, /* (90) alter_db_option ::= BUFFER NK_INTEGER */ - -2, /* (91) alter_db_option ::= CACHELAST NK_INTEGER */ - -2, /* (92) alter_db_option ::= FSYNC NK_INTEGER */ - -2, /* (93) alter_db_option ::= KEEP integer_list */ - -2, /* (94) alter_db_option ::= KEEP variable_list */ - -2, /* (95) alter_db_option ::= PAGES NK_INTEGER */ - -2, /* (96) alter_db_option ::= REPLICA NK_INTEGER */ - -2, /* (97) alter_db_option ::= STRICT NK_INTEGER */ - -2, /* (98) alter_db_option ::= WAL NK_INTEGER */ - -1, /* (99) integer_list ::= NK_INTEGER */ - -3, /* (100) integer_list ::= integer_list NK_COMMA NK_INTEGER */ - -1, /* (101) variable_list ::= NK_VARIABLE */ - -3, /* (102) variable_list ::= variable_list NK_COMMA NK_VARIABLE */ - -1, /* (103) retention_list ::= retention */ - -3, /* (104) retention_list ::= retention_list NK_COMMA retention */ - -3, /* (105) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ - -9, /* (106) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ - -3, /* (107) cmd ::= CREATE TABLE multi_create_clause */ - -9, /* (108) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ - -3, /* (109) cmd ::= DROP TABLE multi_drop_clause */ - -4, /* (110) cmd ::= DROP STABLE exists_opt full_table_name */ - -3, /* (111) cmd ::= ALTER TABLE alter_table_clause */ - -3, /* (112) cmd ::= ALTER STABLE alter_table_clause */ - -2, /* (113) alter_table_clause ::= full_table_name alter_table_options */ - -5, /* (114) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ - -4, /* (115) alter_table_clause ::= full_table_name DROP COLUMN column_name */ - -5, /* (116) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ - -5, /* (117) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ - -5, /* (118) alter_table_clause ::= full_table_name ADD TAG column_name type_name */ - -4, /* (119) alter_table_clause ::= full_table_name DROP TAG column_name */ - -5, /* (120) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ - -5, /* (121) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ - -6, /* (122) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ - -1, /* (123) multi_create_clause ::= create_subtable_clause */ - -2, /* (124) multi_create_clause ::= multi_create_clause create_subtable_clause */ - -10, /* (125) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP literal_list NK_RP table_options */ - -1, /* (126) multi_drop_clause ::= drop_table_clause */ - -2, /* (127) multi_drop_clause ::= multi_drop_clause drop_table_clause */ - -2, /* (128) drop_table_clause ::= exists_opt full_table_name */ - 0, /* (129) specific_tags_opt ::= */ - -3, /* (130) specific_tags_opt ::= NK_LP col_name_list NK_RP */ - -1, /* (131) full_table_name ::= table_name */ - -3, /* (132) full_table_name ::= db_name NK_DOT table_name */ - -1, /* (133) column_def_list ::= column_def */ - -3, /* (134) column_def_list ::= column_def_list NK_COMMA column_def */ - -2, /* (135) column_def ::= column_name type_name */ - -4, /* (136) column_def ::= column_name type_name COMMENT NK_STRING */ - -1, /* (137) type_name ::= BOOL */ - -1, /* (138) type_name ::= TINYINT */ - -1, /* (139) type_name ::= SMALLINT */ - -1, /* (140) type_name ::= INT */ - -1, /* (141) type_name ::= INTEGER */ - -1, /* (142) type_name ::= BIGINT */ - -1, /* (143) type_name ::= FLOAT */ - -1, /* (144) type_name ::= DOUBLE */ - -4, /* (145) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ - -1, /* (146) type_name ::= TIMESTAMP */ - -4, /* (147) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ - -2, /* (148) type_name ::= TINYINT UNSIGNED */ - -2, /* (149) type_name ::= SMALLINT UNSIGNED */ - -2, /* (150) type_name ::= INT UNSIGNED */ - -2, /* (151) type_name ::= BIGINT UNSIGNED */ - -1, /* (152) type_name ::= JSON */ - -4, /* (153) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ - -1, /* (154) type_name ::= MEDIUMBLOB */ - -1, /* (155) type_name ::= BLOB */ - -4, /* (156) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ - -1, /* (157) type_name ::= DECIMAL */ - -4, /* (158) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ - -6, /* (159) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ - 0, /* (160) tags_def_opt ::= */ - -1, /* (161) tags_def_opt ::= tags_def */ - -4, /* (162) tags_def ::= TAGS NK_LP column_def_list NK_RP */ - 0, /* (163) table_options ::= */ - -3, /* (164) table_options ::= table_options COMMENT NK_STRING */ - -3, /* (165) table_options ::= table_options FILE_FACTOR NK_FLOAT */ - -5, /* (166) table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP */ - -3, /* (167) table_options ::= table_options TTL NK_INTEGER */ - -5, /* (168) table_options ::= table_options SMA NK_LP col_name_list NK_RP */ - -1, /* (169) alter_table_options ::= alter_table_option */ - -2, /* (170) alter_table_options ::= alter_table_options alter_table_option */ - -2, /* (171) alter_table_option ::= COMMENT NK_STRING */ - -2, /* (172) alter_table_option ::= TTL NK_INTEGER */ - -1, /* (173) col_name_list ::= col_name */ - -3, /* (174) col_name_list ::= col_name_list NK_COMMA col_name */ - -1, /* (175) col_name ::= column_name */ - -2, /* (176) cmd ::= SHOW DNODES */ - -2, /* (177) cmd ::= SHOW USERS */ - -2, /* (178) cmd ::= SHOW DATABASES */ - -4, /* (179) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */ - -4, /* (180) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ - -3, /* (181) cmd ::= SHOW db_name_cond_opt VGROUPS */ - -2, /* (182) cmd ::= SHOW MNODES */ - -2, /* (183) cmd ::= SHOW MODULES */ - -2, /* (184) cmd ::= SHOW QNODES */ - -2, /* (185) cmd ::= SHOW FUNCTIONS */ - -5, /* (186) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ - -2, /* (187) cmd ::= SHOW STREAMS */ - -2, /* (188) cmd ::= SHOW ACCOUNTS */ - -2, /* (189) cmd ::= SHOW APPS */ - -2, /* (190) cmd ::= SHOW CONNECTIONS */ - -2, /* (191) cmd ::= SHOW LICENCE */ - -2, /* (192) cmd ::= SHOW GRANTS */ - -4, /* (193) cmd ::= SHOW CREATE DATABASE db_name */ - -4, /* (194) cmd ::= SHOW CREATE TABLE full_table_name */ - -4, /* (195) cmd ::= SHOW CREATE STABLE full_table_name */ - -2, /* (196) cmd ::= SHOW QUERIES */ - -2, /* (197) cmd ::= SHOW SCORES */ - -2, /* (198) cmd ::= SHOW TOPICS */ - -2, /* (199) cmd ::= SHOW VARIABLES */ - -2, /* (200) cmd ::= SHOW BNODES */ - -2, /* (201) cmd ::= SHOW SNODES */ - -2, /* (202) cmd ::= SHOW CLUSTER */ - -2, /* (203) cmd ::= SHOW TRANSACTIONS */ - 0, /* (204) db_name_cond_opt ::= */ - -2, /* (205) db_name_cond_opt ::= db_name NK_DOT */ - 0, /* (206) like_pattern_opt ::= */ - -2, /* (207) like_pattern_opt ::= LIKE NK_STRING */ - -1, /* (208) table_name_cond ::= table_name */ - 0, /* (209) from_db_opt ::= */ - -2, /* (210) from_db_opt ::= FROM db_name */ - -1, /* (211) func_name_list ::= func_name */ - -3, /* (212) func_name_list ::= func_name_list NK_COMMA func_name */ - -1, /* (213) func_name ::= function_name */ - -8, /* (214) cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options */ - -10, /* (215) cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP */ - -6, /* (216) cmd ::= DROP INDEX exists_opt index_name ON table_name */ - 0, /* (217) index_options ::= */ - -9, /* (218) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt */ - -11, /* (219) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt */ - -1, /* (220) func_list ::= func */ - -3, /* (221) func_list ::= func_list NK_COMMA func */ - -4, /* (222) func ::= function_name NK_LP expression_list NK_RP */ - -6, /* (223) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression */ - -7, /* (224) cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name */ - -7, /* (225) cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name */ - -4, /* (226) cmd ::= DROP TOPIC exists_opt topic_name */ - -7, /* (227) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ - -2, /* (228) cmd ::= DESC full_table_name */ - -2, /* (229) cmd ::= DESCRIBE full_table_name */ - -3, /* (230) cmd ::= RESET QUERY CACHE */ - -4, /* (231) cmd ::= EXPLAIN analyze_opt explain_options query_expression */ - 0, /* (232) analyze_opt ::= */ - -1, /* (233) analyze_opt ::= ANALYZE */ - 0, /* (234) explain_options ::= */ - -3, /* (235) explain_options ::= explain_options VERBOSE NK_BOOL */ - -3, /* (236) explain_options ::= explain_options RATIO NK_FLOAT */ - -6, /* (237) cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP */ - -10, /* (238) cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */ - -4, /* (239) cmd ::= DROP FUNCTION exists_opt function_name */ - 0, /* (240) agg_func_opt ::= */ - -1, /* (241) agg_func_opt ::= AGGREGATE */ - 0, /* (242) bufsize_opt ::= */ - -2, /* (243) bufsize_opt ::= BUFSIZE NK_INTEGER */ - -8, /* (244) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression */ - -4, /* (245) cmd ::= DROP STREAM exists_opt stream_name */ - 0, /* (246) into_opt ::= */ - -2, /* (247) into_opt ::= INTO full_table_name */ - 0, /* (248) stream_options ::= */ - -3, /* (249) stream_options ::= stream_options TRIGGER AT_ONCE */ - -3, /* (250) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ - -3, /* (251) stream_options ::= stream_options WATERMARK duration_literal */ - -3, /* (252) cmd ::= KILL CONNECTION NK_INTEGER */ - -3, /* (253) cmd ::= KILL QUERY NK_INTEGER */ - -3, /* (254) cmd ::= KILL TRANSACTION NK_INTEGER */ - -4, /* (255) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ - -4, /* (256) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ - -3, /* (257) cmd ::= SPLIT VGROUP NK_INTEGER */ - -2, /* (258) dnode_list ::= DNODE NK_INTEGER */ - -3, /* (259) dnode_list ::= dnode_list DNODE NK_INTEGER */ - -3, /* (260) cmd ::= SYNCDB db_name REPLICA */ - -1, /* (261) cmd ::= query_expression */ - -1, /* (262) literal ::= NK_INTEGER */ - -1, /* (263) literal ::= NK_FLOAT */ - -1, /* (264) literal ::= NK_STRING */ - -1, /* (265) literal ::= NK_BOOL */ - -2, /* (266) literal ::= TIMESTAMP NK_STRING */ - -1, /* (267) literal ::= duration_literal */ - -1, /* (268) literal ::= NULL */ - -1, /* (269) literal ::= NK_QUESTION */ - -1, /* (270) duration_literal ::= NK_VARIABLE */ - -1, /* (271) signed ::= NK_INTEGER */ - -2, /* (272) signed ::= NK_PLUS NK_INTEGER */ - -2, /* (273) signed ::= NK_MINUS NK_INTEGER */ - -1, /* (274) signed ::= NK_FLOAT */ - -2, /* (275) signed ::= NK_PLUS NK_FLOAT */ - -2, /* (276) signed ::= NK_MINUS NK_FLOAT */ - -1, /* (277) signed_literal ::= signed */ - -1, /* (278) signed_literal ::= NK_STRING */ - -1, /* (279) signed_literal ::= NK_BOOL */ - -2, /* (280) signed_literal ::= TIMESTAMP NK_STRING */ - -1, /* (281) signed_literal ::= duration_literal */ - -1, /* (282) signed_literal ::= NULL */ - -1, /* (283) signed_literal ::= literal_func */ - -1, /* (284) literal_list ::= signed_literal */ - -3, /* (285) literal_list ::= literal_list NK_COMMA signed_literal */ - -1, /* (286) db_name ::= NK_ID */ - -1, /* (287) table_name ::= NK_ID */ - -1, /* (288) column_name ::= NK_ID */ - -1, /* (289) function_name ::= NK_ID */ - -1, /* (290) table_alias ::= NK_ID */ - -1, /* (291) column_alias ::= NK_ID */ - -1, /* (292) user_name ::= NK_ID */ - -1, /* (293) index_name ::= NK_ID */ - -1, /* (294) topic_name ::= NK_ID */ - -1, /* (295) stream_name ::= NK_ID */ - -1, /* (296) cgroup_name ::= NK_ID */ - -1, /* (297) expression ::= literal */ - -1, /* (298) expression ::= pseudo_column */ - -1, /* (299) expression ::= column_reference */ - -1, /* (300) expression ::= function_expression */ - -1, /* (301) expression ::= subquery */ - -3, /* (302) expression ::= NK_LP expression NK_RP */ - -2, /* (303) expression ::= NK_PLUS expression */ - -2, /* (304) expression ::= NK_MINUS expression */ - -3, /* (305) expression ::= expression NK_PLUS expression */ - -3, /* (306) expression ::= expression NK_MINUS expression */ - -3, /* (307) expression ::= expression NK_STAR expression */ - -3, /* (308) expression ::= expression NK_SLASH expression */ - -3, /* (309) expression ::= expression NK_REM expression */ - -3, /* (310) expression ::= column_reference NK_ARROW NK_STRING */ - -1, /* (311) expression_list ::= expression */ - -3, /* (312) expression_list ::= expression_list NK_COMMA expression */ - -1, /* (313) column_reference ::= column_name */ - -3, /* (314) column_reference ::= table_name NK_DOT column_name */ - -1, /* (315) pseudo_column ::= ROWTS */ - -1, /* (316) pseudo_column ::= TBNAME */ - -3, /* (317) pseudo_column ::= table_name NK_DOT TBNAME */ - -1, /* (318) pseudo_column ::= QSTARTTS */ - -1, /* (319) pseudo_column ::= QENDTS */ - -1, /* (320) pseudo_column ::= WSTARTTS */ - -1, /* (321) pseudo_column ::= WENDTS */ - -1, /* (322) pseudo_column ::= WDURATION */ - -4, /* (323) function_expression ::= function_name NK_LP expression_list NK_RP */ - -4, /* (324) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ - -6, /* (325) function_expression ::= CAST NK_LP expression AS type_name NK_RP */ - -1, /* (326) function_expression ::= literal_func */ - -3, /* (327) literal_func ::= noarg_func NK_LP NK_RP */ - -1, /* (328) literal_func ::= NOW */ - -1, /* (329) noarg_func ::= NOW */ - -1, /* (330) noarg_func ::= TODAY */ - -1, /* (331) noarg_func ::= TIMEZONE */ - -1, /* (332) star_func ::= COUNT */ - -1, /* (333) star_func ::= FIRST */ - -1, /* (334) star_func ::= LAST */ - -1, /* (335) star_func ::= LAST_ROW */ - -1, /* (336) star_func_para_list ::= NK_STAR */ - -1, /* (337) star_func_para_list ::= other_para_list */ - -1, /* (338) other_para_list ::= star_func_para */ - -3, /* (339) other_para_list ::= other_para_list NK_COMMA star_func_para */ - -1, /* (340) star_func_para ::= expression */ - -3, /* (341) star_func_para ::= table_name NK_DOT NK_STAR */ - -3, /* (342) predicate ::= expression compare_op expression */ - -5, /* (343) predicate ::= expression BETWEEN expression AND expression */ - -6, /* (344) predicate ::= expression NOT BETWEEN expression AND expression */ - -3, /* (345) predicate ::= expression IS NULL */ - -4, /* (346) predicate ::= expression IS NOT NULL */ - -3, /* (347) predicate ::= expression in_op in_predicate_value */ - -1, /* (348) compare_op ::= NK_LT */ - -1, /* (349) compare_op ::= NK_GT */ - -1, /* (350) compare_op ::= NK_LE */ - -1, /* (351) compare_op ::= NK_GE */ - -1, /* (352) compare_op ::= NK_NE */ - -1, /* (353) compare_op ::= NK_EQ */ - -1, /* (354) compare_op ::= LIKE */ - -2, /* (355) compare_op ::= NOT LIKE */ - -1, /* (356) compare_op ::= MATCH */ - -1, /* (357) compare_op ::= NMATCH */ - -1, /* (358) compare_op ::= CONTAINS */ - -1, /* (359) in_op ::= IN */ - -2, /* (360) in_op ::= NOT IN */ - -3, /* (361) in_predicate_value ::= NK_LP expression_list NK_RP */ - -1, /* (362) boolean_value_expression ::= boolean_primary */ - -2, /* (363) boolean_value_expression ::= NOT boolean_primary */ - -3, /* (364) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ - -3, /* (365) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ - -1, /* (366) boolean_primary ::= predicate */ - -3, /* (367) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ - -1, /* (368) common_expression ::= expression */ - -1, /* (369) common_expression ::= boolean_value_expression */ - -2, /* (370) from_clause ::= FROM table_reference_list */ - -1, /* (371) table_reference_list ::= table_reference */ - -3, /* (372) table_reference_list ::= table_reference_list NK_COMMA table_reference */ - -1, /* (373) table_reference ::= table_primary */ - -1, /* (374) table_reference ::= joined_table */ - -2, /* (375) table_primary ::= table_name alias_opt */ - -4, /* (376) table_primary ::= db_name NK_DOT table_name alias_opt */ - -2, /* (377) table_primary ::= subquery alias_opt */ - -1, /* (378) table_primary ::= parenthesized_joined_table */ - 0, /* (379) alias_opt ::= */ - -1, /* (380) alias_opt ::= table_alias */ - -2, /* (381) alias_opt ::= AS table_alias */ - -3, /* (382) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - -3, /* (383) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ - -6, /* (384) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ - 0, /* (385) join_type ::= */ - -1, /* (386) join_type ::= INNER */ - -9, /* (387) query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ - 0, /* (388) set_quantifier_opt ::= */ - -1, /* (389) set_quantifier_opt ::= DISTINCT */ - -1, /* (390) set_quantifier_opt ::= ALL */ - -1, /* (391) select_list ::= NK_STAR */ - -1, /* (392) select_list ::= select_sublist */ - -1, /* (393) select_sublist ::= select_item */ - -3, /* (394) select_sublist ::= select_sublist NK_COMMA select_item */ - -1, /* (395) select_item ::= common_expression */ - -2, /* (396) select_item ::= common_expression column_alias */ - -3, /* (397) select_item ::= common_expression AS column_alias */ - -3, /* (398) select_item ::= table_name NK_DOT NK_STAR */ - 0, /* (399) where_clause_opt ::= */ - -2, /* (400) where_clause_opt ::= WHERE search_condition */ - 0, /* (401) partition_by_clause_opt ::= */ - -3, /* (402) partition_by_clause_opt ::= PARTITION BY expression_list */ - 0, /* (403) twindow_clause_opt ::= */ - -6, /* (404) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ - -4, /* (405) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */ - -6, /* (406) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ - -8, /* (407) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ - 0, /* (408) sliding_opt ::= */ - -4, /* (409) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ - 0, /* (410) fill_opt ::= */ - -4, /* (411) fill_opt ::= FILL NK_LP fill_mode NK_RP */ - -6, /* (412) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ - -1, /* (413) fill_mode ::= NONE */ - -1, /* (414) fill_mode ::= PREV */ - -1, /* (415) fill_mode ::= NULL */ - -1, /* (416) fill_mode ::= LINEAR */ - -1, /* (417) fill_mode ::= NEXT */ - 0, /* (418) group_by_clause_opt ::= */ - -3, /* (419) group_by_clause_opt ::= GROUP BY group_by_list */ - -1, /* (420) group_by_list ::= expression */ - -3, /* (421) group_by_list ::= group_by_list NK_COMMA expression */ - 0, /* (422) having_clause_opt ::= */ - -2, /* (423) having_clause_opt ::= HAVING search_condition */ - -4, /* (424) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ - -1, /* (425) query_expression_body ::= query_primary */ - -4, /* (426) query_expression_body ::= query_expression_body UNION ALL query_expression_body */ - -3, /* (427) query_expression_body ::= query_expression_body UNION query_expression_body */ - -1, /* (428) query_primary ::= query_specification */ - -6, /* (429) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */ - 0, /* (430) order_by_clause_opt ::= */ - -3, /* (431) order_by_clause_opt ::= ORDER BY sort_specification_list */ - 0, /* (432) slimit_clause_opt ::= */ - -2, /* (433) slimit_clause_opt ::= SLIMIT NK_INTEGER */ - -4, /* (434) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - -4, /* (435) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - 0, /* (436) limit_clause_opt ::= */ - -2, /* (437) limit_clause_opt ::= LIMIT NK_INTEGER */ - -4, /* (438) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ - -4, /* (439) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - -3, /* (440) subquery ::= NK_LP query_expression NK_RP */ - -1, /* (441) search_condition ::= common_expression */ - -1, /* (442) sort_specification_list ::= sort_specification */ - -3, /* (443) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ - -3, /* (444) sort_specification ::= expression ordering_specification_opt null_ordering_opt */ - 0, /* (445) ordering_specification_opt ::= */ - -1, /* (446) ordering_specification_opt ::= ASC */ - -1, /* (447) ordering_specification_opt ::= DESC */ - 0, /* (448) null_ordering_opt ::= */ - -2, /* (449) null_ordering_opt ::= NULLS FIRST */ - -2, /* (450) null_ordering_opt ::= NULLS LAST */ +/* The following table contains information about every rule that +** is used during the reduce. +*/ +static const struct { + YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */ + signed char nrhs; /* Negative of the number of RHS symbols in the rule */ +} yyRuleInfo[] = { + { 237, -6 }, /* (0) cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */ + { 237, -4 }, /* (1) cmd ::= ALTER ACCOUNT NK_ID alter_account_options */ + { 238, 0 }, /* (2) account_options ::= */ + { 238, -3 }, /* (3) account_options ::= account_options PPS literal */ + { 238, -3 }, /* (4) account_options ::= account_options TSERIES literal */ + { 238, -3 }, /* (5) account_options ::= account_options STORAGE literal */ + { 238, -3 }, /* (6) account_options ::= account_options STREAMS literal */ + { 238, -3 }, /* (7) account_options ::= account_options QTIME literal */ + { 238, -3 }, /* (8) account_options ::= account_options DBS literal */ + { 238, -3 }, /* (9) account_options ::= account_options USERS literal */ + { 238, -3 }, /* (10) account_options ::= account_options CONNS literal */ + { 238, -3 }, /* (11) account_options ::= account_options STATE literal */ + { 239, -1 }, /* (12) alter_account_options ::= alter_account_option */ + { 239, -2 }, /* (13) alter_account_options ::= alter_account_options alter_account_option */ + { 241, -2 }, /* (14) alter_account_option ::= PASS literal */ + { 241, -2 }, /* (15) alter_account_option ::= PPS literal */ + { 241, -2 }, /* (16) alter_account_option ::= TSERIES literal */ + { 241, -2 }, /* (17) alter_account_option ::= STORAGE literal */ + { 241, -2 }, /* (18) alter_account_option ::= STREAMS literal */ + { 241, -2 }, /* (19) alter_account_option ::= QTIME literal */ + { 241, -2 }, /* (20) alter_account_option ::= DBS literal */ + { 241, -2 }, /* (21) alter_account_option ::= USERS literal */ + { 241, -2 }, /* (22) alter_account_option ::= CONNS literal */ + { 241, -2 }, /* (23) alter_account_option ::= STATE literal */ + { 237, -5 }, /* (24) cmd ::= CREATE USER user_name PASS NK_STRING */ + { 237, -5 }, /* (25) cmd ::= ALTER USER user_name PASS NK_STRING */ + { 237, -5 }, /* (26) cmd ::= ALTER USER user_name PRIVILEGE NK_STRING */ + { 237, -3 }, /* (27) cmd ::= DROP USER user_name */ + { 237, -6 }, /* (28) cmd ::= GRANT privileges ON priv_level TO user_name */ + { 237, -6 }, /* (29) cmd ::= REVOKE privileges ON priv_level FROM user_name */ + { 243, -1 }, /* (30) privileges ::= ALL */ + { 243, -1 }, /* (31) privileges ::= priv_type_list */ + { 245, -1 }, /* (32) priv_type_list ::= priv_type */ + { 245, -3 }, /* (33) priv_type_list ::= priv_type_list NK_COMMA priv_type */ + { 246, -1 }, /* (34) priv_type ::= READ */ + { 246, -1 }, /* (35) priv_type ::= WRITE */ + { 244, -3 }, /* (36) priv_level ::= NK_STAR NK_DOT NK_STAR */ + { 244, -3 }, /* (37) priv_level ::= db_name NK_DOT NK_STAR */ + { 237, -3 }, /* (38) cmd ::= CREATE DNODE dnode_endpoint */ + { 237, -5 }, /* (39) cmd ::= CREATE DNODE dnode_host_name PORT NK_INTEGER */ + { 237, -3 }, /* (40) cmd ::= DROP DNODE NK_INTEGER */ + { 237, -3 }, /* (41) cmd ::= DROP DNODE dnode_endpoint */ + { 237, -4 }, /* (42) cmd ::= ALTER DNODE NK_INTEGER NK_STRING */ + { 237, -5 }, /* (43) cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */ + { 237, -4 }, /* (44) cmd ::= ALTER ALL DNODES NK_STRING */ + { 237, -5 }, /* (45) cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */ + { 248, -1 }, /* (46) dnode_endpoint ::= NK_STRING */ + { 249, -1 }, /* (47) dnode_host_name ::= NK_ID */ + { 249, -1 }, /* (48) dnode_host_name ::= NK_IPTOKEN */ + { 237, -3 }, /* (49) cmd ::= ALTER LOCAL NK_STRING */ + { 237, -4 }, /* (50) cmd ::= ALTER LOCAL NK_STRING NK_STRING */ + { 237, -5 }, /* (51) cmd ::= CREATE QNODE ON DNODE NK_INTEGER */ + { 237, -5 }, /* (52) cmd ::= DROP QNODE ON DNODE NK_INTEGER */ + { 237, -5 }, /* (53) cmd ::= CREATE BNODE ON DNODE NK_INTEGER */ + { 237, -5 }, /* (54) cmd ::= DROP BNODE ON DNODE NK_INTEGER */ + { 237, -5 }, /* (55) cmd ::= CREATE SNODE ON DNODE NK_INTEGER */ + { 237, -5 }, /* (56) cmd ::= DROP SNODE ON DNODE NK_INTEGER */ + { 237, -5 }, /* (57) cmd ::= CREATE MNODE ON DNODE NK_INTEGER */ + { 237, -5 }, /* (58) cmd ::= DROP MNODE ON DNODE NK_INTEGER */ + { 237, -5 }, /* (59) cmd ::= CREATE DATABASE not_exists_opt db_name db_options */ + { 237, -4 }, /* (60) cmd ::= DROP DATABASE exists_opt db_name */ + { 237, -2 }, /* (61) cmd ::= USE db_name */ + { 237, -4 }, /* (62) cmd ::= ALTER DATABASE db_name alter_db_options */ + { 250, -3 }, /* (63) not_exists_opt ::= IF NOT EXISTS */ + { 250, 0 }, /* (64) not_exists_opt ::= */ + { 252, -2 }, /* (65) exists_opt ::= IF EXISTS */ + { 252, 0 }, /* (66) exists_opt ::= */ + { 251, 0 }, /* (67) db_options ::= */ + { 251, -3 }, /* (68) db_options ::= db_options BUFFER NK_INTEGER */ + { 251, -3 }, /* (69) db_options ::= db_options CACHELAST NK_INTEGER */ + { 251, -3 }, /* (70) db_options ::= db_options COMP NK_INTEGER */ + { 251, -3 }, /* (71) db_options ::= db_options DAYS NK_INTEGER */ + { 251, -3 }, /* (72) db_options ::= db_options DAYS NK_VARIABLE */ + { 251, -3 }, /* (73) db_options ::= db_options FSYNC NK_INTEGER */ + { 251, -3 }, /* (74) db_options ::= db_options MAXROWS NK_INTEGER */ + { 251, -3 }, /* (75) db_options ::= db_options MINROWS NK_INTEGER */ + { 251, -3 }, /* (76) db_options ::= db_options KEEP integer_list */ + { 251, -3 }, /* (77) db_options ::= db_options KEEP variable_list */ + { 251, -3 }, /* (78) db_options ::= db_options PAGES NK_INTEGER */ + { 251, -3 }, /* (79) db_options ::= db_options PAGESIZE NK_INTEGER */ + { 251, -3 }, /* (80) db_options ::= db_options PRECISION NK_STRING */ + { 251, -3 }, /* (81) db_options ::= db_options REPLICA NK_INTEGER */ + { 251, -3 }, /* (82) db_options ::= db_options STRICT NK_INTEGER */ + { 251, -3 }, /* (83) db_options ::= db_options WAL NK_INTEGER */ + { 251, -3 }, /* (84) db_options ::= db_options VGROUPS NK_INTEGER */ + { 251, -3 }, /* (85) db_options ::= db_options SINGLE_STABLE NK_INTEGER */ + { 251, -3 }, /* (86) db_options ::= db_options RETENTIONS retention_list */ + { 251, -3 }, /* (87) db_options ::= db_options SCHEMALESS NK_INTEGER */ + { 253, -1 }, /* (88) alter_db_options ::= alter_db_option */ + { 253, -2 }, /* (89) alter_db_options ::= alter_db_options alter_db_option */ + { 257, -2 }, /* (90) alter_db_option ::= BUFFER NK_INTEGER */ + { 257, -2 }, /* (91) alter_db_option ::= CACHELAST NK_INTEGER */ + { 257, -2 }, /* (92) alter_db_option ::= FSYNC NK_INTEGER */ + { 257, -2 }, /* (93) alter_db_option ::= KEEP integer_list */ + { 257, -2 }, /* (94) alter_db_option ::= KEEP variable_list */ + { 257, -2 }, /* (95) alter_db_option ::= PAGES NK_INTEGER */ + { 257, -2 }, /* (96) alter_db_option ::= REPLICA NK_INTEGER */ + { 257, -2 }, /* (97) alter_db_option ::= STRICT NK_INTEGER */ + { 257, -2 }, /* (98) alter_db_option ::= WAL NK_INTEGER */ + { 254, -1 }, /* (99) integer_list ::= NK_INTEGER */ + { 254, -3 }, /* (100) integer_list ::= integer_list NK_COMMA NK_INTEGER */ + { 255, -1 }, /* (101) variable_list ::= NK_VARIABLE */ + { 255, -3 }, /* (102) variable_list ::= variable_list NK_COMMA NK_VARIABLE */ + { 256, -1 }, /* (103) retention_list ::= retention */ + { 256, -3 }, /* (104) retention_list ::= retention_list NK_COMMA retention */ + { 258, -3 }, /* (105) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ + { 237, -9 }, /* (106) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ + { 237, -3 }, /* (107) cmd ::= CREATE TABLE multi_create_clause */ + { 237, -9 }, /* (108) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ + { 237, -3 }, /* (109) cmd ::= DROP TABLE multi_drop_clause */ + { 237, -4 }, /* (110) cmd ::= DROP STABLE exists_opt full_table_name */ + { 237, -3 }, /* (111) cmd ::= ALTER TABLE alter_table_clause */ + { 237, -3 }, /* (112) cmd ::= ALTER STABLE alter_table_clause */ + { 266, -2 }, /* (113) alter_table_clause ::= full_table_name alter_table_options */ + { 266, -5 }, /* (114) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ + { 266, -4 }, /* (115) alter_table_clause ::= full_table_name DROP COLUMN column_name */ + { 266, -5 }, /* (116) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ + { 266, -5 }, /* (117) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ + { 266, -5 }, /* (118) alter_table_clause ::= full_table_name ADD TAG column_name type_name */ + { 266, -4 }, /* (119) alter_table_clause ::= full_table_name DROP TAG column_name */ + { 266, -5 }, /* (120) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ + { 266, -5 }, /* (121) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ + { 266, -6 }, /* (122) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ + { 263, -1 }, /* (123) multi_create_clause ::= create_subtable_clause */ + { 263, -2 }, /* (124) multi_create_clause ::= multi_create_clause create_subtable_clause */ + { 271, -10 }, /* (125) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP literal_list NK_RP table_options */ + { 265, -1 }, /* (126) multi_drop_clause ::= drop_table_clause */ + { 265, -2 }, /* (127) multi_drop_clause ::= multi_drop_clause drop_table_clause */ + { 274, -2 }, /* (128) drop_table_clause ::= exists_opt full_table_name */ + { 272, 0 }, /* (129) specific_tags_opt ::= */ + { 272, -3 }, /* (130) specific_tags_opt ::= NK_LP col_name_list NK_RP */ + { 259, -1 }, /* (131) full_table_name ::= table_name */ + { 259, -3 }, /* (132) full_table_name ::= db_name NK_DOT table_name */ + { 260, -1 }, /* (133) column_def_list ::= column_def */ + { 260, -3 }, /* (134) column_def_list ::= column_def_list NK_COMMA column_def */ + { 277, -2 }, /* (135) column_def ::= column_name type_name */ + { 277, -4 }, /* (136) column_def ::= column_name type_name COMMENT NK_STRING */ + { 269, -1 }, /* (137) type_name ::= BOOL */ + { 269, -1 }, /* (138) type_name ::= TINYINT */ + { 269, -1 }, /* (139) type_name ::= SMALLINT */ + { 269, -1 }, /* (140) type_name ::= INT */ + { 269, -1 }, /* (141) type_name ::= INTEGER */ + { 269, -1 }, /* (142) type_name ::= BIGINT */ + { 269, -1 }, /* (143) type_name ::= FLOAT */ + { 269, -1 }, /* (144) type_name ::= DOUBLE */ + { 269, -4 }, /* (145) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ + { 269, -1 }, /* (146) type_name ::= TIMESTAMP */ + { 269, -4 }, /* (147) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ + { 269, -2 }, /* (148) type_name ::= TINYINT UNSIGNED */ + { 269, -2 }, /* (149) type_name ::= SMALLINT UNSIGNED */ + { 269, -2 }, /* (150) type_name ::= INT UNSIGNED */ + { 269, -2 }, /* (151) type_name ::= BIGINT UNSIGNED */ + { 269, -1 }, /* (152) type_name ::= JSON */ + { 269, -4 }, /* (153) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ + { 269, -1 }, /* (154) type_name ::= MEDIUMBLOB */ + { 269, -1 }, /* (155) type_name ::= BLOB */ + { 269, -4 }, /* (156) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ + { 269, -1 }, /* (157) type_name ::= DECIMAL */ + { 269, -4 }, /* (158) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ + { 269, -6 }, /* (159) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ + { 261, 0 }, /* (160) tags_def_opt ::= */ + { 261, -1 }, /* (161) tags_def_opt ::= tags_def */ + { 264, -4 }, /* (162) tags_def ::= TAGS NK_LP column_def_list NK_RP */ + { 262, 0 }, /* (163) table_options ::= */ + { 262, -3 }, /* (164) table_options ::= table_options COMMENT NK_STRING */ + { 262, -3 }, /* (165) table_options ::= table_options FILE_FACTOR NK_FLOAT */ + { 262, -5 }, /* (166) table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP */ + { 262, -3 }, /* (167) table_options ::= table_options TTL NK_INTEGER */ + { 262, -5 }, /* (168) table_options ::= table_options SMA NK_LP col_name_list NK_RP */ + { 267, -1 }, /* (169) alter_table_options ::= alter_table_option */ + { 267, -2 }, /* (170) alter_table_options ::= alter_table_options alter_table_option */ + { 279, -2 }, /* (171) alter_table_option ::= COMMENT NK_STRING */ + { 279, -2 }, /* (172) alter_table_option ::= TTL NK_INTEGER */ + { 275, -1 }, /* (173) col_name_list ::= col_name */ + { 275, -3 }, /* (174) col_name_list ::= col_name_list NK_COMMA col_name */ + { 280, -1 }, /* (175) col_name ::= column_name */ + { 237, -2 }, /* (176) cmd ::= SHOW DNODES */ + { 237, -2 }, /* (177) cmd ::= SHOW USERS */ + { 237, -2 }, /* (178) cmd ::= SHOW DATABASES */ + { 237, -4 }, /* (179) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */ + { 237, -4 }, /* (180) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ + { 237, -3 }, /* (181) cmd ::= SHOW db_name_cond_opt VGROUPS */ + { 237, -2 }, /* (182) cmd ::= SHOW MNODES */ + { 237, -2 }, /* (183) cmd ::= SHOW MODULES */ + { 237, -2 }, /* (184) cmd ::= SHOW QNODES */ + { 237, -2 }, /* (185) cmd ::= SHOW FUNCTIONS */ + { 237, -5 }, /* (186) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ + { 237, -2 }, /* (187) cmd ::= SHOW STREAMS */ + { 237, -2 }, /* (188) cmd ::= SHOW ACCOUNTS */ + { 237, -2 }, /* (189) cmd ::= SHOW APPS */ + { 237, -2 }, /* (190) cmd ::= SHOW CONNECTIONS */ + { 237, -2 }, /* (191) cmd ::= SHOW LICENCE */ + { 237, -2 }, /* (192) cmd ::= SHOW GRANTS */ + { 237, -4 }, /* (193) cmd ::= SHOW CREATE DATABASE db_name */ + { 237, -4 }, /* (194) cmd ::= SHOW CREATE TABLE full_table_name */ + { 237, -4 }, /* (195) cmd ::= SHOW CREATE STABLE full_table_name */ + { 237, -2 }, /* (196) cmd ::= SHOW QUERIES */ + { 237, -2 }, /* (197) cmd ::= SHOW SCORES */ + { 237, -2 }, /* (198) cmd ::= SHOW TOPICS */ + { 237, -2 }, /* (199) cmd ::= SHOW VARIABLES */ + { 237, -2 }, /* (200) cmd ::= SHOW BNODES */ + { 237, -2 }, /* (201) cmd ::= SHOW SNODES */ + { 237, -2 }, /* (202) cmd ::= SHOW CLUSTER */ + { 237, -2 }, /* (203) cmd ::= SHOW TRANSACTIONS */ + { 281, 0 }, /* (204) db_name_cond_opt ::= */ + { 281, -2 }, /* (205) db_name_cond_opt ::= db_name NK_DOT */ + { 282, 0 }, /* (206) like_pattern_opt ::= */ + { 282, -2 }, /* (207) like_pattern_opt ::= LIKE NK_STRING */ + { 283, -1 }, /* (208) table_name_cond ::= table_name */ + { 284, 0 }, /* (209) from_db_opt ::= */ + { 284, -2 }, /* (210) from_db_opt ::= FROM db_name */ + { 278, -1 }, /* (211) func_name_list ::= func_name */ + { 278, -3 }, /* (212) func_name_list ::= func_name_list NK_COMMA func_name */ + { 285, -1 }, /* (213) func_name ::= function_name */ + { 237, -8 }, /* (214) cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options */ + { 237, -10 }, /* (215) cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP */ + { 237, -6 }, /* (216) cmd ::= DROP INDEX exists_opt index_name ON table_name */ + { 288, 0 }, /* (217) index_options ::= */ + { 288, -9 }, /* (218) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt */ + { 288, -11 }, /* (219) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt */ + { 289, -1 }, /* (220) func_list ::= func */ + { 289, -3 }, /* (221) func_list ::= func_list NK_COMMA func */ + { 292, -4 }, /* (222) func ::= function_name NK_LP expression_list NK_RP */ + { 237, -6 }, /* (223) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression */ + { 237, -7 }, /* (224) cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name */ + { 237, -7 }, /* (225) cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name */ + { 237, -4 }, /* (226) cmd ::= DROP TOPIC exists_opt topic_name */ + { 237, -7 }, /* (227) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ + { 237, -2 }, /* (228) cmd ::= DESC full_table_name */ + { 237, -2 }, /* (229) cmd ::= DESCRIBE full_table_name */ + { 237, -3 }, /* (230) cmd ::= RESET QUERY CACHE */ + { 237, -4 }, /* (231) cmd ::= EXPLAIN analyze_opt explain_options query_expression */ + { 297, 0 }, /* (232) analyze_opt ::= */ + { 297, -1 }, /* (233) analyze_opt ::= ANALYZE */ + { 298, 0 }, /* (234) explain_options ::= */ + { 298, -3 }, /* (235) explain_options ::= explain_options VERBOSE NK_BOOL */ + { 298, -3 }, /* (236) explain_options ::= explain_options RATIO NK_FLOAT */ + { 237, -6 }, /* (237) cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP */ + { 237, -10 }, /* (238) cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */ + { 237, -4 }, /* (239) cmd ::= DROP FUNCTION exists_opt function_name */ + { 299, 0 }, /* (240) agg_func_opt ::= */ + { 299, -1 }, /* (241) agg_func_opt ::= AGGREGATE */ + { 300, 0 }, /* (242) bufsize_opt ::= */ + { 300, -2 }, /* (243) bufsize_opt ::= BUFSIZE NK_INTEGER */ + { 237, -8 }, /* (244) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression */ + { 237, -4 }, /* (245) cmd ::= DROP STREAM exists_opt stream_name */ + { 303, 0 }, /* (246) into_opt ::= */ + { 303, -2 }, /* (247) into_opt ::= INTO full_table_name */ + { 302, 0 }, /* (248) stream_options ::= */ + { 302, -3 }, /* (249) stream_options ::= stream_options TRIGGER AT_ONCE */ + { 302, -3 }, /* (250) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ + { 302, -3 }, /* (251) stream_options ::= stream_options WATERMARK duration_literal */ + { 237, -3 }, /* (252) cmd ::= KILL CONNECTION NK_INTEGER */ + { 237, -3 }, /* (253) cmd ::= KILL QUERY NK_INTEGER */ + { 237, -3 }, /* (254) cmd ::= KILL TRANSACTION NK_INTEGER */ + { 237, -4 }, /* (255) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ + { 237, -4 }, /* (256) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ + { 237, -3 }, /* (257) cmd ::= SPLIT VGROUP NK_INTEGER */ + { 304, -2 }, /* (258) dnode_list ::= DNODE NK_INTEGER */ + { 304, -3 }, /* (259) dnode_list ::= dnode_list DNODE NK_INTEGER */ + { 237, -3 }, /* (260) cmd ::= SYNCDB db_name REPLICA */ + { 237, -1 }, /* (261) cmd ::= query_expression */ + { 240, -1 }, /* (262) literal ::= NK_INTEGER */ + { 240, -1 }, /* (263) literal ::= NK_FLOAT */ + { 240, -1 }, /* (264) literal ::= NK_STRING */ + { 240, -1 }, /* (265) literal ::= NK_BOOL */ + { 240, -2 }, /* (266) literal ::= TIMESTAMP NK_STRING */ + { 240, -1 }, /* (267) literal ::= duration_literal */ + { 240, -1 }, /* (268) literal ::= NULL */ + { 240, -1 }, /* (269) literal ::= NK_QUESTION */ + { 290, -1 }, /* (270) duration_literal ::= NK_VARIABLE */ + { 305, -1 }, /* (271) signed ::= NK_INTEGER */ + { 305, -2 }, /* (272) signed ::= NK_PLUS NK_INTEGER */ + { 305, -2 }, /* (273) signed ::= NK_MINUS NK_INTEGER */ + { 305, -1 }, /* (274) signed ::= NK_FLOAT */ + { 305, -2 }, /* (275) signed ::= NK_PLUS NK_FLOAT */ + { 305, -2 }, /* (276) signed ::= NK_MINUS NK_FLOAT */ + { 270, -1 }, /* (277) signed_literal ::= signed */ + { 270, -1 }, /* (278) signed_literal ::= NK_STRING */ + { 270, -1 }, /* (279) signed_literal ::= NK_BOOL */ + { 270, -2 }, /* (280) signed_literal ::= TIMESTAMP NK_STRING */ + { 270, -1 }, /* (281) signed_literal ::= duration_literal */ + { 270, -1 }, /* (282) signed_literal ::= NULL */ + { 270, -1 }, /* (283) signed_literal ::= literal_func */ + { 273, -1 }, /* (284) literal_list ::= signed_literal */ + { 273, -3 }, /* (285) literal_list ::= literal_list NK_COMMA signed_literal */ + { 247, -1 }, /* (286) db_name ::= NK_ID */ + { 276, -1 }, /* (287) table_name ::= NK_ID */ + { 268, -1 }, /* (288) column_name ::= NK_ID */ + { 286, -1 }, /* (289) function_name ::= NK_ID */ + { 307, -1 }, /* (290) table_alias ::= NK_ID */ + { 308, -1 }, /* (291) column_alias ::= NK_ID */ + { 242, -1 }, /* (292) user_name ::= NK_ID */ + { 287, -1 }, /* (293) index_name ::= NK_ID */ + { 294, -1 }, /* (294) topic_name ::= NK_ID */ + { 301, -1 }, /* (295) stream_name ::= NK_ID */ + { 296, -1 }, /* (296) cgroup_name ::= NK_ID */ + { 309, -1 }, /* (297) expression ::= literal */ + { 309, -1 }, /* (298) expression ::= pseudo_column */ + { 309, -1 }, /* (299) expression ::= column_reference */ + { 309, -1 }, /* (300) expression ::= function_expression */ + { 309, -1 }, /* (301) expression ::= subquery */ + { 309, -3 }, /* (302) expression ::= NK_LP expression NK_RP */ + { 309, -2 }, /* (303) expression ::= NK_PLUS expression */ + { 309, -2 }, /* (304) expression ::= NK_MINUS expression */ + { 309, -3 }, /* (305) expression ::= expression NK_PLUS expression */ + { 309, -3 }, /* (306) expression ::= expression NK_MINUS expression */ + { 309, -3 }, /* (307) expression ::= expression NK_STAR expression */ + { 309, -3 }, /* (308) expression ::= expression NK_SLASH expression */ + { 309, -3 }, /* (309) expression ::= expression NK_REM expression */ + { 309, -3 }, /* (310) expression ::= column_reference NK_ARROW NK_STRING */ + { 293, -1 }, /* (311) expression_list ::= expression */ + { 293, -3 }, /* (312) expression_list ::= expression_list NK_COMMA expression */ + { 311, -1 }, /* (313) column_reference ::= column_name */ + { 311, -3 }, /* (314) column_reference ::= table_name NK_DOT column_name */ + { 310, -1 }, /* (315) pseudo_column ::= ROWTS */ + { 310, -1 }, /* (316) pseudo_column ::= TBNAME */ + { 310, -3 }, /* (317) pseudo_column ::= table_name NK_DOT TBNAME */ + { 310, -1 }, /* (318) pseudo_column ::= QSTARTTS */ + { 310, -1 }, /* (319) pseudo_column ::= QENDTS */ + { 310, -1 }, /* (320) pseudo_column ::= WSTARTTS */ + { 310, -1 }, /* (321) pseudo_column ::= WENDTS */ + { 310, -1 }, /* (322) pseudo_column ::= WDURATION */ + { 312, -4 }, /* (323) function_expression ::= function_name NK_LP expression_list NK_RP */ + { 312, -4 }, /* (324) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ + { 312, -6 }, /* (325) function_expression ::= CAST NK_LP expression AS type_name NK_RP */ + { 312, -1 }, /* (326) function_expression ::= literal_func */ + { 306, -3 }, /* (327) literal_func ::= noarg_func NK_LP NK_RP */ + { 306, -1 }, /* (328) literal_func ::= NOW */ + { 316, -1 }, /* (329) noarg_func ::= NOW */ + { 316, -1 }, /* (330) noarg_func ::= TODAY */ + { 316, -1 }, /* (331) noarg_func ::= TIMEZONE */ + { 314, -1 }, /* (332) star_func ::= COUNT */ + { 314, -1 }, /* (333) star_func ::= FIRST */ + { 314, -1 }, /* (334) star_func ::= LAST */ + { 314, -1 }, /* (335) star_func ::= LAST_ROW */ + { 315, -1 }, /* (336) star_func_para_list ::= NK_STAR */ + { 315, -1 }, /* (337) star_func_para_list ::= other_para_list */ + { 317, -1 }, /* (338) other_para_list ::= star_func_para */ + { 317, -3 }, /* (339) other_para_list ::= other_para_list NK_COMMA star_func_para */ + { 318, -1 }, /* (340) star_func_para ::= expression */ + { 318, -3 }, /* (341) star_func_para ::= table_name NK_DOT NK_STAR */ + { 319, -3 }, /* (342) predicate ::= expression compare_op expression */ + { 319, -5 }, /* (343) predicate ::= expression BETWEEN expression AND expression */ + { 319, -6 }, /* (344) predicate ::= expression NOT BETWEEN expression AND expression */ + { 319, -3 }, /* (345) predicate ::= expression IS NULL */ + { 319, -4 }, /* (346) predicate ::= expression IS NOT NULL */ + { 319, -3 }, /* (347) predicate ::= expression in_op in_predicate_value */ + { 320, -1 }, /* (348) compare_op ::= NK_LT */ + { 320, -1 }, /* (349) compare_op ::= NK_GT */ + { 320, -1 }, /* (350) compare_op ::= NK_LE */ + { 320, -1 }, /* (351) compare_op ::= NK_GE */ + { 320, -1 }, /* (352) compare_op ::= NK_NE */ + { 320, -1 }, /* (353) compare_op ::= NK_EQ */ + { 320, -1 }, /* (354) compare_op ::= LIKE */ + { 320, -2 }, /* (355) compare_op ::= NOT LIKE */ + { 320, -1 }, /* (356) compare_op ::= MATCH */ + { 320, -1 }, /* (357) compare_op ::= NMATCH */ + { 320, -1 }, /* (358) compare_op ::= CONTAINS */ + { 321, -1 }, /* (359) in_op ::= IN */ + { 321, -2 }, /* (360) in_op ::= NOT IN */ + { 322, -3 }, /* (361) in_predicate_value ::= NK_LP expression_list NK_RP */ + { 323, -1 }, /* (362) boolean_value_expression ::= boolean_primary */ + { 323, -2 }, /* (363) boolean_value_expression ::= NOT boolean_primary */ + { 323, -3 }, /* (364) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ + { 323, -3 }, /* (365) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ + { 324, -1 }, /* (366) boolean_primary ::= predicate */ + { 324, -3 }, /* (367) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ + { 325, -1 }, /* (368) common_expression ::= expression */ + { 325, -1 }, /* (369) common_expression ::= boolean_value_expression */ + { 326, -2 }, /* (370) from_clause ::= FROM table_reference_list */ + { 327, -1 }, /* (371) table_reference_list ::= table_reference */ + { 327, -3 }, /* (372) table_reference_list ::= table_reference_list NK_COMMA table_reference */ + { 328, -1 }, /* (373) table_reference ::= table_primary */ + { 328, -1 }, /* (374) table_reference ::= joined_table */ + { 329, -2 }, /* (375) table_primary ::= table_name alias_opt */ + { 329, -4 }, /* (376) table_primary ::= db_name NK_DOT table_name alias_opt */ + { 329, -2 }, /* (377) table_primary ::= subquery alias_opt */ + { 329, -1 }, /* (378) table_primary ::= parenthesized_joined_table */ + { 331, 0 }, /* (379) alias_opt ::= */ + { 331, -1 }, /* (380) alias_opt ::= table_alias */ + { 331, -2 }, /* (381) alias_opt ::= AS table_alias */ + { 332, -3 }, /* (382) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ + { 332, -3 }, /* (383) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ + { 330, -6 }, /* (384) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ + { 333, 0 }, /* (385) join_type ::= */ + { 333, -1 }, /* (386) join_type ::= INNER */ + { 335, -9 }, /* (387) query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ + { 336, 0 }, /* (388) set_quantifier_opt ::= */ + { 336, -1 }, /* (389) set_quantifier_opt ::= DISTINCT */ + { 336, -1 }, /* (390) set_quantifier_opt ::= ALL */ + { 337, -1 }, /* (391) select_list ::= NK_STAR */ + { 337, -1 }, /* (392) select_list ::= select_sublist */ + { 343, -1 }, /* (393) select_sublist ::= select_item */ + { 343, -3 }, /* (394) select_sublist ::= select_sublist NK_COMMA select_item */ + { 344, -1 }, /* (395) select_item ::= common_expression */ + { 344, -2 }, /* (396) select_item ::= common_expression column_alias */ + { 344, -3 }, /* (397) select_item ::= common_expression AS column_alias */ + { 344, -3 }, /* (398) select_item ::= table_name NK_DOT NK_STAR */ + { 338, 0 }, /* (399) where_clause_opt ::= */ + { 338, -2 }, /* (400) where_clause_opt ::= WHERE search_condition */ + { 339, 0 }, /* (401) partition_by_clause_opt ::= */ + { 339, -3 }, /* (402) partition_by_clause_opt ::= PARTITION BY expression_list */ + { 340, 0 }, /* (403) twindow_clause_opt ::= */ + { 340, -6 }, /* (404) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ + { 340, -4 }, /* (405) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */ + { 340, -6 }, /* (406) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ + { 340, -8 }, /* (407) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ + { 291, 0 }, /* (408) sliding_opt ::= */ + { 291, -4 }, /* (409) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ + { 345, 0 }, /* (410) fill_opt ::= */ + { 345, -4 }, /* (411) fill_opt ::= FILL NK_LP fill_mode NK_RP */ + { 345, -6 }, /* (412) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ + { 346, -1 }, /* (413) fill_mode ::= NONE */ + { 346, -1 }, /* (414) fill_mode ::= PREV */ + { 346, -1 }, /* (415) fill_mode ::= NULL */ + { 346, -1 }, /* (416) fill_mode ::= LINEAR */ + { 346, -1 }, /* (417) fill_mode ::= NEXT */ + { 341, 0 }, /* (418) group_by_clause_opt ::= */ + { 341, -3 }, /* (419) group_by_clause_opt ::= GROUP BY group_by_list */ + { 347, -1 }, /* (420) group_by_list ::= expression */ + { 347, -3 }, /* (421) group_by_list ::= group_by_list NK_COMMA expression */ + { 342, 0 }, /* (422) having_clause_opt ::= */ + { 342, -2 }, /* (423) having_clause_opt ::= HAVING search_condition */ + { 295, -4 }, /* (424) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ + { 348, -1 }, /* (425) query_expression_body ::= query_primary */ + { 348, -4 }, /* (426) query_expression_body ::= query_expression_body UNION ALL query_expression_body */ + { 348, -3 }, /* (427) query_expression_body ::= query_expression_body UNION query_expression_body */ + { 352, -1 }, /* (428) query_primary ::= query_specification */ + { 352, -6 }, /* (429) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */ + { 349, 0 }, /* (430) order_by_clause_opt ::= */ + { 349, -3 }, /* (431) order_by_clause_opt ::= ORDER BY sort_specification_list */ + { 350, 0 }, /* (432) slimit_clause_opt ::= */ + { 350, -2 }, /* (433) slimit_clause_opt ::= SLIMIT NK_INTEGER */ + { 350, -4 }, /* (434) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + { 350, -4 }, /* (435) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + { 351, 0 }, /* (436) limit_clause_opt ::= */ + { 351, -2 }, /* (437) limit_clause_opt ::= LIMIT NK_INTEGER */ + { 351, -4 }, /* (438) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ + { 351, -4 }, /* (439) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + { 313, -3 }, /* (440) subquery ::= NK_LP query_expression NK_RP */ + { 334, -1 }, /* (441) search_condition ::= common_expression */ + { 353, -1 }, /* (442) sort_specification_list ::= sort_specification */ + { 353, -3 }, /* (443) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ + { 354, -3 }, /* (444) sort_specification ::= expression ordering_specification_opt null_ordering_opt */ + { 355, 0 }, /* (445) ordering_specification_opt ::= */ + { 355, -1 }, /* (446) ordering_specification_opt ::= ASC */ + { 355, -1 }, /* (447) ordering_specification_opt ::= DESC */ + { 356, 0 }, /* (448) null_ordering_opt ::= */ + { 356, -2 }, /* (449) null_ordering_opt ::= NULLS FIRST */ + { 356, -2 }, /* (450) null_ordering_opt ::= NULLS LAST */ }; static void yy_accept(yyParser*); /* Forward Declaration */ @@ -3742,6 +3033,51 @@ static YYACTIONTYPE yy_reduce( (void)yyLookahead; (void)yyLookaheadToken; yymsp = yypParser->yytos; +#ifndef NDEBUG + if( yyTraceFILE && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){ + yysize = yyRuleInfo[yyruleno].nrhs; + if( yysize ){ + fprintf(yyTraceFILE, "%sReduce %d [%s], go to state %d.\n", + yyTracePrompt, + yyruleno, yyRuleName[yyruleno], yymsp[yysize].stateno); + }else{ + fprintf(yyTraceFILE, "%sReduce %d [%s].\n", + yyTracePrompt, yyruleno, yyRuleName[yyruleno]); + } + } +#endif /* NDEBUG */ + + /* Check that the stack is large enough to grow by a single entry + ** if the RHS of the rule is empty. This ensures that there is room + ** enough on the stack to push the LHS value */ + if( yyRuleInfo[yyruleno].nrhs==0 ){ +#ifdef YYTRACKMAXSTACKDEPTH + if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){ + yypParser->yyhwm++; + assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack)); + } +#endif +#if YYSTACKDEPTH>0 + if( yypParser->yytos>=yypParser->yystackEnd ){ + yyStackOverflow(yypParser); + /* The call to yyStackOverflow() above pops the stack until it is + ** empty, causing the main parser loop to exit. So the return value + ** is never used and does not matter. */ + return 0; + } +#else + if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){ + if( yyGrowStack(yypParser) ){ + yyStackOverflow(yypParser); + /* The call to yyStackOverflow() above pops the stack until it is + ** empty, causing the main parser loop to exit. So the return value + ** is never used and does not matter. */ + return 0; + } + yymsp = yypParser->yytos; + } +#endif + } switch( yyruleno ){ /* Beginning here are the reduction cases. A typical example @@ -5070,9 +4406,9 @@ static YYACTIONTYPE yy_reduce( break; /********** End reduce actions ************************************************/ }; - assert( yyrulenoyytos>=yypParser->yystack ); + do{ assert( yyact==yypParser->yytos->stateno ); yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact); if( yyact >= YY_MIN_REDUCE ){ - unsigned int yyruleno = yyact - YY_MIN_REDUCE; /* Reduce by this rule */ -#ifndef NDEBUG - assert( yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ); - if( yyTraceFILE ){ - int yysize = yyRuleInfoNRhs[yyruleno]; - if( yysize ){ - fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n", - yyTracePrompt, - yyruleno, yyRuleName[yyruleno], - yyrulenoyytos[yysize].stateno); - }else{ - fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n", - yyTracePrompt, yyruleno, yyRuleName[yyruleno], - yyrulenoyytos - yypParser->yystack)>yypParser->yyhwm ){ - yypParser->yyhwm++; - assert( yypParser->yyhwm == - (int)(yypParser->yytos - yypParser->yystack)); - } -#endif -#if YYSTACKDEPTH>0 - if( yypParser->yytos>=yypParser->yystackEnd ){ - yyStackOverflow(yypParser); - break; - } -#else - if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){ - if( yyGrowStack(yypParser) ){ - yyStackOverflow(yypParser); - break; - } - } -#endif - } - yyact = yy_reduce(yypParser,yyruleno,yymajor,yyminor ParseCTX_PARAM); + yyact = yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor, + yyminor ParseCTX_PARAM); }else if( yyact <= YY_MAX_SHIFTREDUCE ){ yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor); #ifndef YYNOERRORRECOVERY @@ -5324,13 +4616,14 @@ void Parse( yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion); yymajor = YYNOCODE; }else{ - while( yypParser->yytos > yypParser->yystack ){ - yyact = yy_find_reduce_action(yypParser->yytos->stateno, - YYERRORSYMBOL); - if( yyact<=YY_MAX_SHIFTREDUCE ) break; + while( yypParser->yytos >= yypParser->yystack + && (yyact = yy_find_reduce_action( + yypParser->yytos->stateno, + YYERRORSYMBOL)) > YY_MAX_SHIFTREDUCE + ){ yy_pop_parser_stack(yypParser); } - if( yypParser->yytos <= yypParser->yystack || yymajor==0 ){ + if( yypParser->yytos < yypParser->yystack || yymajor==0 ){ yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); yy_parse_failed(yypParser); #ifndef YYNOERRORRECOVERY @@ -5380,7 +4673,7 @@ void Parse( break; #endif } - } + }while( yypParser->yytos>yypParser->yystack ); #ifndef NDEBUG if( yyTraceFILE ){ yyStackEntry *i; @@ -5402,10 +4695,11 @@ void Parse( */ int ParseFallback(int iToken){ #ifdef YYFALLBACK - assert( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) ); - return yyFallback[iToken]; + if( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) ){ + return yyFallback[iToken]; + } #else (void)iToken; - return 0; #endif + return 0; } From 5344ab10f2400e73be50613a8ceba8bd5cea0d5a Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Tue, 31 May 2022 06:26:46 -0400 Subject: [PATCH 09/14] fix((query): add statecount/stateduration parameter check TD-16160 --- source/libs/function/src/builtins.c | 28 ++++++++++++++++++++++++++-- 1 file changed, 26 insertions(+), 2 deletions(-) diff --git a/source/libs/function/src/builtins.c b/source/libs/function/src/builtins.c index 4725f11715..798b03362c 100644 --- a/source/libs/function/src/builtins.c +++ b/source/libs/function/src/builtins.c @@ -183,7 +183,7 @@ static int32_t translatePercentile(SFunctionNode* pFunc, char* pErrBuf, int32_t return TSDB_CODE_SUCCESS; } -static bool validAperventileAlgo(const SValueNode* pVal) { +static bool validateAperventileAlgo(const SValueNode* pVal) { if (TSDB_DATA_TYPE_BINARY != pVal->node.resType.type) { return false; } @@ -231,7 +231,7 @@ static int32_t translateApercentile(SFunctionNode* pFunc, char* pErrBuf, int32_t } SNode* pParamNode2 = nodesListGetNode(pFunc->pParameterList, 2); - if (QUERY_NODE_VALUE != nodeType(pParamNode2) || !validAperventileAlgo((SValueNode*)pParamNode2)) { + if (QUERY_NODE_VALUE != nodeType(pParamNode2) || !validateAperventileAlgo((SValueNode*)pParamNode2)) { return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR, "Third parameter algorithm of apercentile must be 'default' or 't-digest'"); } @@ -438,6 +438,18 @@ static int32_t translateHLL(SFunctionNode* pFunc, char* pErrBuf, int32_t len) { return TSDB_CODE_SUCCESS; } +static bool validateStateOper(const SValueNode* pVal) { + if (TSDB_DATA_TYPE_BINARY != pVal->node.resType.type) { + return false; + } + return (0 == strcasecmp(varDataVal(pVal->datum.p), "GT") || + 0 == strcasecmp(varDataVal(pVal->datum.p), "GE") || + 0 == strcasecmp(varDataVal(pVal->datum.p), "LT") || + 0 == strcasecmp(varDataVal(pVal->datum.p), "LE") || + 0 == strcasecmp(varDataVal(pVal->datum.p), "EQ") || + 0 == strcasecmp(varDataVal(pVal->datum.p), "NE")); +} + static int32_t translateStateCount(SFunctionNode* pFunc, char* pErrBuf, int32_t len) { int32_t numOfParams = LIST_LENGTH(pFunc->pParameterList); if (3 != numOfParams) { @@ -464,6 +476,12 @@ static int32_t translateStateCount(SFunctionNode* pFunc, char* pErrBuf, int32_t SValueNode* pValue = (SValueNode*)pParamNode; + if (i == 1 && !validateStateOper(pValue)) { + return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR, + "Second parameter of STATECOUNT/STATEDURATION function" + "must be one of the following: 'GE', 'GT', 'LE', 'LT', 'EQ', 'NE'"); + } + pValue->notReserved = true; } @@ -504,6 +522,12 @@ static int32_t translateStateDuration(SFunctionNode* pFunc, char* pErrBuf, int32 SValueNode* pValue = (SValueNode*)pParamNode; + if (i == 1 && !validateStateOper(pValue)) { + return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR, + "Second parameter of STATECOUNT/STATEDURATION function" + "must be one of the following: 'GE', 'GT', 'LE', 'LT', 'EQ', 'NE'"); + } + pValue->notReserved = true; } From 93a3c271689db0faf0ebdc73330d61e6e9148cdb Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Tue, 31 May 2022 06:44:44 -0400 Subject: [PATCH 10/14] fix(query): restrict stateduration function time unit parameter greater than db precision. TD-16171 --- source/libs/function/src/builtins.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/source/libs/function/src/builtins.c b/source/libs/function/src/builtins.c index 798b03362c..d269e59c1e 100644 --- a/source/libs/function/src/builtins.c +++ b/source/libs/function/src/builtins.c @@ -478,7 +478,7 @@ static int32_t translateStateCount(SFunctionNode* pFunc, char* pErrBuf, int32_t if (i == 1 && !validateStateOper(pValue)) { return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR, - "Second parameter of STATECOUNT/STATEDURATION function" + "Second parameter of STATECOUNT function" "must be one of the following: 'GE', 'GT', 'LE', 'LT', 'EQ', 'NE'"); } @@ -524,10 +524,14 @@ static int32_t translateStateDuration(SFunctionNode* pFunc, char* pErrBuf, int32 if (i == 1 && !validateStateOper(pValue)) { return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR, - "Second parameter of STATECOUNT/STATEDURATION function" + "Second parameter of STATEDURATION function" "must be one of the following: 'GE', 'GT', 'LE', 'LT', 'EQ', 'NE'"); + } else if (i == 3 && pValue->datum.i == 0) { + return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR, + "STATEDURATION function time unit parameter should be greater than db precision"); } + pValue->notReserved = true; } From 5a9774b53c138fc12cec6b4c6550a66eab7fc736 Mon Sep 17 00:00:00 2001 From: gccgdb1234 Date: Tue, 31 May 2022 18:50:52 +0800 Subject: [PATCH 11/14] docs: add operator chapter in English --- docs-cn/12-taos-sql/13-operators.md | 2 +- docs-en/12-taos-sql/13-operators.md | 66 +++++++++++++++++++++++++++++ 2 files changed, 67 insertions(+), 1 deletion(-) create mode 100644 docs-en/12-taos-sql/13-operators.md diff --git a/docs-cn/12-taos-sql/13-operators.md b/docs-cn/12-taos-sql/13-operators.md index 65b1a65dcb..1ffc823044 100644 --- a/docs-cn/12-taos-sql/13-operators.md +++ b/docs-cn/12-taos-sql/13-operators.md @@ -21,7 +21,7 @@ title: 运算符 ## JSON 运算符 -`->` 运算符可以对 JSON 类型的列按键取值。->左侧是列标识符,右侧是键的字符串常量,如 col->'name',返回键'name'的值。 +`->` 运算符可以对 JSON 类型的列按键取值。`->` 左侧是列标识符,右侧是键的字符串常量,如 `col->'name'`,返回键 `'name'` 的值。 ## 集合运算符 diff --git a/docs-en/12-taos-sql/13-operators.md b/docs-en/12-taos-sql/13-operators.md new file mode 100644 index 0000000000..2db1397d67 --- /dev/null +++ b/docs-en/12-taos-sql/13-operators.md @@ -0,0 +1,66 @@ +--- +sidebar_label: Operators +title: Operators +--- + +## Arithmetic Operators + +| # | **Operator** | **Data Types** | **Description** | +| --- | :----------: | -------------- | --------------------------------------------------------- | +| 1 | +, - | Numeric Types | Representing positive or negative numbers, unary operator | +| 2 | +, - | Numeric Types | Addition and substraction, binary operator | +| 3 | \*, / | Numeric Types | Multiplication and division, binary oeprator | +| 4 | % | Numeric Types | Taking the remainder, binary operator | + +## Bitwise Operators + +| # | **Operator** | **Data Types** | **Description** | +| --- | :----------: | -------------- | ----------------------------- | +| 1 | & | Numeric Types | Bitewise AND, binary operator | +| 2 | \| | Numeric Types | Bitewise OR, binary operator | + +## JSON Operator + +`->` operator can be used to get the value of a key in a column of JSON type, the left oeprand is the column name, the right operand is a string constant. For example, `col->'name'` returns the value of key `'name'`. + +## Set Operator + +Set operators are used to combine the results of two queries into single result. A query including set operators is called a combined query. The number of rows in each result in a combined query must be same, and the type is determined by the first query's result, the type of the following queriess result must be able to be converted to the type of the first query's result, the conversion rule is same as `CAST` function. + +TDengine provides 2 set operators: `UNION ALL` and `UNION`. `UNION ALL` combines the results without removing duplicate data. `UNION` combines the results and remove duplicate data rows. In single SQL statement, at most 100 set operators can be used. + +## Comparsion Operator + +| # | **Operator** | **Data Types** | **Description** | +| --- | :---------------: | ------------------------------------------------------------------- | ----------------------------------------------- | +| 1 | = | Except for BLOB, MEDIUMBLOB and JSON | Equal | +| 2 | <\>, != | Except for BLOB, MEDIUMBLOB, JSON and primary key of timestamp type | Not equal | +| 3 | \>, \< | Except for BLOB, MEDIUMBLOB and JSON | Greater than, less than | +| 4 | \>=, \<= | Except for BLOB, MEDIUMBLOB and JSON | Greater than or equal to, less than or equal to | +| 5 | IS [NOT] NULL | Any types | Is NULL or NOT | +| 6 | [NOT] BETWEEN AND | Except for BLOB, MEDIUMBLOB and JSON | In a value range or not | +| 7 | IN | Except for BLOB, MEDIUMBLOB, JSON and primary key of timestamp type | In a list of values or not | +| 8 | LIKE | BINARY, NCHAR and VARCHAR | Wildcard matching | +| 9 | MATCH, NMATCH | BINARY, NCHAR and VARCHAR | Regular expression matching | +| 10 | CONTAINS | JSON | If A key exists in JSON | + +`LIKE` operator uses wildcard to match a string, the rules are: + +- '%' matches 0 to any number of characters; '\_' matches any single ASCII character. +- \_ can be used to match a `_` in the string, i.e. using escape character backslash `\` +- Wildcard string is 100 bytes at most. Longer a wildcard string is, worse the performance of LIKE operator is. + +`MATCH` and `NMATCH` operators use regular expressions to match a string, the rules are: + +- Regular expressions of POSIX standard are supported. +- Only `tbname`, i.e. table name of sub tables, and tag columns of string types can be matched with regular expression, data columns are not supported. +- Regular expression string is 128 bytes at most, and can be adjusted by setting parameter `maxRegexStringLen`, which is a client side configuration and needs to restart the client to take effect. + +## Logical Operators + +| # | **Operator** | **Data Types** | **Description** | +| --- | :----------: | -------------- | ---------------------------------------------------------------------------------------- | +| 1 | AND | BOOL | Logical AND, return TRUE if both conditions are TRUE; return FALSE if any one is FALSE. | +| 2 | OR | BOOL | Logical OR, return TRUE if any condition is TRUE; return FALSE if both are FALSE | + +TDengine employs shortcircut optimization when performing logical operations. For AND operator, if the first condition is evaluated to FALSE, then the second one is not evaluated. For OR operator, if the first condition is evaluated to TRUE, then the second one is not evaluated. From 6144cad04fa692a31aed053f0f81cbe6351ac323 Mon Sep 17 00:00:00 2001 From: gccgdb1234 Date: Tue, 31 May 2022 18:53:17 +0800 Subject: [PATCH 12/14] docs: remove arithmetic from functions.md --- docs-en/12-taos-sql/07-function.md | 31 ------------------------------ 1 file changed, 31 deletions(-) diff --git a/docs-en/12-taos-sql/07-function.md b/docs-en/12-taos-sql/07-function.md index 3589efe9cd..1a0dc28fa0 100644 --- a/docs-en/12-taos-sql/07-function.md +++ b/docs-en/12-taos-sql/07-function.md @@ -1537,37 +1537,6 @@ SELECT SUBSTR(str,pos[,len]) FROM { tb_name | stb_name } [WHERE clause] - Parameter `pos` can be an positive or negative integer; If it's positive, the starting position will be counted from the beginning of the string; if it's negative, the starting position will be counted from the end of the string. - If `len` is not specified, it means from `pos` to the end. -### Arithmetic Operations - -``` -SELECT field_name [+|-|*|/|%][Value|field_name] FROM { tb_name | stb_name } [WHERE clause]; -``` - -**Description**: The sum, difference, product, quotient, or remainder between one or more columns - -**Return value type**: Double precision floating point - -**Applicable column types**: Data types except for timestamp, binary, nchar, bool - -**Applicable table types**: table, STable - -**More explanations**: - -- Arithmetic operations can be performed on two or more columns, Parentheses `()` can be used to control the order of precedence. -- NULL doesn't participate in the operation i.e. if one of the operands is NULL then result is NULL. - -**Examples**: - -``` -taos> SELECT current + voltage * phase FROM d1001; -(current+(voltage*phase)) | -============================ - 78.190000713 | - 84.540003240 | - 80.810000718 | -Query OK, 3 row(s) in set (0.001046s) -``` - ### STATECOUNT ``` From 11e55389b14dc32769952a59c023d58653026fc5 Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Tue, 31 May 2022 06:54:27 -0400 Subject: [PATCH 13/14] fix: fix typo --- source/libs/function/src/builtins.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/libs/function/src/builtins.c b/source/libs/function/src/builtins.c index d269e59c1e..add94cb83c 100644 --- a/source/libs/function/src/builtins.c +++ b/source/libs/function/src/builtins.c @@ -183,7 +183,7 @@ static int32_t translatePercentile(SFunctionNode* pFunc, char* pErrBuf, int32_t return TSDB_CODE_SUCCESS; } -static bool validateAperventileAlgo(const SValueNode* pVal) { +static bool validateApercentileAlgo(const SValueNode* pVal) { if (TSDB_DATA_TYPE_BINARY != pVal->node.resType.type) { return false; } @@ -231,7 +231,7 @@ static int32_t translateApercentile(SFunctionNode* pFunc, char* pErrBuf, int32_t } SNode* pParamNode2 = nodesListGetNode(pFunc->pParameterList, 2); - if (QUERY_NODE_VALUE != nodeType(pParamNode2) || !validateAperventileAlgo((SValueNode*)pParamNode2)) { + if (QUERY_NODE_VALUE != nodeType(pParamNode2) || !validateApercentileAlgo((SValueNode*)pParamNode2)) { return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR, "Third parameter algorithm of apercentile must be 'default' or 't-digest'"); } From 5e4c31c7943f4301a67dd278b6830d2373bd8421 Mon Sep 17 00:00:00 2001 From: gccgdb1234 Date: Tue, 31 May 2022 18:54:34 +0800 Subject: [PATCH 14/14] docs: rephrases --- docs-en/12-taos-sql/13-operators.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs-en/12-taos-sql/13-operators.md b/docs-en/12-taos-sql/13-operators.md index 2db1397d67..e393c82c76 100644 --- a/docs-en/12-taos-sql/13-operators.md +++ b/docs-en/12-taos-sql/13-operators.md @@ -63,4 +63,4 @@ TDengine provides 2 set operators: `UNION ALL` and `UNION`. `UNION ALL` combines | 1 | AND | BOOL | Logical AND, return TRUE if both conditions are TRUE; return FALSE if any one is FALSE. | | 2 | OR | BOOL | Logical OR, return TRUE if any condition is TRUE; return FALSE if both are FALSE | -TDengine employs shortcircut optimization when performing logical operations. For AND operator, if the first condition is evaluated to FALSE, then the second one is not evaluated. For OR operator, if the first condition is evaluated to TRUE, then the second one is not evaluated. +TDengine uses shortcircut optimization when performing logical operations. For AND operator, if the first condition is evaluated to FALSE, then the second one is not evaluated. For OR operator, if the first condition is evaluated to TRUE, then the second one is not evaluated.