From 433179af0dc849e79a9d14163773b07e12b1a3ac Mon Sep 17 00:00:00 2001 From: kailixu Date: Sun, 10 Mar 2024 22:14:57 +0800 Subject: [PATCH] fix: unify tag value parsing syntax --- include/common/tmsg.h | 1 + source/common/src/tvariant.c | 8 +- source/libs/parser/inc/parAst.h | 2 + source/libs/parser/inc/parUtil.h | 52 + source/libs/parser/inc/sql.y | 51 +- source/libs/parser/src/parAstCreater.c | 74 + source/libs/parser/src/parInsertSql.c | 163 +- source/libs/parser/src/parTranslater.c | 291 +- source/libs/parser/src/sql.c | 5984 ++++++++--------- source/os/src/osString.c | 15 +- source/util/src/terror.c | 2 +- tests/parallel_test/cases.task | 1 + .../script/tsim/parser/columnValue_bigint.sim | 81 +- tests/script/tsim/parser/columnValue_bool.sim | 36 +- .../script/tsim/parser/columnValue_double.sim | 28 +- .../script/tsim/parser/columnValue_float.sim | 26 +- tests/script/tsim/parser/columnValue_int.sim | 36 +- .../tsim/parser/columnValue_smallint.sim | 34 +- .../tsim/parser/columnValue_tinyint.sim | 64 +- tests/script/tsim/parser/create_mt.sim | 2 +- tests/script/tsim/parser/null_char.sim | 47 +- tests/script/tsim/tag/add.sim | 4 +- .../1-insert/insert_column_value.py | 159 + tests/system-test/2-query/count_partition.py | 2 +- tests/system-test/2-query/max_partition.py | 2 +- tests/system-test/2-query/tagFilter.py | 234 +- tests/system-test/2-query/tsbsQuery.py | 2 +- tests/system-test/runAllOne.sh | 1 + tests/system-test/win-test-file | 1 + 29 files changed, 3894 insertions(+), 3509 deletions(-) create mode 100644 tests/system-test/1-insert/insert_column_value.py diff --git a/include/common/tmsg.h b/include/common/tmsg.h index db2c51fb01..06381a433f 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -2822,6 +2822,7 @@ typedef struct { int8_t tagType; uint32_t nTagVal; uint8_t* pTagVal; + SArray* pTagArray; // TSDB_ALTER_TABLE_UPDATE_OPTIONS int8_t updateTTL; int32_t newTTL; diff --git a/source/common/src/tvariant.c b/source/common/src/tvariant.c index dd5e8240b9..db5448447b 100644 --- a/source/common/src/tvariant.c +++ b/source/common/src/tvariant.c @@ -98,8 +98,8 @@ int32_t parseSignAndUInteger(const char *z, int32_t n, bool *is_neg, uint64_t *v int32_t toDoubleEx(const char *z, int32_t n, uint32_t type, double* value) { if (n == 0) { - *value = 0; - return TSDB_CODE_SUCCESS; + errno = EINVAL; + return TSDB_CODE_FAILED; } errno = 0; @@ -144,8 +144,8 @@ int32_t toIntegerEx(const char *z, int32_t n, uint32_t type, int64_t *value) { } if (n == 0) { - *value = 0; - return TSDB_CODE_SUCCESS; + errno = EINVAL; + return TSDB_CODE_FAILED; } // 1. try to parse as integer diff --git a/source/libs/parser/inc/parAst.h b/source/libs/parser/inc/parAst.h index f13f9f1b96..dcd102b92d 100644 --- a/source/libs/parser/inc/parAst.h +++ b/source/libs/parser/inc/parAst.h @@ -108,6 +108,8 @@ SNodeList* addNodeToList(SAstCreateContext* pCxt, SNodeList* pList, SNode* pNode SNode* createColumnNode(SAstCreateContext* pCxt, SToken* pTableAlias, SToken* pColumnName); SNode* createValueNode(SAstCreateContext* pCxt, int32_t dataType, const SToken* pLiteral); +SNode* createRawValueNode(SAstCreateContext* pCxt, int32_t dataType, const SToken* pLiteral, SNode *pNode); +SNode* createRawValueNodeExt(SAstCreateContext* pCxt, int32_t dataType, const SToken* pLiteral, SNode *pLeft, SNode *pRight); SNodeList* createHintNodeList(SAstCreateContext* pCxt, const SToken* pLiteral); SNode* createIdentifierValueNode(SAstCreateContext* pCxt, SToken* pLiteral); SNode* createDurationValueNode(SAstCreateContext* pCxt, const SToken* pLiteral); diff --git a/source/libs/parser/inc/parUtil.h b/source/libs/parser/inc/parUtil.h index 11a3a40a1e..df3fdbf3ed 100644 --- a/source/libs/parser/inc/parUtil.h +++ b/source/libs/parser/inc/parUtil.h @@ -23,6 +23,7 @@ extern "C" { #include "catalog.h" #include "os.h" #include "parser.h" +#include "parToken.h" #include "query.h" #define parserFatal(param, ...) qFatal("PARSER: " param, ##__VA_ARGS__) @@ -35,6 +36,54 @@ extern "C" { #define ROWTS_PSEUDO_COLUMN_NAME "_rowts" #define C0_PSEUDO_COLUMN_NAME "_c0" +#define IS_NOW_STR(s, n) \ + ((*(s) == 'n' || *(s) == 'N') && (*((s) + 1) == 'o' || *((s) + 1) == 'O') && \ + (*((s) + 2) == 'w' || *((s) + 2) == 'W') && (n == 3 || (n == 5 && *((s) + 3) == '(' && *((s) + 4) == ')'))) + +#define IS_TODAY_STR(s, n) \ + ((*(s) == 't' || *(s) == 'T') && (*((s) + 1) == 'o' || *((s) + 1) == 'O') && \ + (*((s) + 2) == 'd' || *((s) + 2) == 'D') && (*((s) + 3) == 'a' || *((s) + 3) == 'A') && \ + (*((s) + 4) == 'y' || *((s) + 4) == 'Y') && (n == 5 || (n == 7 && *((s) + 5) == '(' && *((s) + 6) == ')'))) + +#define IS_TRUE_STR(s, n) \ + (n == 4 && (*(s) == 't' || *(s) == 'T') && (*((s) + 1) == 'r' || *((s) + 1) == 'R') && \ + (*((s) + 2) == 'u' || *((s) + 2) == 'U') && (*((s) + 3) == 'e' || *((s) + 3) == 'E')) + +#define IS_FALSE_STR(s, n) \ + (n == 5 && (*(s) == 'f' || *(s) == 'F') && (*((s) + 1) == 'a' || *((s) + 1) == 'A') && \ + (*((s) + 2) == 'l' || *((s) + 2) == 'L') && (*((s) + 3) == 's' || *((s) + 3) == 'S') && \ + (*((s) + 4) == 'e' || *((s) + 4) == 'E')) + +#define IS_NULL_STR(s, n) \ + (n == 4 && (*(s) == 'N' || *(s) == 'n') && (*((s) + 1) == 'U' || *((s) + 1) == 'u') && \ + (*((s) + 2) == 'L' || *((s) + 2) == 'l') && (*((s) + 3) == 'L' || *((s) + 3) == 'l')) + +#define NEXT_TOKEN_WITH_PREV(pSql, token) \ + do { \ + int32_t index = 0; \ + token = tStrGetToken(pSql, &index, true, NULL); \ + pSql += index; \ + } while (0) + +#define NEXT_TOKEN_WITH_PREV_EXT(pSql, token, pIgnoreComma) \ + do { \ + int32_t index = 0; \ + token = tStrGetToken(pSql, &index, true, pIgnoreComma); \ + pSql += index; \ + } while (0) + +#define NEXT_TOKEN_KEEP_SQL(pSql, token, index) \ + do { \ + token = tStrGetToken(pSql, &index, false, NULL); \ + } while (0) + +#define NEXT_VALID_TOKEN(pSql, token) \ + do { \ + (token).n = tGetToken(pSql, &(token).type); \ + (token).z = (char*)pSql; \ + pSql += (token).n; \ + } while (TK_NK_SPACE == (token).type) + typedef struct SMsgBuf { int32_t len; char* buf; @@ -89,6 +138,9 @@ int32_t getTableTypeFromTableNode(SNode *pTable); int32_t trimString(const char* src, int32_t len, char* dst, int32_t dlen); int32_t getVnodeSysTableTargetName(int32_t acctId, SNode* pWhere, SName* pName); +int32_t checkAndTrimValue(SToken* pToken, char* tmpTokenBuf, SMsgBuf* pMsgBuf, int8_t type); +int32_t parseTagValue(SMsgBuf* pMsgBuf, const char** pSql, uint8_t precision, SSchema* pTagSchema, SToken* pToken, + SArray* pTagName, SArray* pTagVals, STag** pTag); int32_t buildCatalogReq(const SParseMetaCache* pMetaCache, SCatalogReq* pCatalogReq); int32_t putMetaDataToCache(const SCatalogReq* pCatalogReq, const SMetaData* pMetaData, SParseMetaCache* pMetaCache); diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y index 4c59f3abd7..edd5a31e1e 100755 --- a/source/libs/parser/inc/sql.y +++ b/source/libs/parser/inc/sql.y @@ -354,7 +354,7 @@ alter_table_clause(A) ::= alter_table_clause(A) ::= full_table_name(B) RENAME TAG column_name(C) column_name(D). { A = createAlterTableRenameCol(pCxt, B, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &C, &D); } alter_table_clause(A) ::= - full_table_name(B) SET TAG column_name(C) NK_EQ signed_literal(D). { A = createAlterTableSetTag(pCxt, B, &C, D); } + full_table_name(B) SET TAG column_name(C) NK_EQ tags_literal(D). { A = createAlterTableSetTag(pCxt, B, &C, D); } %type multi_create_clause { SNodeList* } %destructor multi_create_clause { nodesDestroyList($$); } @@ -363,7 +363,7 @@ multi_create_clause(A) ::= multi_create_clause(B) create_subtable_clause(C). create_subtable_clause(A) ::= not_exists_opt(B) full_table_name(C) USING full_table_name(D) - specific_cols_opt(E) TAGS NK_LP expression_list(F) NK_RP table_options(G). { A = createCreateSubTableClause(pCxt, B, C, D, E, F, G); } + specific_cols_opt(E) TAGS NK_LP tags_literal_list(F) NK_RP table_options(G). { A = createCreateSubTableClause(pCxt, B, C, D, E, F, G); } %type multi_drop_clause { SNodeList* } %destructor multi_drop_clause { nodesDestroyList($$); } @@ -744,6 +744,52 @@ insert_query(A) ::= INSERT INTO full_table_name(D) NK_LP col_name_list(B) NK_RP query_or_subquery(C). { A = createInsertStmt(pCxt, D, B, C); } insert_query(A) ::= INSERT INTO full_table_name(C) query_or_subquery(B). { A = createInsertStmt(pCxt, C, NULL, B); } +/************************************************ tags_literal *************************************************************/ +tags_literal(A) ::= NK_INTEGER(B). { A = createRawValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &B, NULL); } +tags_literal(A) ::= NK_PLUS(B) NK_INTEGER(C). { + SToken t = B; + t.n = (C.z + C.n) - B.z; + A = createRawValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &t, NULL); + } +tags_literal(A) ::= NK_MINUS(B) NK_INTEGER(C). { + SToken t = B; + t.n = (C.z + C.n) - B.z; + A = createRawValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &t, NULL); + } +tags_literal(A) ::= NK_FLOAT(B). { A = createRawValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &B, NULL); } +tags_literal(A) ::= NK_PLUS(B) NK_FLOAT(C). { + SToken t = B; + t.n = (C.z + C.n) - B.z; + A = createRawValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t, NULL); + } +tags_literal(A) ::= NK_MINUS(B) NK_FLOAT(C). { + SToken t = B; + t.n = (C.z + C.n) - B.z; + A = createRawValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t, NULL); + } +tags_literal(A) ::= NK_STRING(B). { A = createRawValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &B, NULL); } +tags_literal(A) ::= NK_BOOL(B). { A = createRawValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &B, NULL); } +tags_literal(A) ::= NULL(B). { A = createRawValueNode(pCxt, TSDB_DATA_TYPE_NULL, &B, NULL); } + +tags_literal(A) ::= literal_func(B). { A = createRawValueNode(pCxt, TSDB_DATA_TYPE_BINARY, NULL, B); } +tags_literal(A) ::= literal_func(B) NK_PLUS duration_literal(C). { + SToken l = getTokenFromRawExprNode(pCxt, B); + SToken r = getTokenFromRawExprNode(pCxt, C); + l.n = (r.z + r.n) - l.z; + A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, B, C); + } +tags_literal(A) ::= literal_func(B) NK_MINUS duration_literal(C). { + SToken l = getTokenFromRawExprNode(pCxt, B); + SToken r = getTokenFromRawExprNode(pCxt, C); + l.n = (r.z + r.n) - l.z; + A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, B, C); + } + +%type tags_literal_list { SNodeList* } +%destructor tags_literal_list { nodesDestroyList($$); } +tags_literal_list(A) ::= tags_literal(B). { A = createNodeList(pCxt, B); } +tags_literal_list(A) ::= tags_literal_list(B) NK_COMMA tags_literal(C). { A = addNodeToList(pCxt, B, C); } + /************************************************ literal *************************************************************/ literal(A) ::= NK_INTEGER(B). { A = createRawExprNode(pCxt, &B, createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &B)); } literal(A) ::= NK_FLOAT(B). { A = createRawExprNode(pCxt, &B, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &B)); } @@ -924,6 +970,7 @@ function_expression(A) ::= literal_func(B). literal_func(A) ::= noarg_func(B) NK_LP NK_RP(C). { A = createRawExprNodeExt(pCxt, &B, &C, createFunctionNode(pCxt, &B, NULL)); } literal_func(A) ::= NOW(B). { A = createRawExprNode(pCxt, &B, createFunctionNode(pCxt, &B, NULL)); } +literal_func(A) ::= TODAY(B). { A = createRawExprNode(pCxt, &B, createFunctionNode(pCxt, &B, NULL)); } %type noarg_func { SToken } %destructor noarg_func { } diff --git a/source/libs/parser/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c index 1d6c5e800e..4a487439c2 100644 --- a/source/libs/parser/src/parAstCreater.c +++ b/source/libs/parser/src/parAstCreater.c @@ -371,6 +371,80 @@ SNode* createValueNode(SAstCreateContext* pCxt, int32_t dataType, const SToken* return (SNode*)val; } +SNode* createRawValueNode(SAstCreateContext* pCxt, int32_t dataType, const SToken* pLiteral, SNode* pNode) { + CHECK_PARSER_STATUS(pCxt); + SValueNode* val = NULL; + + if (!(val = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE))) { + pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_OUT_OF_MEMORY, "Out of memory"); + goto _exit; + } + if (pLiteral) { + val->literal = strndup(pLiteral->z, pLiteral->n); + } else if (pNode) { + SRawExprNode* pRawExpr = (SRawExprNode*)pNode; + if (!nodesIsExprNode(pRawExpr->pNode)) { + pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_SYNTAX_ERROR, pRawExpr->p); + goto _exit; + } + val->literal = strndup(pRawExpr->p, pRawExpr->n); + } else { + pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INTERNAL_ERROR, "Invalid parameters"); + goto _exit; + } + if (!val->literal) { + pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_OUT_OF_MEMORY, "Out of memory"); + goto _exit; + } + + val->node.resType.type = dataType; + val->node.resType.bytes = IS_VAR_DATA_TYPE(dataType) ? strlen(val->literal) : tDataTypes[dataType].bytes; + if (TSDB_DATA_TYPE_TIMESTAMP == dataType) { + val->node.resType.precision = TSDB_TIME_PRECISION_MILLI; + } +_exit: + nodesDestroyNode(pNode); + if (pCxt->errCode != 0) { + nodesDestroyNode((SNode*)val); + return NULL; + } + return (SNode*)val; +} + +SNode* createRawValueNodeExt(SAstCreateContext* pCxt, int32_t dataType, const SToken* pLiteral, SNode* pLeft, + SNode* pRight) { + CHECK_PARSER_STATUS(pCxt); + SValueNode* val = NULL; + + if (!(val = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE))) { + pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_OUT_OF_MEMORY, "Out of memory"); + goto _exit; + } + if (pLiteral) { + if (!(val->literal = strndup(pLiteral->z, pLiteral->n))) { + pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_OUT_OF_MEMORY, "Out of memory"); + goto _exit; + } + } else { + pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INTERNAL_ERROR, "Invalid parameters"); + goto _exit; + } + + val->node.resType.type = dataType; + val->node.resType.bytes = IS_VAR_DATA_TYPE(dataType) ? strlen(val->literal) : tDataTypes[dataType].bytes; + if (TSDB_DATA_TYPE_TIMESTAMP == dataType) { + val->node.resType.precision = TSDB_TIME_PRECISION_MILLI; + } +_exit: + nodesDestroyNode(pLeft); + nodesDestroyNode(pRight); + if (pCxt->errCode != 0) { + nodesDestroyNode((SNode*)val); + return NULL; + } + return (SNode*)val; +} + static bool hasHint(SNodeList* pHintList, EHintOption hint) { if (!pHintList) return false; SNode* pNode; diff --git a/source/libs/parser/src/parInsertSql.c b/source/libs/parser/src/parInsertSql.c index 63fcd7c64e..965b80e9ce 100644 --- a/source/libs/parser/src/parInsertSql.c +++ b/source/libs/parser/src/parInsertSql.c @@ -20,32 +20,6 @@ #include "ttime.h" #include "geosWrapper.h" -#define NEXT_TOKEN_WITH_PREV(pSql, token) \ - do { \ - int32_t index = 0; \ - token = tStrGetToken(pSql, &index, true, NULL); \ - pSql += index; \ - } while (0) - -#define NEXT_TOKEN_WITH_PREV_EXT(pSql, token, pIgnoreComma) \ - do { \ - int32_t index = 0; \ - token = tStrGetToken(pSql, &index, true, pIgnoreComma); \ - pSql += index; \ - } while (0) - -#define NEXT_TOKEN_KEEP_SQL(pSql, token, index) \ - do { \ - token = tStrGetToken(pSql, &index, false, NULL); \ - } while (0) - -#define NEXT_VALID_TOKEN(pSql, token) \ - do { \ - (token).n = tGetToken(pSql, &(token).type); \ - (token).z = (char*)pSql; \ - pSql += (token).n; \ - } while (TK_NK_SPACE == (token).type) - typedef struct SInsertParseContext { SParseContext* pComCxt; SMsgBuf msg; @@ -63,13 +37,9 @@ typedef int32_t (*_row_append_fn_t)(SMsgBuf* pMsgBuf, const void* value, int32_t static uint8_t TRUE_VALUE = (uint8_t)TSDB_TRUE; static uint8_t FALSE_VALUE = (uint8_t)TSDB_FALSE; -static bool isNullStr(SToken* pToken) { - return ((pToken->type == TK_NK_STRING) && (strlen(TSDB_DATA_NULL_STR_L) == pToken->n) && - (strncasecmp(TSDB_DATA_NULL_STR_L, pToken->z, pToken->n) == 0)); -} - -static bool isNullValue(int8_t dataType, SToken* pToken) { - return TK_NULL == pToken->type || (!IS_STR_DATA_TYPE(dataType) && isNullStr(pToken)); +static FORCE_INLINE bool isNullValue(int8_t dataType, SToken* pToken) { + return TK_NULL == pToken->type || + (TK_NK_STRING == pToken->type && !IS_STR_DATA_TYPE(dataType) && IS_NULL_STR(pToken->z, pToken->n)); } static FORCE_INLINE int32_t toDouble(SToken* pToken, double* value, char** endPtr) { @@ -268,7 +238,8 @@ static int32_t parseBoundColumns(SInsertParseContext* pCxt, const char** pSql, E return code; } -static int parseTimestampOrInterval(const char** end, SToken* pToken, int16_t timePrec, int64_t* ts, int64_t* interval, SMsgBuf* pMsgBuf, bool* isTs) { +static int parseTimestampOrInterval(const char** end, SToken* pToken, int16_t timePrec, int64_t* ts, int64_t* interval, + SMsgBuf* pMsgBuf, bool* isTs) { if (pToken->type == TK_NOW) { *isTs = true; *ts = taosGetTimestamp(timePrec); @@ -289,7 +260,20 @@ static int parseTimestampOrInterval(const char** end, SToken* pToken, int16_t ti } else { // parse the RFC-3339/ISO-8601 timestamp format string *isTs = true; if (taosParseTime(pToken->z, ts, pToken->n, timePrec, tsDaylight) != TSDB_CODE_SUCCESS) { - return buildSyntaxErrMsg(pMsgBuf, "invalid timestamp format", pToken->z); + if (pToken->type != TK_NK_STRING) { + return buildSyntaxErrMsg(pMsgBuf, "invalid timestamp format", pToken->z); + } + if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, 10, ts)) { + if (IS_NOW_STR(pToken->z, pToken->n)) { + *isTs = true; + *ts = taosGetTimestamp(timePrec); + } else if (IS_TODAY_STR(pToken->z, pToken->n)) { + *isTs = true; + *ts = taosGetTimestampToday(timePrec); + } else { + return buildSyntaxErrMsg(pMsgBuf, "invalid timestamp format", pToken->z); + } + } } } @@ -313,10 +297,22 @@ static int parseTime(const char** end, SToken* pToken, int16_t timePrec, int64_t for (int k = pToken->n; pToken->z[k] != '\0'; k++) { if (pToken->z[k] == ' ' || pToken->z[k] == '\t') continue; - if (pToken->z[k] == '(' && pToken->z[k + 1] == ')') { // for insert NOW()/TODAY() - *end = pTokenEnd = &pToken->z[k + 2]; - k++; - continue; + if (pToken->z[k] == '(') { // for insert NOW()/TODAY() + if (pToken->z[k + 1] == ')') { + *end = pTokenEnd = &pToken->z[k + 2]; + ++k; + continue; + } else { + char nc = pToken->z[k + 1]; + while (nc == ' ' || nc == '\t' || nc == '\n' || nc == '\r' || nc == '\f') { + nc = pToken->z[(++k) + 1]; + } + if (nc == ')') { + *end = pTokenEnd = &pToken->z[k + 2]; + ++k; + continue; + } + } } if (pToken->z[k] == ',') { *end = pTokenEnd; @@ -491,9 +487,9 @@ static int32_t parseTagToken(const char** end, SToken* pToken, SSchema* pSchema, switch (pSchema->type) { case TSDB_DATA_TYPE_BOOL: { if ((pToken->type == TK_NK_BOOL || pToken->type == TK_NK_STRING) && (pToken->n != 0)) { - if (strncmp(pToken->z, "true", pToken->n) == 0) { + if (IS_TRUE_STR(pToken->z, pToken->n)) { *(int8_t*)(&val->i64) = TRUE_VALUE; - } else if (strncmp(pToken->z, "false", pToken->n) == 0) { + } else if (IS_FALSE_STR(pToken->z, pToken->n)) { *(int8_t*)(&val->i64) = FALSE_VALUE; } else { return buildSyntaxErrMsg(pMsgBuf, "invalid bool data", pToken->z); @@ -709,30 +705,29 @@ static int32_t parseBoundTagsClause(SInsertParseContext* pCxt, SVnodeModifyOpStm return parseBoundColumns(pCxt, &pStmt->pSql, BOUND_TAGS, pStmt->pTableMeta, &pCxt->tags); } -static int32_t parseTagValue(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt, const char** ppSql, SSchema* pTagSchema, SToken* pToken, - SArray* pTagName, SArray* pTagVals, STag** pTag) { +int32_t parseTagValue(SMsgBuf* pMsgBuf, const char** pSql, uint8_t precision, SSchema* pTagSchema, SToken* pToken, + SArray* pTagName, SArray* pTagVals, STag** pTag) { bool isNull = isNullValue(pTagSchema->type, pToken); - if (!isNull) { + if (!isNull && pTagName) { taosArrayPush(pTagName, pTagSchema->name); } if (pTagSchema->type == TSDB_DATA_TYPE_JSON) { if (pToken->n > (TSDB_MAX_JSON_TAG_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE) { - return buildSyntaxErrMsg(&pCxt->msg, "json string too long than 4095", pToken->z); + return buildSyntaxErrMsg(pMsgBuf, "json string too long than 4095", pToken->z); } if (isNull) { return tTagNew(pTagVals, 1, true, pTag); } else { - return parseJsontoTagData(pToken->z, pTagVals, pTag, &pCxt->msg); + return parseJsontoTagData(pToken->z, pTagVals, pTag, pMsgBuf); } } if (isNull) return 0; STagVal val = {0}; - int32_t code = - parseTagToken(ppSql, pToken, pTagSchema, pStmt->pTableMeta->tableInfo.precision, &val, &pCxt->msg); + int32_t code = parseTagToken(pSql, pToken, pTagSchema, precision, &val, pMsgBuf); if (TSDB_CODE_SUCCESS == code) { taosArrayPush(pTagVals, &val); } @@ -755,7 +750,7 @@ static int32_t buildCreateTbReq(SVnodeModifyOpStmt* pStmt, STag* pTag, SArray* p return TSDB_CODE_SUCCESS; } -static int32_t checkAndTrimValue(SToken* pToken, char* tmpTokenBuf, SMsgBuf* pMsgBuf, int8_t type) { +int32_t checkAndTrimValue(SToken* pToken, char* tmpTokenBuf, SMsgBuf* pMsgBuf, int8_t type) { if ((pToken->type != TK_NOW && pToken->type != TK_TODAY && pToken->type != TK_NK_INTEGER && pToken->type != TK_NK_STRING && pToken->type != TK_NK_FLOAT && pToken->type != TK_NK_BOOL && pToken->type != TK_NULL && pToken->type != TK_NK_HEX && pToken->type != TK_NK_OCT && @@ -911,12 +906,19 @@ static int32_t checkSubtablePrivilege(SArray* pTagVals, SArray* pTagName, SNode* static int32_t parseTagsClauseImpl(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt) { int32_t code = TSDB_CODE_SUCCESS; SSchema* pSchema = getTableTagSchema(pStmt->pTableMeta); - SArray* pTagVals = taosArrayInit(pCxt->tags.numOfBound, sizeof(STagVal)); - SArray* pTagName = taosArrayInit(8, TSDB_COL_NAME_LEN); + SArray* pTagVals = NULL; + SArray* pTagName = NULL; + uint8_t precision = pStmt->pTableMeta->tableInfo.precision; SToken token; bool isParseBindParam = false; bool isJson = false; STag* pTag = NULL; + + if (!(pTagVals = taosArrayInit(pCxt->tags.numOfBound, sizeof(STagVal))) || + !(pTagName = taosArrayInit(pCxt->tags.numOfBound, TSDB_COL_NAME_LEN))) { + return TSDB_CODE_OUT_OF_MEMORY; + } + for (int i = 0; TSDB_CODE_SUCCESS == code && i < pCxt->tags.numOfBound; ++i) { NEXT_TOKEN_WITH_PREV(pStmt->pSql, token); @@ -938,16 +940,15 @@ static int32_t parseTagsClauseImpl(SInsertParseContext* pCxt, SVnodeModifyOpStmt SSchema* pTagSchema = &pSchema[pCxt->tags.pColIndex[i]]; isJson = pTagSchema->type == TSDB_DATA_TYPE_JSON; code = checkAndTrimValue(&token, pCxt->tmpTokenBuf, &pCxt->msg, pTagSchema->type); - if (TK_NK_VARIABLE == token.type) { + if (TSDB_CODE_SUCCESS == code && TK_NK_VARIABLE == token.type) { code = buildSyntaxErrMsg(&pCxt->msg, "not expected tags values ", token.z); } if (TSDB_CODE_SUCCESS == code) { - code = parseTagValue(pCxt, pStmt, &pStmt->pSql, pTagSchema, &token, pTagName, pTagVals, &pTag); + code = parseTagValue(&pCxt->msg, &pStmt->pSql, precision, pTagSchema, &token, pTagName, pTagVals, &pTag); } } if (TSDB_CODE_SUCCESS == code && NULL != pStmt->pTagCond) { - assert(0); code = checkSubtablePrivilege(pTagVals, pTagName, &pStmt->pTagCond); } @@ -960,8 +961,8 @@ static int32_t parseTagsClauseImpl(SInsertParseContext* pCxt, SVnodeModifyOpStmt pTag = NULL; } - for (int i = 0; i < taosArrayGetSize(pTagVals); ++i) { - STagVal* p = (STagVal*)taosArrayGet(pTagVals, i); + for (int32_t i = 0; i < TARRAY_SIZE(pTagVals); ++i) { + STagVal* p = (STagVal*)TARRAY_GET_ELEM(pTagVals, i); if (IS_VAR_DATA_TYPE(p->type)) { taosMemoryFreeClear(p->pData); } @@ -1426,9 +1427,9 @@ static int32_t parseValueTokenImpl(SInsertParseContext* pCxt, const char** pSql, switch (pSchema->type) { case TSDB_DATA_TYPE_BOOL: { if ((pToken->type == TK_NK_BOOL || pToken->type == TK_NK_STRING) && (pToken->n != 0)) { - if (strncmp(pToken->z, "true", pToken->n) == 0) { + if (IS_TRUE_STR(pToken->z, pToken->n)) { pVal->value.val = TRUE_VALUE; - } else if (strncmp(pToken->z, "false", pToken->n) == 0) { + } else if (IS_FALSE_STR(pToken->z, pToken->n)) { pVal->value.val = FALSE_VALUE; } else { return buildSyntaxErrMsg(&pCxt->msg, "invalid bool data", pToken->z); @@ -1511,7 +1512,7 @@ static int32_t parseValueTokenImpl(SInsertParseContext* pCxt, const char** pSql, break; } case TSDB_DATA_TYPE_FLOAT: { - double dv; + double dv; int32_t code = toDoubleEx(pToken->z, pToken->n, pToken->type, &dv); if (TSDB_CODE_SUCCESS != code) { return buildSyntaxErrMsg(&pCxt->msg, "illegal float data", pToken->z); @@ -1524,7 +1525,7 @@ static int32_t parseValueTokenImpl(SInsertParseContext* pCxt, const char** pSql, break; } case TSDB_DATA_TYPE_DOUBLE: { - double dv; + double dv; int32_t code = toDoubleEx(pToken->z, pToken->n, pToken->type, &dv); if (TSDB_CODE_SUCCESS != code) { return buildSyntaxErrMsg(&pCxt->msg, "illegal float data", pToken->z); @@ -1550,7 +1551,7 @@ static int32_t parseValueTokenImpl(SInsertParseContext* pCxt, const char** pSql, } case TSDB_DATA_TYPE_VARBINARY: { int32_t code = parseVarbinary(pToken, &pVal->value.pData, &pVal->value.nData, pSchema->bytes); - if(code != TSDB_CODE_SUCCESS){ + if (code != TSDB_CODE_SUCCESS) { return generateSyntaxErrMsg(&pCxt->msg, code, pSchema->name); } break; @@ -1588,9 +1589,9 @@ static int32_t parseValueTokenImpl(SInsertParseContext* pCxt, const char** pSql, break; } case TSDB_DATA_TYPE_GEOMETRY: { - int32_t code = TSDB_CODE_FAILED; - unsigned char *output = NULL; - size_t size = 0; + int32_t code = TSDB_CODE_FAILED; + unsigned char* output = NULL; + size_t size = 0; code = parseGeometry(pToken, &output, &size); if (code != TSDB_CODE_SUCCESS) { @@ -1599,13 +1600,11 @@ static int32_t parseValueTokenImpl(SInsertParseContext* pCxt, const char** pSql, // Too long values will raise the invalid sql error message else if (size + VARSTR_HEADER_SIZE > pSchema->bytes) { code = generateSyntaxErrMsg(&pCxt->msg, TSDB_CODE_PAR_VALUE_TOO_LONG, pSchema->name); - } - else { + } else { pVal->value.pData = taosMemoryMalloc(size); if (NULL == pVal->value.pData) { code = TSDB_CODE_OUT_OF_MEMORY; - } - else { + } else { memcpy(pVal->value.pData, output, size); pVal->value.nData = size; } @@ -1640,18 +1639,14 @@ static int32_t parseValueToken(SInsertParseContext* pCxt, const char** pSql, STo return buildSyntaxErrMsg(&pCxt->msg, "primary timestamp should not be null", pToken->z); } - if (TK_NK_VARIABLE == pToken->type && pSchema->type != TSDB_DATA_TYPE_TIMESTAMP) { - return buildSyntaxErrMsg(&pCxt->msg, "invalid values", pToken->z); - } pVal->flag = CV_FLAG_NULL; return TSDB_CODE_SUCCESS; } - if (TSDB_CODE_SUCCESS == code && IS_NUMERIC_TYPE(pSchema->type) && pToken->n == 0) { - return buildSyntaxErrMsg(&pCxt->msg, "invalid numeric data", pToken->z); - } - if (TSDB_CODE_SUCCESS == code) { + if (pToken->n == 0 && IS_NUMERIC_TYPE(pSchema->type)) { + return buildSyntaxErrMsg(&pCxt->msg, "invalid numeric data", pToken->z); + } code = parseValueTokenImpl(pCxt, pSql, pToken, pSchema, timePrec, pVal); } @@ -1729,18 +1724,19 @@ static int32_t processCtbTagsAfterCtbName(SInsertParseContext* pCxt, SVnodeModif const SToken* tagTokens, SSchema* const* tagSchemas, int numOfTagTokens) { int32_t code = TSDB_CODE_SUCCESS; + uint8_t precision = pStmt->pTableMeta->tableInfo.precision; if (code == TSDB_CODE_SUCCESS && ctbFirst) { for (int32_t i = 0; code == TSDB_CODE_SUCCESS && i < numOfTagTokens; ++i) { SToken* pTagToken = (SToken*)(tagTokens + i); SSchema* pTagSchema = tagSchemas[i]; code = checkAndTrimValue(pTagToken, pCxt->tmpTokenBuf, &pCxt->msg, pTagSchema->type); - if (TK_NK_VARIABLE == pTagToken->type) { + if (code == TSDB_CODE_SUCCESS && TK_NK_VARIABLE == pTagToken->type) { code = buildInvalidOperationMsg(&pCxt->msg, "not expected tag"); } if (code == TSDB_CODE_SUCCESS) { - code = parseTagValue(pCxt, pStmt, NULL, pTagSchema, pTagToken, pStbRowsCxt->aTagNames, pStbRowsCxt->aTagVals, + code = parseTagValue(&pCxt->msg, NULL, precision, pTagSchema, pTagToken, pStbRowsCxt->aTagNames, pStbRowsCxt->aTagVals, &pStbRowsCxt->pTag); } } @@ -1760,11 +1756,12 @@ static int32_t doGetStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt* const SBoundColInfo* pCols, const SSchema* pSchemas, SToken* tagTokens, SSchema** tagSchemas, int* pNumOfTagTokens, bool* bFoundTbName) { int32_t code = TSDB_CODE_SUCCESS; - SArray* pTagNames = pStbRowsCxt->aTagNames; - SArray* pTagVals = pStbRowsCxt->aTagVals; - bool canParseTagsAfter = !pStbRowsCxt->pTagCond && !pStbRowsCxt->hasTimestampTag; + SArray* pTagNames = pStbRowsCxt->aTagNames; + SArray* pTagVals = pStbRowsCxt->aTagVals; + bool canParseTagsAfter = !pStbRowsCxt->pTagCond && !pStbRowsCxt->hasTimestampTag; int32_t numOfCols = getNumOfColumns(pStbRowsCxt->pStbMeta); int32_t tbnameIdx = getTbnameSchemaIndex(pStbRowsCxt->pStbMeta); + uint8_t precision = getTableInfo(pStbRowsCxt->pStbMeta).precision; for (int i = 0; i < pCols->numOfBound && (code) == TSDB_CODE_SUCCESS; ++i) { const char* pTmpSql = *ppSql; bool ignoreComma = false; @@ -1782,7 +1779,7 @@ static int32_t doGetStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt* if (pCols->pColIndex[i] < numOfCols) { const SSchema* pSchema = &pSchemas[pCols->pColIndex[i]]; SColVal* pVal = taosArrayGet(pStbRowsCxt->aColVals, pCols->pColIndex[i]); - code = parseValueToken(pCxt, ppSql, pToken, (SSchema*)pSchema, getTableInfo(pStbRowsCxt->pStbMeta).precision, pVal); + code = parseValueToken(pCxt, ppSql, pToken, (SSchema*)pSchema, precision, pVal); if (TK_NK_VARIABLE == pToken->type) { code = buildInvalidOperationMsg(&pCxt->msg, "not expected row value"); } @@ -1794,11 +1791,11 @@ static int32_t doGetStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt* ++(*pNumOfTagTokens); } else { code = checkAndTrimValue(pToken, pCxt->tmpTokenBuf, &pCxt->msg, pTagSchema->type); - if (TK_NK_VARIABLE == pToken->type) { + if (code == TSDB_CODE_SUCCESS && TK_NK_VARIABLE == pToken->type) { code = buildInvalidOperationMsg(&pCxt->msg, "not expected row value"); } if (code == TSDB_CODE_SUCCESS) { - code = parseTagValue(pCxt, pStmt, ppSql, (SSchema*)pTagSchema, pToken, pTagNames, pTagVals, &pStbRowsCxt->pTag); + code = parseTagValue(&pCxt->msg, ppSql, precision, (SSchema*)pTagSchema, pToken, pTagNames, pTagVals, &pStbRowsCxt->pTag); } } } diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index 6db68f54c7..b29cd85294 100644 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -1517,12 +1517,13 @@ static EDealRes translateNormalValue(STranslateContext* pCxt, SValueNode* pVal, void* data = NULL; uint32_t size = 0; - bool isHexChar = isHex(pVal->literal, strlen(pVal->literal)); + uint32_t vlen = strlen(pVal->literal); + bool isHexChar = isHex(pVal->literal, vlen); if (isHexChar) { - if (!isValidateHex(pVal->literal, strlen(pVal->literal))) { + if (!isValidateHex(pVal->literal, vlen)) { return TSDB_CODE_PAR_INVALID_VARBINARY; } - if (taosHex2Ascii(pVal->literal, strlen(pVal->literal), &data, &size) < 0) { + if (taosHex2Ascii(pVal->literal, vlen, &data, &size) < 0) { return TSDB_CODE_OUT_OF_MEMORY; } } else { @@ -10025,75 +10026,6 @@ static int32_t createCastFuncForTag(STranslateContext* pCxt, SNode* pNode, SData return code; } -static int32_t createTagValFromExpr(STranslateContext* pCxt, SDataType targetDt, SNode* pNode, SValueNode** pVal) { - SNode* pCast = NULL; - int32_t code = createCastFuncForTag(pCxt, pNode, targetDt, &pCast); - SNode* pNew = NULL; - if (TSDB_CODE_SUCCESS == code) { - code = scalarCalculateConstants(pCast, &pNew); - } - if (TSDB_CODE_SUCCESS == code) { - pCast = pNew; - if (QUERY_NODE_VALUE != nodeType(pCast)) { - code = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_WRONG_VALUE_TYPE, ((SExprNode*)pNode)->aliasName); - } - } - - if (TSDB_CODE_SUCCESS == code) { - *pVal = (SValueNode*)pCast; - } else { - nodesDestroyNode(pCast); - } - return code; -} - -static int32_t createTagValFromVal(STranslateContext* pCxt, SDataType targetDt, SNode* pNode, SValueNode** pVal) { - SValueNode* pTempVal = (SValueNode*)nodesCloneNode(pNode); - if (NULL == pTempVal) { - return TSDB_CODE_OUT_OF_MEMORY; - } - if (DEAL_RES_ERROR == translateValueImpl(pCxt, pTempVal, targetDt, true)) { - nodesDestroyNode((SNode*)pTempVal); - return pCxt->errCode; - } - *pVal = pTempVal; - return TSDB_CODE_SUCCESS; -} - -static int32_t createTagVal(STranslateContext* pCxt, uint8_t precision, SSchema* pSchema, SNode* pNode, - SValueNode** pVal) { - if (QUERY_NODE_VALUE == nodeType(pNode)) { - return createTagValFromVal(pCxt, schemaToDataType(precision, pSchema), pNode, pVal); - } else { - return createTagValFromExpr(pCxt, schemaToDataType(precision, pSchema), pNode, pVal); - } -} - -static int32_t buildJsonTagVal(STranslateContext* pCxt, SSchema* pTagSchema, SValueNode* pVal, SArray* pTagArray, - STag** ppTag) { - if (pVal->literal && strlen(pVal->literal) > (TSDB_MAX_JSON_TAG_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE) { - return buildSyntaxErrMsg(&pCxt->msgBuf, "json string too long than 4095", pVal->literal); - } - - return parseJsontoTagData(pVal->literal, pTagArray, ppTag, &pCxt->msgBuf); -} - -static int32_t buildNormalTagVal(STranslateContext* pCxt, SSchema* pTagSchema, SValueNode* pVal, SArray* pTagArray) { - if (pVal->node.resType.type != TSDB_DATA_TYPE_NULL) { - void* nodeVal = nodesGetValueFromNode(pVal); - STagVal val = {.cid = pTagSchema->colId, .type = pTagSchema->type}; - // strcpy(val.colName, pTagSchema->name); - if (IS_VAR_DATA_TYPE(pTagSchema->type)) { - val.pData = varDataVal(nodeVal); - val.nData = varDataLen(nodeVal); - } else { - memcpy(&val.i64, nodeVal, pTagSchema->bytes); - } - taosArrayPush(pTagArray, &val); - } - return TSDB_CODE_SUCCESS; -} - static int32_t buildKVRowForBindTags(STranslateContext* pCxt, SCreateSubTableClause* pStmt, STableMeta* pSuperTableMeta, STag** ppTag, SArray* tagName) { int32_t numOfTags = getNumOfTags(pSuperTableMeta); @@ -10109,42 +10041,56 @@ static int32_t buildKVRowForBindTags(STranslateContext* pCxt, SCreateSubTableCla int32_t code = TSDB_CODE_SUCCESS; - bool isJson = false; - SNodeList* pVals = NULL; - SNode * pTag = NULL, *pNode = NULL; - FORBOTH(pTag, pStmt->pSpecificTags, pNode, pStmt->pValsOfTags) { - SColumnNode* pCol = (SColumnNode*)pTag; - SSchema* pSchema = getTagSchema(pSuperTableMeta, pCol->colName); - if (NULL == pSchema) { - code = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_TAG_NAME, pCol->colName); - } - SValueNode* pVal = NULL; + bool isJson = false; + SNode * pTagNode = NULL, *pNode = NULL; + uint8_t precision = pSuperTableMeta->tableInfo.precision; + SToken token; + char tokenBuf[TSDB_MAX_TAGS_LEN]; + const char* tagStr = NULL; + FORBOTH(pTagNode, pStmt->pSpecificTags, pNode, pStmt->pValsOfTags) { + tagStr = ((SValueNode*)pNode)->literal; + NEXT_TOKEN_WITH_PREV(tagStr, token); + + SSchema* pSchema = NULL; if (TSDB_CODE_SUCCESS == code) { - code = createTagVal(pCxt, pSuperTableMeta->tableInfo.precision, pSchema, pNode, &pVal); + if ((pSchema = getTagSchema(pSuperTableMeta, ((SColumnNode*)pTagNode)->colName))) { + code = checkAndTrimValue(&token, tokenBuf, &pCxt->msgBuf, pSchema->type); + if (TSDB_CODE_SUCCESS == code && TK_NK_VARIABLE == token.type) { + code = TSDB_CODE_TSC_SQL_SYNTAX_ERROR; + } + } else { + code = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_TAG_NAME, ((SColumnNode*)pTagNode)->colName); + } } + if (TSDB_CODE_SUCCESS == code) { if (pSchema->type == TSDB_DATA_TYPE_JSON) { isJson = true; - code = buildJsonTagVal(pCxt, pSchema, pVal, pTagArray, ppTag); - taosArrayPush(tagName, pCol->colName); - } else if (pVal->node.resType.type != TSDB_DATA_TYPE_NULL) { - code = buildNormalTagVal(pCxt, pSchema, pVal, pTagArray); - taosArrayPush(tagName, pCol->colName); + } + code = parseTagValue(&pCxt->msgBuf, &tagStr, precision, pSchema, &token, tagName, pTagArray, ppTag); + } + + if (TSDB_CODE_SUCCESS == code) { + NEXT_VALID_TOKEN(tagStr, token); + if (token.n != 0) { + code = buildSyntaxErrMsg(&pCxt->msgBuf, "not expected tags values", token.z); } } - if (TSDB_CODE_SUCCESS == code) { - code = nodesListMakeAppend(&pVals, (SNode*)pVal); - } + if (TSDB_CODE_SUCCESS != code) { break; } } - if (TSDB_CODE_SUCCESS == code && !isJson) { code = tTagNew(pTagArray, 1, false, ppTag); } - nodesDestroyList(pVals); + for (int i = 0; i < taosArrayGetSize(pTagArray); ++i) { + STagVal* p = (STagVal*)taosArrayGet(pTagArray, i); + if (IS_VAR_DATA_TYPE(p->type)) { + taosMemoryFreeClear(p->pData); + } + } taosArrayDestroy(pTagArray); return code; } @@ -10162,51 +10108,52 @@ static int32_t buildKVRowForAllTags(STranslateContext* pCxt, SCreateSubTableClau int32_t code = TSDB_CODE_SUCCESS; - bool isJson = false; - int32_t index = 0; - SSchema* pTagSchemas = getTableTagSchema(pSuperTableMeta); - SNodeList* pVals = NULL; - SNode* pNode; + bool isJson = false; + SNode* pNode; + uint8_t precision = pSuperTableMeta->tableInfo.precision; + SSchema* pTagSchema = getTableTagSchema(pSuperTableMeta); + SToken token; + char tokenBuf[TSDB_MAX_TAGS_LEN]; + const char* tagStr = NULL; FOREACH(pNode, pStmt->pValsOfTags) { - SValueNode* pVal = NULL; - SSchema* pTagSchema = pTagSchemas + index; - code = createTagVal(pCxt, pSuperTableMeta->tableInfo.precision, pTagSchema, pNode, &pVal); + tagStr = ((SValueNode*)pNode)->literal; + NEXT_TOKEN_WITH_PREV(tagStr, token); + + code = checkAndTrimValue(&token, tokenBuf, &pCxt->msgBuf, pTagSchema->type); + if (TSDB_CODE_SUCCESS == code && TK_NK_VARIABLE == token.type) { + code = buildSyntaxErrMsg(&pCxt->msgBuf, "not expected tags values", token.z); + } + if (TSDB_CODE_SUCCESS == code) { if (pTagSchema->type == TSDB_DATA_TYPE_JSON) { isJson = true; - code = buildJsonTagVal(pCxt, pTagSchema, pVal, pTagArray, ppTag); - if (TSDB_CODE_SUCCESS != code) { - nodesDestroyNode((SNode*)pVal); - } - taosArrayPush(tagName, pTagSchema->name); - } else if (pVal->node.resType.type != TSDB_DATA_TYPE_NULL && !pVal->isNull) { - char* tmpVal = nodesGetValueFromNode(pVal); - STagVal val = {.cid = pTagSchema->colId, .type = pTagSchema->type}; - // strcpy(val.colName, pTagSchema->name); - if (IS_VAR_DATA_TYPE(pTagSchema->type)) { - val.pData = varDataVal(tmpVal); - val.nData = varDataLen(tmpVal); - } else { - memcpy(&val.i64, tmpVal, pTagSchema->bytes); - } - taosArrayPush(pTagArray, &val); - taosArrayPush(tagName, pTagSchema->name); + } + code = parseTagValue(&pCxt->msgBuf, &tagStr, precision, pTagSchema, &token, tagName, pTagArray, ppTag); + } + + if (TSDB_CODE_SUCCESS == code) { + NEXT_VALID_TOKEN(tagStr, token); + if (token.n != 0) { + code = buildSyntaxErrMsg(&pCxt->msgBuf, "not expected tags values", token.z); } } - if (TSDB_CODE_SUCCESS == code) { - code = nodesListMakeAppend(&pVals, (SNode*)pVal); - } + if (TSDB_CODE_SUCCESS != code) { break; } - ++index; + ++pTagSchema; } if (TSDB_CODE_SUCCESS == code && !isJson) { code = tTagNew(pTagArray, 1, false, ppTag); } - nodesDestroyList(pVals); + for (int32_t i = 0; i < TARRAY_SIZE(pTagArray); ++i) { + STagVal* p = (STagVal*)TARRAY_GET_ELEM(pTagArray, i); + if (IS_VAR_DATA_TYPE(p->type)) { + taosMemoryFreeClear(p->pData); + } + } taosArrayDestroy(pTagArray); return code; } @@ -10467,58 +10414,65 @@ static int32_t buildUpdateTagValReq(STranslateContext* pCxt, SAlterTableStmt* pS return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_ALTER_TABLE, "Invalid tag name: %s", pStmt->colName); } - pReq->tagName = taosStrdup(pStmt->colName); if (NULL == pReq->tagName) { return TSDB_CODE_OUT_OF_MEMORY; } + pReq->pTagArray = taosArrayInit(1, sizeof(STagVal)); + if (NULL == pReq->pTagArray) { + return TSDB_CODE_OUT_OF_MEMORY; + } pReq->colId = pSchema->colId; + pReq->tagType = pSchema->type; - SDataType targetDt = schemaToDataType(pTableMeta->tableInfo.precision, pSchema); + int32_t code = 0; - if (QUERY_NODE_VALUE != pStmt->pVal->node.type) { - SValueNode* pVal = NULL; - pCxt->errCode = createTagValFromExpr(pCxt, targetDt, (SNode*)pStmt->pVal, &pVal); - if (pCxt->errCode) { - return pCxt->errCode; - } - - nodesDestroyNode((SNode*)pStmt->pVal); - pStmt->pVal = pVal; - } else if (DEAL_RES_ERROR == translateValueImpl(pCxt, pStmt->pVal, targetDt, true)) { - return pCxt->errCode; - } - - pReq->tagType = targetDt.type; - if (targetDt.type == TSDB_DATA_TYPE_JSON) { - if (pStmt->pVal->literal && - strlen(pStmt->pVal->literal) > (TSDB_MAX_JSON_TAG_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE) { - return buildSyntaxErrMsg(&pCxt->msgBuf, "json string too long than 4095", pStmt->pVal->literal); - } - SArray* pTagVals = taosArrayInit(1, sizeof(STagVal)); - int32_t code = TSDB_CODE_SUCCESS; - STag* pTag = NULL; - code = parseJsontoTagData(pStmt->pVal->literal, pTagVals, &pTag, &pCxt->msgBuf); - taosArrayDestroy(pTagVals); - if (code != TSDB_CODE_SUCCESS) { - return code; - } - pReq->nTagVal = pTag->len; - pReq->pTagVal = (uint8_t*)pTag; - pStmt->pVal->datum.p = (char*)pTag; // for free - } else { - pReq->isNull = pStmt->pVal->isNull; - pReq->nTagVal = pStmt->pVal->node.resType.bytes; - pReq->pTagVal = nodesGetValueFromNode(pStmt->pVal); - - // data and length are seperated for new tag format STagVal - if (IS_VAR_DATA_TYPE(pStmt->pVal->node.resType.type)) { - pReq->nTagVal = varDataLen(pReq->pTagVal); - pReq->pTagVal = varDataVal(pReq->pTagVal); + STag* pTag = NULL; + SToken token; + char tokenBuf[TSDB_MAX_TAGS_LEN]; + const char* tagStr = pStmt->pVal->literal; + NEXT_TOKEN_WITH_PREV(tagStr, token); + if (TSDB_CODE_SUCCESS == code) { + code = checkAndTrimValue(&token, tokenBuf, &pCxt->msgBuf, pSchema->type); + if (TSDB_CODE_SUCCESS == code && TK_NK_VARIABLE == token.type) { + code = buildSyntaxErrMsg(&pCxt->msgBuf, "not expected tags values", token.z); } } - return TSDB_CODE_SUCCESS; + if (TSDB_CODE_SUCCESS == code) { + code = parseTagValue(&pCxt->msgBuf, &tagStr, pTableMeta->tableInfo.precision, pSchema, &token, NULL, + pReq->pTagArray, &pTag); + } + if (TSDB_CODE_SUCCESS == code && tagStr) { + NEXT_VALID_TOKEN(tagStr, token); + if (token.n != 0) { + code = buildSyntaxErrMsg(&pCxt->msgBuf, "not expected tags values", token.z); + } + } + + if (TSDB_CODE_SUCCESS == code) { + if (pSchema->type == TSDB_DATA_TYPE_JSON) { + pReq->nTagVal = pTag->len; + pReq->pTagVal = (uint8_t*)pTag; + pStmt->pVal->datum.p = (char*)pTag; // for free + } else { + STagVal* pTagVal = taosArrayGet(pReq->pTagArray, 0); + if (pTagVal) { + pReq->isNull = false; + if (IS_VAR_DATA_TYPE(pSchema->type)) { + pReq->nTagVal = pTagVal->nData; + pReq->pTagVal = pTagVal->pData; + } else { + pReq->nTagVal = pSchema->bytes; + pReq->pTagVal = (uint8_t*)&pTagVal->i64; + } + } else { + pReq->isNull = true; + } + } + } + + return code; } static int32_t buildAddColReq(STranslateContext* pCxt, SAlterTableStmt* pStmt, STableMeta* pTableMeta, @@ -10742,6 +10696,13 @@ static void destoryAlterTbReq(SVAlterTbReq* pReq) { taosMemoryFree(pReq->colNewName); taosMemoryFree(pReq->tagName); taosMemoryFree(pReq->newComment); + for (int i = 0; i < taosArrayGetSize(pReq->pTagArray); ++i) { + STagVal* p = (STagVal*)taosArrayGet(pReq->pTagArray, i); + if (IS_VAR_DATA_TYPE(p->type)) { + taosMemoryFreeClear(p->pData); + } + } + taosArrayDestroy(pReq->pTagArray); } static int32_t rewriteAlterTableImpl(STranslateContext* pCxt, SAlterTableStmt* pStmt, STableMeta* pTableMeta, diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c index 9833c8151b..b6ca2c75f4 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 @@ -41,361 +42,11 @@ #define YYSTACKDEPTH 0 /**************** 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_NK_COMMA 33 -#define TK_HOST 34 -#define TK_USER 35 -#define TK_ENABLE 36 -#define TK_NK_INTEGER 37 -#define TK_SYSINFO 38 -#define TK_ADD 39 -#define TK_DROP 40 -#define TK_GRANT 41 -#define TK_ON 42 -#define TK_TO 43 -#define TK_REVOKE 44 -#define TK_FROM 45 -#define TK_SUBSCRIBE 46 -#define TK_READ 47 -#define TK_WRITE 48 -#define TK_NK_DOT 49 -#define TK_WITH 50 -#define TK_DNODE 51 -#define TK_PORT 52 -#define TK_DNODES 53 -#define TK_RESTORE 54 -#define TK_NK_IPTOKEN 55 -#define TK_FORCE 56 -#define TK_UNSAFE 57 -#define TK_CLUSTER 58 -#define TK_LOCAL 59 -#define TK_QNODE 60 -#define TK_BNODE 61 -#define TK_SNODE 62 -#define TK_MNODE 63 -#define TK_VNODE 64 -#define TK_DATABASE 65 -#define TK_USE 66 -#define TK_FLUSH 67 -#define TK_TRIM 68 -#define TK_COMPACT 69 -#define TK_IF 70 -#define TK_NOT 71 -#define TK_EXISTS 72 -#define TK_BUFFER 73 -#define TK_CACHEMODEL 74 -#define TK_CACHESIZE 75 -#define TK_COMP 76 -#define TK_DURATION 77 -#define TK_NK_VARIABLE 78 -#define TK_MAXROWS 79 -#define TK_MINROWS 80 -#define TK_KEEP 81 -#define TK_PAGES 82 -#define TK_PAGESIZE 83 -#define TK_TSDB_PAGESIZE 84 -#define TK_PRECISION 85 -#define TK_REPLICA 86 -#define TK_VGROUPS 87 -#define TK_SINGLE_STABLE 88 -#define TK_RETENTIONS 89 -#define TK_SCHEMALESS 90 -#define TK_WAL_LEVEL 91 -#define TK_WAL_FSYNC_PERIOD 92 -#define TK_WAL_RETENTION_PERIOD 93 -#define TK_WAL_RETENTION_SIZE 94 -#define TK_WAL_ROLL_PERIOD 95 -#define TK_WAL_SEGMENT_SIZE 96 -#define TK_STT_TRIGGER 97 -#define TK_TABLE_PREFIX 98 -#define TK_TABLE_SUFFIX 99 -#define TK_KEEP_TIME_OFFSET 100 -#define TK_NK_COLON 101 -#define TK_BWLIMIT 102 -#define TK_START 103 -#define TK_TIMESTAMP 104 -#define TK_END 105 -#define TK_TABLE 106 -#define TK_NK_LP 107 -#define TK_NK_RP 108 -#define TK_STABLE 109 -#define TK_COLUMN 110 -#define TK_MODIFY 111 -#define TK_RENAME 112 -#define TK_TAG 113 -#define TK_SET 114 -#define TK_NK_EQ 115 -#define TK_USING 116 -#define TK_TAGS 117 -#define TK_BOOL 118 -#define TK_TINYINT 119 -#define TK_SMALLINT 120 -#define TK_INT 121 -#define TK_INTEGER 122 -#define TK_BIGINT 123 -#define TK_FLOAT 124 -#define TK_DOUBLE 125 -#define TK_BINARY 126 -#define TK_NCHAR 127 -#define TK_UNSIGNED 128 -#define TK_JSON 129 -#define TK_VARCHAR 130 -#define TK_MEDIUMBLOB 131 -#define TK_BLOB 132 -#define TK_VARBINARY 133 -#define TK_GEOMETRY 134 -#define TK_DECIMAL 135 -#define TK_COMMENT 136 -#define TK_MAX_DELAY 137 -#define TK_WATERMARK 138 -#define TK_ROLLUP 139 -#define TK_TTL 140 -#define TK_SMA 141 -#define TK_DELETE_MARK 142 -#define TK_FIRST 143 -#define TK_LAST 144 -#define TK_SHOW 145 -#define TK_PRIVILEGES 146 -#define TK_DATABASES 147 -#define TK_TABLES 148 -#define TK_STABLES 149 -#define TK_MNODES 150 -#define TK_QNODES 151 -#define TK_FUNCTIONS 152 -#define TK_INDEXES 153 -#define TK_ACCOUNTS 154 -#define TK_APPS 155 -#define TK_CONNECTIONS 156 -#define TK_LICENCES 157 -#define TK_GRANTS 158 -#define TK_FULL 159 -#define TK_LOGS 160 -#define TK_MACHINES 161 -#define TK_QUERIES 162 -#define TK_SCORES 163 -#define TK_TOPICS 164 -#define TK_VARIABLES 165 -#define TK_BNODES 166 -#define TK_SNODES 167 -#define TK_TRANSACTIONS 168 -#define TK_DISTRIBUTED 169 -#define TK_CONSUMERS 170 -#define TK_SUBSCRIPTIONS 171 -#define TK_VNODES 172 -#define TK_ALIVE 173 -#define TK_VIEWS 174 -#define TK_VIEW 175 -#define TK_COMPACTS 176 -#define TK_NORMAL 177 -#define TK_CHILD 178 -#define TK_LIKE 179 -#define TK_TBNAME 180 -#define TK_QTAGS 181 -#define TK_AS 182 -#define TK_SYSTEM 183 -#define TK_INDEX 184 -#define TK_FUNCTION 185 -#define TK_INTERVAL 186 -#define TK_COUNT 187 -#define TK_LAST_ROW 188 -#define TK_META 189 -#define TK_ONLY 190 -#define TK_TOPIC 191 -#define TK_CONSUMER 192 -#define TK_GROUP 193 -#define TK_DESC 194 -#define TK_DESCRIBE 195 -#define TK_RESET 196 -#define TK_QUERY 197 -#define TK_CACHE 198 -#define TK_EXPLAIN 199 -#define TK_ANALYZE 200 -#define TK_VERBOSE 201 -#define TK_NK_BOOL 202 -#define TK_RATIO 203 -#define TK_NK_FLOAT 204 -#define TK_OUTPUTTYPE 205 -#define TK_AGGREGATE 206 -#define TK_BUFSIZE 207 -#define TK_LANGUAGE 208 -#define TK_REPLACE 209 -#define TK_STREAM 210 -#define TK_INTO 211 -#define TK_PAUSE 212 -#define TK_RESUME 213 -#define TK_TRIGGER 214 -#define TK_AT_ONCE 215 -#define TK_WINDOW_CLOSE 216 -#define TK_IGNORE 217 -#define TK_EXPIRED 218 -#define TK_FILL_HISTORY 219 -#define TK_UPDATE 220 -#define TK_SUBTABLE 221 -#define TK_UNTREATED 222 -#define TK_KILL 223 -#define TK_CONNECTION 224 -#define TK_TRANSACTION 225 -#define TK_BALANCE 226 -#define TK_VGROUP 227 -#define TK_LEADER 228 -#define TK_MERGE 229 -#define TK_REDISTRIBUTE 230 -#define TK_SPLIT 231 -#define TK_DELETE 232 -#define TK_INSERT 233 -#define TK_NULL 234 -#define TK_NK_QUESTION 235 -#define TK_NK_ALIAS 236 -#define TK_NK_ARROW 237 -#define TK_ROWTS 238 -#define TK_QSTART 239 -#define TK_QEND 240 -#define TK_QDURATION 241 -#define TK_WSTART 242 -#define TK_WEND 243 -#define TK_WDURATION 244 -#define TK_IROWTS 245 -#define TK_ISFILLED 246 -#define TK_CAST 247 -#define TK_NOW 248 -#define TK_TODAY 249 -#define TK_TIMEZONE 250 -#define TK_CLIENT_VERSION 251 -#define TK_SERVER_VERSION 252 -#define TK_SERVER_STATUS 253 -#define TK_CURRENT_USER 254 -#define TK_CASE 255 -#define TK_WHEN 256 -#define TK_THEN 257 -#define TK_ELSE 258 -#define TK_BETWEEN 259 -#define TK_IS 260 -#define TK_NK_LT 261 -#define TK_NK_GT 262 -#define TK_NK_LE 263 -#define TK_NK_GE 264 -#define TK_NK_NE 265 -#define TK_MATCH 266 -#define TK_NMATCH 267 -#define TK_CONTAINS 268 -#define TK_IN 269 -#define TK_JOIN 270 -#define TK_INNER 271 -#define TK_SELECT 272 -#define TK_NK_HINT 273 -#define TK_DISTINCT 274 -#define TK_WHERE 275 -#define TK_PARTITION 276 -#define TK_BY 277 -#define TK_SESSION 278 -#define TK_STATE_WINDOW 279 -#define TK_EVENT_WINDOW 280 -#define TK_COUNT_WINDOW 281 -#define TK_SLIDING 282 -#define TK_FILL 283 -#define TK_VALUE 284 -#define TK_VALUE_F 285 -#define TK_NONE 286 -#define TK_PREV 287 -#define TK_NULL_F 288 -#define TK_LINEAR 289 -#define TK_NEXT 290 -#define TK_HAVING 291 -#define TK_RANGE 292 -#define TK_EVERY 293 -#define TK_ORDER 294 -#define TK_SLIMIT 295 -#define TK_SOFFSET 296 -#define TK_LIMIT 297 -#define TK_OFFSET 298 -#define TK_ASC 299 -#define TK_NULLS 300 -#define TK_ABORT 301 -#define TK_AFTER 302 -#define TK_ATTACH 303 -#define TK_BEFORE 304 -#define TK_BEGIN 305 -#define TK_BITAND 306 -#define TK_BITNOT 307 -#define TK_BITOR 308 -#define TK_BLOCKS 309 -#define TK_CHANGE 310 -#define TK_COMMA 311 -#define TK_CONCAT 312 -#define TK_CONFLICT 313 -#define TK_COPY 314 -#define TK_DEFERRED 315 -#define TK_DELIMITERS 316 -#define TK_DETACH 317 -#define TK_DIVIDE 318 -#define TK_DOT 319 -#define TK_EACH 320 -#define TK_FAIL 321 -#define TK_FILE 322 -#define TK_FOR 323 -#define TK_GLOB 324 -#define TK_ID 325 -#define TK_IMMEDIATE 326 -#define TK_IMPORT 327 -#define TK_INITIALLY 328 -#define TK_INSTEAD 329 -#define TK_ISNULL 330 -#define TK_KEY 331 -#define TK_MODULES 332 -#define TK_NK_BITNOT 333 -#define TK_NK_SEMI 334 -#define TK_NOTNULL 335 -#define TK_OF 336 -#define TK_PLUS 337 -#define TK_PRIVILEGE 338 -#define TK_RAISE 339 -#define TK_RESTRICT 340 -#define TK_ROW 341 -#define TK_SEMI 342 -#define TK_STAR 343 -#define TK_STATEMENT 344 -#define TK_STRICT 345 -#define TK_STRING 346 -#define TK_TIMES 347 -#define TK_VALUES 348 -#define TK_VARIABLE 349 -#define TK_WAL 350 -#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. @@ -453,29 +104,29 @@ #endif /************* Begin control #defines *****************************************/ #define YYCODETYPE unsigned short int -#define YYNOCODE 512 +#define YYNOCODE 514 #define YYACTIONTYPE unsigned short int #define ParseTOKENTYPE SToken typedef union { int yyinit; ParseTOKENTYPE yy0; - STokenPair yy57; - int64_t yy221; - EOperatorType yy252; - EShowKind yy321; - bool yy345; - EFillMode yy358; - SNode* yy360; - SNodeList* yy536; - int32_t yy580; - ENullOrder yy585; - EJoinType yy596; - EOrder yy642; - int8_t yy695; - SAlterOption yy797; - SDataType yy912; - SToken yy929; - SShowTablesOption yy1005; + SNode* yy20; + SShowTablesOption yy105; + int64_t yy181; + EOperatorType yy232; + int8_t yy247; + int32_t yy252; + EShowKind yy277; + SDataType yy324; + EOrder yy398; + EJoinType yy432; + SAlterOption yy489; + STokenPair yy577; + SToken yy621; + EFillMode yy690; + bool yy709; + ENullOrder yy929; + SNodeList* yy1008; } YYMINORTYPE; #ifndef YYSTACKDEPTH #define YYSTACKDEPTH 100 @@ -491,18 +142,18 @@ typedef union { #define ParseCTX_FETCH #define ParseCTX_STORE #define YYFALLBACK 1 -#define YYNSTATE 852 -#define YYNRULE 649 -#define YYNRULE_WITH_ACTION 649 +#define YYNSTATE 859 +#define YYNRULE 664 +#define YYNRULE_WITH_ACTION 664 #define YYNTOKEN 351 -#define YY_MAX_SHIFT 851 -#define YY_MIN_SHIFTREDUCE 1256 -#define YY_MAX_SHIFTREDUCE 1904 -#define YY_ERROR_ACTION 1905 -#define YY_ACCEPT_ACTION 1906 -#define YY_NO_ACTION 1907 -#define YY_MIN_REDUCE 1908 -#define YY_MAX_REDUCE 2556 +#define YY_MAX_SHIFT 858 +#define YY_MIN_SHIFTREDUCE 1275 +#define YY_MAX_SHIFTREDUCE 1938 +#define YY_ERROR_ACTION 1939 +#define YY_ACCEPT_ACTION 1940 +#define YY_NO_ACTION 1941 +#define YY_MIN_REDUCE 1942 +#define YY_MAX_REDUCE 2605 /************* End control #defines *******************************************/ #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) @@ -569,618 +220,636 @@ typedef union { ** yy_default[] Default action for each state. ** *********** Begin parsing tables **********************************************/ -#define YY_ACTTAB_COUNT (2941) +#define YY_ACTTAB_COUNT (3128) static const YYACTIONTYPE yy_action[] = { - /* 0 */ 95, 2332, 567, 2151, 468, 568, 1951, 14, 13, 467, - /* 10 */ 2185, 2315, 48, 46, 1826, 2340, 2532, 387, 723, 2527, - /* 20 */ 419, 699, 1667, 41, 40, 2336, 2093, 47, 45, 44, - /* 30 */ 43, 42, 174, 647, 1920, 1752, 1994, 1665, 2531, 737, - /* 40 */ 2098, 704, 2528, 2530, 2527, 2356, 38, 321, 645, 584, - /* 50 */ 643, 270, 269, 1696, 675, 716, 146, 2527, 719, 137, - /* 60 */ 112, 675, 703, 203, 2527, 1747, 610, 2528, 705, 2338, - /* 70 */ 416, 19, 739, 2236, 2418, 2533, 203, 147, 1673, 747, - /* 80 */ 2528, 705, 2533, 203, 2236, 2090, 2374, 2528, 705, 41, - /* 90 */ 40, 2234, 724, 47, 45, 44, 43, 42, 2322, 412, - /* 100 */ 753, 587, 2233, 724, 848, 585, 2229, 15, 475, 823, - /* 110 */ 822, 821, 820, 431, 1795, 819, 818, 151, 813, 812, - /* 120 */ 811, 810, 809, 808, 807, 150, 801, 800, 799, 430, - /* 130 */ 429, 796, 795, 794, 183, 182, 793, 2074, 1322, 2355, - /* 140 */ 1321, 63, 2393, 1754, 1755, 114, 2357, 757, 2359, 2360, - /* 150 */ 752, 1692, 747, 534, 532, 142, 367, 186, 575, 2446, - /* 160 */ 217, 568, 1951, 415, 2442, 301, 2454, 715, 572, 138, - /* 170 */ 714, 511, 2527, 1323, 569, 510, 184, 2151, 205, 2532, - /* 180 */ 1727, 1737, 2527, 509, 383, 736, 2476, 1753, 1756, 1870, - /* 190 */ 703, 203, 2149, 716, 146, 2528, 705, 1908, 385, 52, - /* 200 */ 2216, 2531, 1668, 63, 1666, 2528, 2529, 792, 196, 1901, - /* 210 */ 1692, 41, 40, 2145, 2146, 47, 45, 44, 43, 42, - /* 220 */ 2138, 136, 135, 134, 133, 132, 131, 130, 129, 128, - /* 230 */ 736, 484, 2212, 528, 1671, 1672, 1724, 1724, 1726, 1729, - /* 240 */ 1730, 1731, 1732, 1733, 1734, 1735, 1736, 749, 745, 1745, - /* 250 */ 1746, 1748, 1749, 1750, 1751, 2, 48, 46, 1325, 1326, - /* 260 */ 1693, 365, 704, 1690, 419, 2527, 1667, 428, 427, 1697, - /* 270 */ 518, 238, 2356, 537, 377, 570, 658, 1959, 536, 1752, - /* 280 */ 219, 1665, 223, 703, 203, 751, 273, 240, 2528, 705, - /* 290 */ 272, 570, 1674, 1959, 498, 228, 538, 466, 1696, 465, - /* 300 */ 698, 366, 500, 202, 2454, 2455, 305, 144, 2459, 1747, - /* 310 */ 1931, 659, 478, 2374, 1900, 19, 1460, 51, 1781, 527, - /* 320 */ 227, 452, 1673, 90, 274, 2322, 89, 753, 2374, 464, - /* 330 */ 1451, 782, 781, 780, 1455, 779, 1457, 1458, 778, 775, - /* 340 */ 583, 1466, 772, 1468, 1469, 769, 766, 763, 848, 386, - /* 350 */ 1693, 15, 790, 161, 160, 787, 786, 785, 158, 98, - /* 360 */ 486, 1997, 372, 2322, 305, 398, 2355, 649, 305, 2393, - /* 370 */ 1566, 1567, 357, 2357, 757, 2359, 2360, 752, 750, 747, - /* 380 */ 738, 2411, 1782, 1586, 1587, 577, 2275, 1754, 1755, 697, - /* 390 */ 2223, 2202, 88, 525, 524, 523, 522, 517, 516, 515, - /* 400 */ 514, 369, 1635, 1636, 1930, 504, 503, 502, 501, 495, - /* 410 */ 494, 493, 2532, 488, 487, 384, 184, 737, 2098, 479, - /* 420 */ 1554, 1555, 716, 146, 1727, 1737, 1573, 1585, 1588, 1695, - /* 430 */ 2461, 1753, 1756, 1695, 629, 628, 627, 137, 716, 146, - /* 440 */ 2217, 619, 143, 623, 615, 1305, 1668, 622, 1666, 456, - /* 450 */ 1696, 1691, 621, 626, 393, 392, 2458, 2322, 620, 1677, - /* 460 */ 194, 616, 37, 417, 1776, 1777, 1778, 1779, 1780, 1784, - /* 470 */ 1785, 1786, 1787, 1495, 1496, 792, 458, 454, 1671, 1672, - /* 480 */ 1724, 744, 1726, 1729, 1730, 1731, 1732, 1733, 1734, 1735, - /* 490 */ 1736, 749, 745, 1745, 1746, 1748, 1749, 1750, 1751, 2, - /* 500 */ 12, 48, 46, 2356, 1322, 2332, 1321, 736, 2531, 419, - /* 510 */ 2075, 1667, 422, 1823, 1697, 256, 754, 1894, 424, 2089, - /* 520 */ 168, 2144, 2146, 2151, 1752, 1929, 1665, 400, 2100, 2336, - /* 530 */ 399, 179, 204, 2454, 2455, 2149, 144, 2459, 2149, 1323, - /* 540 */ 604, 600, 596, 592, 2374, 255, 106, 718, 201, 2454, - /* 550 */ 2455, 1303, 144, 2459, 1747, 12, 2322, 2151, 753, 656, - /* 560 */ 19, 629, 628, 627, 409, 3, 694, 1673, 619, 143, - /* 570 */ 623, 2091, 2149, 2338, 622, 1301, 1302, 54, 2322, 621, - /* 580 */ 626, 393, 392, 747, 1859, 620, 96, 1692, 616, 253, - /* 590 */ 12, 303, 10, 848, 51, 303, 15, 2355, 737, 2098, - /* 600 */ 2393, 2356, 95, 114, 2357, 757, 2359, 2360, 752, 741, - /* 610 */ 747, 2418, 198, 149, 754, 156, 2417, 2446, 492, 41, - /* 620 */ 40, 415, 2442, 47, 45, 44, 43, 42, 2094, 2332, - /* 630 */ 1415, 1696, 1754, 1755, 691, 690, 1857, 1858, 1860, 1861, - /* 640 */ 1862, 1928, 2374, 2341, 1773, 1414, 790, 161, 160, 787, - /* 650 */ 786, 785, 158, 2336, 2322, 243, 753, 1909, 700, 695, - /* 660 */ 688, 684, 490, 2212, 252, 245, 1697, 520, 2212, 1727, - /* 670 */ 1737, 250, 581, 1927, 63, 659, 1753, 1756, 127, 68, - /* 680 */ 2303, 126, 125, 124, 123, 122, 121, 120, 119, 118, - /* 690 */ 242, 1668, 173, 1666, 2322, 2355, 806, 2338, 2393, 2059, - /* 700 */ 2037, 114, 2357, 757, 2359, 2360, 752, 747, 747, 564, - /* 710 */ 1926, 221, 539, 2421, 2316, 2446, 226, 1673, 562, 415, - /* 720 */ 2442, 558, 554, 1671, 1672, 1724, 2322, 1726, 1729, 1730, - /* 730 */ 1731, 1732, 1733, 1734, 1735, 1736, 749, 745, 1745, 1746, - /* 740 */ 1748, 1749, 1750, 1751, 2, 48, 46, 1757, 2356, 661, - /* 750 */ 2275, 737, 2098, 419, 2284, 1667, 654, 312, 313, 305, - /* 760 */ 159, 719, 311, 2322, 675, 1936, 843, 2527, 1752, 127, - /* 770 */ 1665, 208, 126, 125, 124, 123, 122, 121, 120, 119, - /* 780 */ 118, 2356, 63, 1822, 413, 2533, 203, 737, 2098, 2374, - /* 790 */ 2528, 705, 171, 199, 754, 2151, 1961, 326, 1747, 707, - /* 800 */ 2100, 2322, 414, 753, 737, 2098, 675, 56, 275, 2527, - /* 810 */ 2149, 1673, 41, 40, 2151, 422, 47, 45, 44, 43, - /* 820 */ 42, 423, 2374, 171, 472, 606, 605, 2533, 203, 2149, - /* 830 */ 425, 2100, 2528, 705, 2322, 55, 753, 848, 171, 305, - /* 840 */ 49, 9, 2355, 737, 2098, 2393, 2100, 1697, 114, 2357, - /* 850 */ 757, 2359, 2360, 752, 1925, 747, 2356, 1924, 783, 1667, - /* 860 */ 186, 1296, 2446, 473, 171, 1923, 415, 2442, 2461, 754, - /* 870 */ 737, 2098, 2101, 1922, 1665, 2355, 1754, 1755, 2393, 2073, - /* 880 */ 1303, 114, 2357, 757, 2359, 2360, 752, 1919, 747, 2477, - /* 890 */ 505, 636, 1830, 2547, 2457, 2446, 1762, 2374, 1692, 415, - /* 900 */ 2442, 197, 1692, 1298, 1301, 1302, 648, 2322, 210, 2322, - /* 910 */ 2322, 753, 1842, 1727, 1737, 1673, 737, 2098, 2322, 2306, - /* 920 */ 1753, 1756, 271, 41, 40, 1692, 2322, 47, 45, 44, - /* 930 */ 43, 42, 44, 43, 42, 1668, 506, 1666, 639, 1851, - /* 940 */ 2322, 848, 674, 625, 624, 633, 631, 305, 30, 2151, - /* 950 */ 2355, 1403, 268, 2393, 1852, 660, 176, 2357, 757, 2359, - /* 960 */ 2360, 752, 2087, 747, 732, 608, 607, 1671, 1672, 1724, - /* 970 */ 441, 1726, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, - /* 980 */ 749, 745, 1745, 1746, 1748, 1749, 1750, 1751, 2, 48, - /* 990 */ 46, 2083, 1405, 72, 1918, 1850, 71, 419, 1917, 1667, - /* 1000 */ 47, 45, 44, 43, 42, 675, 1916, 1915, 2527, 2085, - /* 1010 */ 706, 2548, 1752, 2151, 1665, 790, 161, 160, 787, 786, - /* 1020 */ 785, 158, 1914, 1871, 1913, 2356, 2533, 203, 2150, 41, - /* 1030 */ 40, 2528, 705, 47, 45, 44, 43, 42, 754, 1668, - /* 1040 */ 2484, 1666, 1747, 1783, 737, 2098, 1692, 2322, 2356, 737, - /* 1050 */ 2098, 2322, 1419, 737, 2098, 1673, 737, 2098, 1728, 2322, - /* 1060 */ 2322, 754, 1728, 2497, 507, 148, 2374, 1418, 2417, 586, - /* 1070 */ 1815, 1671, 1672, 2095, 61, 2322, 276, 2322, 2322, 76, - /* 1080 */ 753, 848, 672, 2356, 49, 1728, 614, 41, 40, 2374, - /* 1090 */ 613, 47, 45, 44, 43, 42, 754, 708, 686, 34, - /* 1100 */ 2169, 2322, 2081, 753, 784, 41, 40, 2142, 1912, 47, - /* 1110 */ 45, 44, 43, 42, 1725, 737, 2098, 803, 1725, 2355, - /* 1120 */ 1754, 1755, 2393, 35, 2374, 114, 2357, 757, 2359, 2360, - /* 1130 */ 752, 87, 747, 1788, 541, 284, 2322, 2547, 753, 2446, - /* 1140 */ 711, 1725, 2355, 415, 2442, 2393, 1981, 99, 114, 2357, - /* 1150 */ 757, 2359, 2360, 752, 2195, 747, 1911, 1727, 1737, 1676, - /* 1160 */ 2547, 2322, 2446, 1675, 1753, 1756, 415, 2442, 630, 737, - /* 1170 */ 2098, 737, 2098, 788, 737, 2098, 2142, 2355, 1614, 1668, - /* 1180 */ 2393, 1666, 805, 114, 2357, 757, 2359, 2360, 752, 322, - /* 1190 */ 747, 722, 720, 36, 316, 2547, 482, 2446, 139, 41, - /* 1200 */ 40, 415, 2442, 47, 45, 44, 43, 42, 2102, 2322, - /* 1210 */ 86, 1671, 1672, 1724, 281, 1726, 1729, 1730, 1731, 1732, - /* 1220 */ 1733, 1734, 1735, 1736, 749, 745, 1745, 1746, 1748, 1749, - /* 1230 */ 1750, 1751, 2, 48, 46, 391, 390, 737, 2098, 2461, - /* 1240 */ 2076, 419, 675, 1667, 159, 2527, 737, 2098, 817, 815, - /* 1250 */ 737, 2098, 789, 2466, 1815, 2142, 1752, 734, 1665, 513, - /* 1260 */ 512, 170, 1725, 2533, 203, 2456, 735, 159, 2528, 705, - /* 1270 */ 426, 335, 261, 152, 2128, 259, 2356, 263, 265, 617, - /* 1280 */ 262, 264, 267, 1979, 1970, 266, 1747, 618, 682, 754, - /* 1290 */ 1968, 2520, 651, 285, 650, 2343, 50, 50, 1921, 1673, - /* 1300 */ 1903, 1904, 748, 1400, 1358, 632, 634, 389, 388, 187, - /* 1310 */ 612, 1398, 637, 14, 13, 2038, 2490, 2374, 172, 1630, - /* 1320 */ 298, 159, 50, 341, 310, 848, 1679, 797, 15, 2322, - /* 1330 */ 1678, 753, 614, 692, 2356, 75, 613, 100, 292, 157, - /* 1340 */ 339, 74, 1633, 159, 73, 1359, 66, 754, 141, 2465, - /* 1350 */ 111, 1377, 50, 2345, 368, 50, 2375, 761, 157, 108, - /* 1360 */ 709, 798, 2035, 1846, 1754, 1755, 236, 549, 547, 544, - /* 1370 */ 2355, 1856, 1855, 2393, 159, 2374, 114, 2357, 757, 2359, - /* 1380 */ 2360, 752, 2034, 747, 290, 1375, 2221, 2322, 2547, 753, - /* 1390 */ 2446, 1962, 1952, 2480, 415, 2442, 721, 1583, 689, 314, - /* 1400 */ 405, 1727, 1737, 140, 157, 712, 696, 63, 1753, 1756, - /* 1410 */ 729, 401, 432, 2222, 318, 1958, 2139, 2481, 1445, 726, - /* 1420 */ 2491, 1789, 668, 1668, 717, 1666, 300, 1738, 2355, 297, - /* 1430 */ 334, 2393, 1473, 1477, 114, 2357, 757, 2359, 2360, 752, - /* 1440 */ 2060, 747, 304, 841, 5, 64, 2547, 435, 2446, 1484, - /* 1450 */ 440, 381, 415, 2442, 448, 1671, 1672, 1724, 449, 1726, - /* 1460 */ 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 749, 745, - /* 1470 */ 1745, 1746, 1748, 1749, 1750, 1751, 2, 1700, 1482, 162, - /* 1480 */ 460, 428, 427, 211, 2356, 459, 212, 462, 214, 329, - /* 1490 */ 1690, 1681, 1607, 476, 84, 83, 471, 754, 1691, 216, - /* 1500 */ 483, 225, 485, 489, 1752, 491, 1674, 2356, 530, 496, - /* 1510 */ 508, 2214, 463, 461, 519, 521, 526, 543, 529, 531, - /* 1520 */ 754, 542, 540, 364, 231, 2374, 450, 230, 545, 447, - /* 1530 */ 443, 439, 436, 464, 1747, 1698, 1906, 2322, 546, 753, - /* 1540 */ 233, 548, 2356, 550, 4, 565, 566, 1673, 2374, 573, - /* 1550 */ 574, 576, 1693, 241, 92, 754, 244, 578, 1699, 1701, - /* 1560 */ 2322, 579, 753, 580, 247, 582, 1702, 249, 588, 93, - /* 1570 */ 94, 609, 305, 743, 2230, 254, 640, 611, 2355, 2088, - /* 1580 */ 116, 2393, 641, 2374, 114, 2357, 757, 2359, 2360, 752, - /* 1590 */ 361, 747, 97, 258, 2084, 2322, 2419, 753, 2446, 260, - /* 1600 */ 164, 2355, 415, 2442, 2393, 165, 653, 114, 2357, 757, - /* 1610 */ 2359, 2360, 752, 2086, 747, 434, 2293, 2082, 166, 740, - /* 1620 */ 433, 2446, 167, 2290, 2289, 415, 2442, 277, 1694, 663, - /* 1630 */ 662, 282, 693, 667, 669, 670, 2355, 679, 727, 2393, - /* 1640 */ 664, 2356, 115, 2357, 757, 2359, 2360, 752, 8, 747, - /* 1650 */ 330, 153, 655, 280, 754, 2496, 2446, 287, 289, 702, - /* 1660 */ 2445, 2442, 2495, 677, 2468, 675, 291, 2276, 2527, 680, - /* 1670 */ 293, 1682, 2356, 1677, 678, 296, 713, 406, 710, 1815, - /* 1680 */ 1695, 2526, 2374, 145, 1820, 754, 2533, 203, 2462, 190, - /* 1690 */ 1818, 2528, 705, 306, 2322, 331, 753, 332, 730, 2356, - /* 1700 */ 154, 725, 294, 1685, 1687, 2244, 2243, 731, 2242, 155, - /* 1710 */ 411, 178, 754, 2374, 333, 105, 62, 745, 1745, 1746, - /* 1720 */ 1748, 1749, 1750, 1751, 295, 2322, 2099, 753, 1, 206, - /* 1730 */ 2427, 107, 759, 299, 336, 2355, 324, 2143, 2393, 1280, - /* 1740 */ 2374, 115, 2357, 757, 2359, 2360, 752, 842, 747, 2550, - /* 1750 */ 845, 847, 2322, 163, 753, 2446, 345, 2356, 360, 742, - /* 1760 */ 2442, 373, 53, 374, 359, 340, 755, 349, 2314, 2393, - /* 1770 */ 754, 338, 115, 2357, 757, 2359, 2360, 752, 2313, 747, - /* 1780 */ 2312, 81, 2307, 437, 438, 1658, 2446, 1659, 209, 442, - /* 1790 */ 376, 2442, 2356, 2355, 2305, 444, 2393, 445, 2374, 175, - /* 1800 */ 2357, 757, 2359, 2360, 752, 754, 747, 446, 1657, 2304, - /* 1810 */ 2322, 382, 753, 2302, 451, 2301, 453, 2300, 455, 2299, - /* 1820 */ 457, 1646, 2356, 213, 2279, 215, 1610, 82, 1609, 2257, - /* 1830 */ 2256, 2255, 469, 2374, 2280, 754, 470, 2254, 2253, 2204, - /* 1840 */ 474, 676, 2487, 2201, 1553, 2322, 2200, 753, 477, 2194, - /* 1850 */ 481, 2355, 2191, 480, 2393, 218, 2190, 115, 2357, 757, - /* 1860 */ 2359, 2360, 752, 2374, 747, 85, 2189, 2188, 403, 2193, - /* 1870 */ 220, 2446, 2192, 2187, 2186, 2322, 2443, 753, 2184, 2183, - /* 1880 */ 2182, 222, 497, 2181, 499, 2179, 2355, 2356, 2178, 2393, - /* 1890 */ 2177, 2176, 175, 2357, 757, 2359, 2360, 752, 91, 747, - /* 1900 */ 754, 2199, 2356, 2175, 2174, 2173, 2197, 2180, 2172, 2171, - /* 1910 */ 2170, 2168, 2167, 2166, 2165, 754, 2355, 2356, 1559, 2393, - /* 1920 */ 2164, 2163, 358, 2357, 757, 2359, 2360, 752, 2374, 747, - /* 1930 */ 754, 224, 2162, 404, 229, 2488, 2161, 2160, 2159, 2198, - /* 1940 */ 2322, 2196, 753, 2374, 2158, 2157, 2156, 2155, 533, 2154, - /* 1950 */ 535, 2153, 2152, 1416, 2000, 2322, 1412, 753, 2374, 232, - /* 1960 */ 1999, 1998, 1420, 1996, 234, 370, 371, 235, 1993, 553, - /* 1970 */ 2322, 1992, 753, 552, 556, 557, 1985, 560, 1972, 551, - /* 1980 */ 555, 2355, 1947, 185, 2393, 559, 1304, 358, 2357, 757, - /* 1990 */ 2359, 2360, 752, 563, 747, 561, 2355, 2356, 1946, 2393, - /* 2000 */ 237, 78, 351, 2357, 757, 2359, 2360, 752, 239, 747, - /* 2010 */ 754, 2355, 79, 2342, 2393, 2356, 195, 176, 2357, 757, - /* 2020 */ 2359, 2360, 752, 571, 747, 2278, 2274, 2264, 751, 246, - /* 2030 */ 2251, 2228, 248, 251, 2077, 1995, 1991, 589, 2374, 2252, - /* 2040 */ 2356, 1351, 1989, 410, 590, 591, 593, 594, 701, 595, - /* 2050 */ 2322, 1987, 753, 754, 597, 598, 2374, 599, 1984, 601, - /* 2060 */ 603, 602, 1967, 1965, 1966, 1964, 1943, 2079, 2322, 1489, - /* 2070 */ 753, 2078, 2549, 65, 1488, 257, 1388, 1402, 1401, 1982, - /* 2080 */ 1399, 2374, 1397, 1396, 1395, 1394, 418, 1393, 814, 816, - /* 2090 */ 1390, 2355, 394, 2322, 2393, 753, 1389, 358, 2357, 757, - /* 2100 */ 2359, 2360, 752, 1980, 747, 1387, 395, 1971, 396, 2355, - /* 2110 */ 2356, 1969, 2393, 635, 657, 357, 2357, 757, 2359, 2360, - /* 2120 */ 752, 397, 747, 754, 2412, 638, 1942, 1941, 1940, 642, - /* 2130 */ 1939, 644, 851, 1938, 2355, 117, 646, 2393, 1640, 1642, - /* 2140 */ 358, 2357, 757, 2359, 2360, 752, 2356, 747, 328, 1639, - /* 2150 */ 2277, 2374, 1644, 279, 2273, 57, 420, 58, 1616, 754, - /* 2160 */ 1618, 2263, 665, 2322, 193, 753, 1620, 666, 29, 2250, - /* 2170 */ 2249, 169, 1595, 839, 835, 831, 827, 2356, 325, 69, - /* 2180 */ 283, 671, 2532, 1594, 20, 31, 673, 2374, 1873, 286, - /* 2190 */ 754, 1847, 681, 402, 17, 6, 683, 7, 685, 2322, - /* 2200 */ 687, 753, 200, 288, 2355, 21, 22, 2393, 1854, 189, - /* 2210 */ 358, 2357, 757, 2359, 2360, 752, 177, 747, 2374, 113, - /* 2220 */ 2343, 33, 319, 188, 32, 67, 1841, 80, 24, 1888, - /* 2230 */ 2322, 1893, 753, 1894, 1887, 407, 1892, 1891, 408, 1812, - /* 2240 */ 652, 60, 1811, 2393, 2248, 302, 353, 2357, 757, 2359, - /* 2250 */ 2360, 752, 2356, 747, 733, 180, 23, 18, 59, 2227, - /* 2260 */ 102, 728, 2226, 103, 101, 754, 25, 26, 108, 317, - /* 2270 */ 309, 2355, 2356, 1849, 2393, 191, 320, 343, 2357, 757, - /* 2280 */ 2359, 2360, 752, 1764, 747, 754, 1763, 315, 2356, 70, - /* 2290 */ 104, 1683, 13, 2374, 11, 1742, 2396, 308, 746, 181, - /* 2300 */ 39, 754, 1740, 1774, 307, 2322, 192, 753, 1717, 323, - /* 2310 */ 1739, 16, 27, 2374, 756, 1709, 28, 760, 1474, 421, - /* 2320 */ 758, 762, 764, 278, 1471, 2322, 765, 753, 1470, 2374, - /* 2330 */ 767, 768, 770, 1467, 1461, 771, 773, 774, 776, 1459, - /* 2340 */ 777, 2322, 1483, 753, 109, 2356, 2355, 110, 77, 2393, - /* 2350 */ 1479, 1465, 342, 2357, 757, 2359, 2360, 752, 754, 747, - /* 2360 */ 1464, 1384, 791, 1463, 1462, 2356, 2355, 1381, 1349, 2393, - /* 2370 */ 1380, 1379, 344, 2357, 757, 2359, 2360, 752, 754, 747, - /* 2380 */ 1378, 1376, 2355, 2356, 1374, 2393, 2374, 1373, 350, 2357, - /* 2390 */ 757, 2359, 2360, 752, 1372, 747, 754, 1410, 2322, 802, - /* 2400 */ 753, 1409, 207, 2356, 804, 1370, 2374, 1369, 1368, 1367, - /* 2410 */ 1366, 1365, 1364, 1406, 1404, 1361, 754, 1360, 2322, 1357, - /* 2420 */ 753, 1355, 1356, 1354, 2374, 1990, 824, 825, 1988, 828, - /* 2430 */ 826, 1986, 829, 830, 832, 834, 2322, 1983, 753, 2355, - /* 2440 */ 836, 2356, 2393, 838, 2374, 354, 2357, 757, 2359, 2360, - /* 2450 */ 752, 833, 747, 837, 754, 1963, 2322, 840, 753, 2355, - /* 2460 */ 1293, 1937, 2393, 1281, 846, 346, 2357, 757, 2359, 2360, - /* 2470 */ 752, 844, 747, 327, 1669, 337, 850, 2355, 2356, 849, - /* 2480 */ 2393, 1907, 2374, 355, 2357, 757, 2359, 2360, 752, 1907, - /* 2490 */ 747, 754, 1907, 1907, 2322, 1907, 753, 2355, 2356, 1907, - /* 2500 */ 2393, 1907, 1907, 347, 2357, 757, 2359, 2360, 752, 1907, - /* 2510 */ 747, 754, 1907, 1907, 2356, 1907, 1907, 1907, 1907, 2374, - /* 2520 */ 1907, 1907, 1907, 1907, 1907, 1907, 1907, 754, 1907, 1907, - /* 2530 */ 1907, 2322, 1907, 753, 1907, 2355, 1907, 1907, 2393, 2374, - /* 2540 */ 1907, 356, 2357, 757, 2359, 2360, 752, 1907, 747, 1907, - /* 2550 */ 1907, 2322, 1907, 753, 1907, 2374, 1907, 1907, 1907, 1907, - /* 2560 */ 1907, 1907, 1907, 1907, 1907, 1907, 1907, 2322, 1907, 753, - /* 2570 */ 1907, 1907, 2355, 1907, 1907, 2393, 1907, 1907, 348, 2357, - /* 2580 */ 757, 2359, 2360, 752, 1907, 747, 1907, 1907, 1907, 1907, - /* 2590 */ 1907, 1907, 2355, 1907, 1907, 2393, 1907, 1907, 362, 2357, - /* 2600 */ 757, 2359, 2360, 752, 1907, 747, 1907, 2356, 2355, 1907, - /* 2610 */ 1907, 2393, 1907, 1907, 363, 2357, 757, 2359, 2360, 752, - /* 2620 */ 754, 747, 1907, 1907, 1907, 1907, 2356, 1907, 1907, 1907, - /* 2630 */ 1907, 1907, 1907, 1907, 1907, 1907, 1907, 1907, 1907, 754, - /* 2640 */ 1907, 1907, 1907, 2356, 1907, 1907, 1907, 1907, 2374, 1907, - /* 2650 */ 1907, 1907, 1907, 1907, 1907, 1907, 754, 1907, 1907, 1907, - /* 2660 */ 2322, 1907, 753, 1907, 1907, 1907, 1907, 2374, 1907, 1907, - /* 2670 */ 1907, 1907, 1907, 1907, 1907, 1907, 1907, 1907, 1907, 2322, - /* 2680 */ 1907, 753, 1907, 1907, 2374, 1907, 1907, 1907, 1907, 1907, - /* 2690 */ 1907, 1907, 1907, 1907, 1907, 1907, 2322, 1907, 753, 1907, - /* 2700 */ 2356, 2355, 1907, 1907, 2393, 1907, 1907, 2368, 2357, 757, - /* 2710 */ 2359, 2360, 752, 754, 747, 1907, 1907, 1907, 1907, 1907, - /* 2720 */ 2355, 2356, 1907, 2393, 1907, 1907, 2367, 2357, 757, 2359, - /* 2730 */ 2360, 752, 1907, 747, 754, 1907, 1907, 2355, 2356, 1907, - /* 2740 */ 2393, 2374, 1907, 2366, 2357, 757, 2359, 2360, 752, 1907, - /* 2750 */ 747, 754, 1907, 2322, 1907, 753, 1907, 1907, 2356, 1907, - /* 2760 */ 1907, 1907, 2374, 1907, 1907, 1907, 1907, 1907, 1907, 1907, - /* 2770 */ 1907, 754, 1907, 1907, 2322, 1907, 753, 1907, 1907, 2374, - /* 2780 */ 1907, 1907, 1907, 1907, 1907, 1907, 1907, 1907, 1907, 1907, - /* 2790 */ 1907, 2322, 1907, 753, 2355, 1907, 2356, 2393, 1907, 2374, - /* 2800 */ 378, 2357, 757, 2359, 2360, 752, 1907, 747, 1907, 754, - /* 2810 */ 1907, 2322, 1907, 753, 1907, 2355, 1907, 1907, 2393, 1907, - /* 2820 */ 1907, 379, 2357, 757, 2359, 2360, 752, 1907, 747, 1907, - /* 2830 */ 1907, 1907, 2355, 2356, 1907, 2393, 1907, 2374, 375, 2357, - /* 2840 */ 757, 2359, 2360, 752, 1907, 747, 754, 1907, 1907, 2322, - /* 2850 */ 1907, 753, 2355, 1907, 1907, 2393, 1907, 1907, 380, 2357, - /* 2860 */ 757, 2359, 2360, 752, 1907, 747, 1907, 1907, 1907, 1907, - /* 2870 */ 1907, 1907, 1907, 1907, 2374, 1907, 1907, 1907, 1907, 1907, - /* 2880 */ 1907, 1907, 1907, 1907, 1907, 1907, 2322, 1907, 753, 1907, - /* 2890 */ 755, 1907, 1907, 2393, 1907, 1907, 353, 2357, 757, 2359, - /* 2900 */ 2360, 752, 1907, 747, 1907, 1907, 1907, 1907, 1907, 1907, - /* 2910 */ 1907, 1907, 1907, 1907, 1907, 1907, 1907, 1907, 1907, 1907, - /* 2920 */ 1907, 1907, 1907, 1907, 1907, 1907, 1907, 2355, 1907, 1907, - /* 2930 */ 2393, 1907, 1907, 352, 2357, 757, 2359, 2360, 752, 1907, - /* 2940 */ 747, + /* 0 */ 37, 310, 428, 731, 474, 2467, 760, 2132, 2510, 473, + /* 10 */ 169, 704, 47, 45, 1860, 239, 590, 403, 2134, 576, + /* 20 */ 417, 1993, 1700, 40, 39, 2183, 138, 46, 44, 43, + /* 30 */ 42, 41, 2270, 616, 2507, 1786, 2028, 1698, 1725, 2422, + /* 40 */ 40, 39, 653, 2404, 46, 44, 43, 42, 41, 481, + /* 50 */ 2268, 747, 197, 722, 147, 681, 725, 651, 2576, 649, + /* 60 */ 271, 270, 40, 39, 2172, 1781, 46, 44, 43, 42, + /* 70 */ 41, 19, 591, 2263, 593, 174, 2582, 204, 1706, 760, + /* 80 */ 2132, 2577, 711, 2071, 2422, 40, 39, 29, 2581, 46, + /* 90 */ 44, 43, 42, 41, 540, 538, 2370, 370, 742, 138, + /* 100 */ 66, 218, 703, 1965, 855, 1728, 621, 15, 1726, 830, + /* 110 */ 829, 828, 827, 437, 736, 826, 825, 152, 820, 819, + /* 120 */ 818, 817, 816, 815, 814, 151, 808, 807, 806, 436, + /* 130 */ 435, 803, 802, 801, 184, 183, 800, 175, 2403, 1954, + /* 140 */ 1904, 2441, 570, 1788, 1789, 115, 2405, 746, 2407, 2408, + /* 150 */ 741, 568, 764, 2185, 564, 560, 2370, 187, 1885, 2495, + /* 160 */ 402, 2015, 1905, 413, 2491, 302, 2503, 721, 2183, 139, + /* 170 */ 720, 813, 2576, 1886, 2093, 722, 147, 2185, 206, 710, + /* 180 */ 1760, 1770, 2576, 636, 412, 1876, 2525, 1787, 1790, 2380, + /* 190 */ 709, 204, 2183, 1928, 2337, 2577, 711, 1942, 1585, 1586, + /* 200 */ 709, 204, 1701, 62, 1699, 2577, 711, 722, 147, 1935, + /* 210 */ 1817, 40, 39, 2384, 1884, 46, 44, 43, 42, 41, + /* 220 */ 62, 137, 136, 135, 134, 133, 132, 131, 130, 129, + /* 230 */ 1422, 1605, 1606, 620, 1704, 1705, 1757, 619, 1759, 1762, + /* 240 */ 1763, 1764, 1765, 1766, 1767, 1768, 1769, 738, 762, 761, + /* 250 */ 1780, 1782, 1783, 1784, 1785, 2, 47, 45, 2386, 2388, + /* 260 */ 414, 368, 578, 1723, 417, 2270, 1700, 304, 575, 764, + /* 270 */ 524, 1424, 2404, 543, 378, 1604, 1607, 1807, 542, 1786, + /* 280 */ 420, 1698, 1434, 2267, 747, 743, 724, 202, 2503, 2504, + /* 290 */ 34, 145, 2508, 2380, 504, 573, 544, 1433, 574, 1985, + /* 300 */ 1822, 369, 506, 1893, 46, 44, 43, 42, 41, 1781, + /* 310 */ 2179, 2180, 484, 2422, 1934, 19, 1479, 2384, 1815, 203, + /* 320 */ 2503, 2504, 1706, 145, 2508, 2370, 185, 742, 612, 611, + /* 330 */ 1470, 789, 788, 787, 1474, 786, 1476, 1477, 785, 782, + /* 340 */ 759, 1485, 779, 1487, 1488, 776, 773, 770, 855, 389, + /* 350 */ 2251, 15, 1725, 697, 696, 1891, 1892, 1894, 1895, 1896, + /* 360 */ 492, 2031, 2386, 2389, 545, 241, 1864, 2403, 306, 576, + /* 370 */ 2441, 1993, 1725, 764, 176, 2405, 746, 2407, 2408, 741, + /* 380 */ 185, 764, 1816, 2363, 1964, 306, 426, 1788, 1789, 534, + /* 390 */ 2257, 2236, 2203, 531, 530, 529, 528, 523, 522, 521, + /* 400 */ 520, 372, 388, 51, 2250, 510, 509, 508, 507, 501, + /* 410 */ 500, 499, 700, 494, 493, 387, 682, 2536, 2318, 485, + /* 420 */ 1573, 1574, 211, 1726, 1760, 1770, 1592, 50, 490, 2246, + /* 430 */ 2185, 1787, 1790, 96, 635, 634, 633, 2370, 423, 62, + /* 440 */ 1725, 625, 144, 629, 759, 729, 1701, 628, 1699, 764, + /* 450 */ 390, 229, 627, 632, 396, 395, 434, 433, 626, 2127, + /* 460 */ 1963, 622, 36, 415, 1810, 1811, 1812, 1813, 1814, 1818, + /* 470 */ 1819, 1820, 1821, 276, 1729, 533, 228, 220, 1704, 1705, + /* 480 */ 1757, 1707, 1759, 1762, 1763, 1764, 1765, 1766, 1767, 1768, + /* 490 */ 1769, 738, 762, 761, 1780, 1782, 1783, 1784, 1785, 2, + /* 500 */ 12, 47, 45, 2404, 706, 701, 694, 690, 1341, 417, + /* 510 */ 1340, 1700, 2185, 2370, 581, 1940, 743, 574, 1985, 386, + /* 520 */ 224, 635, 634, 633, 1786, 143, 1698, 2183, 625, 144, + /* 530 */ 629, 50, 1761, 12, 628, 10, 2404, 760, 2132, 627, + /* 540 */ 632, 396, 395, 1342, 2422, 626, 1514, 1515, 622, 725, + /* 550 */ 2580, 519, 518, 705, 1781, 1943, 2370, 209, 742, 33, + /* 560 */ 19, 91, 496, 2246, 90, 40, 39, 1706, 306, 46, + /* 570 */ 44, 43, 42, 41, 760, 2132, 128, 2422, 107, 127, + /* 580 */ 126, 125, 124, 123, 122, 121, 120, 119, 1758, 2370, + /* 590 */ 1728, 742, 306, 855, 55, 440, 15, 113, 2403, 710, + /* 600 */ 439, 2441, 2576, 2125, 306, 115, 2405, 746, 2407, 2408, + /* 610 */ 741, 222, 764, 148, 150, 149, 2466, 156, 2466, 2495, + /* 620 */ 709, 204, 2124, 413, 2491, 2577, 711, 760, 2132, 2123, + /* 630 */ 89, 2403, 1788, 1789, 2441, 2109, 195, 2364, 115, 2405, + /* 640 */ 746, 2407, 2408, 741, 759, 764, 681, 478, 1710, 2576, + /* 650 */ 187, 810, 2495, 458, 2510, 128, 413, 2491, 127, 126, + /* 660 */ 125, 124, 123, 122, 121, 120, 119, 2582, 204, 1760, + /* 670 */ 1770, 791, 2577, 711, 2176, 35, 1787, 1790, 2107, 2526, + /* 680 */ 2506, 40, 39, 2219, 423, 46, 44, 43, 42, 41, + /* 690 */ 1730, 1701, 423, 1699, 430, 764, 1962, 2178, 2180, 1725, + /* 700 */ 40, 39, 2185, 764, 46, 44, 43, 42, 41, 422, + /* 710 */ 722, 147, 1729, 2349, 40, 39, 812, 2183, 46, 44, + /* 720 */ 43, 42, 41, 1704, 1705, 1757, 1961, 1759, 1762, 1763, + /* 730 */ 1764, 1765, 1766, 1767, 1768, 1769, 738, 762, 761, 1780, + /* 740 */ 1782, 1783, 1784, 1785, 2, 47, 45, 1791, 2404, 2370, + /* 750 */ 1700, 2185, 304, 417, 1960, 1700, 2581, 1857, 429, 2576, + /* 760 */ 1959, 743, 664, 1995, 681, 1698, 2183, 2576, 1786, 1757, + /* 770 */ 1698, 797, 162, 161, 794, 793, 792, 159, 2580, 2370, + /* 780 */ 2404, 462, 2577, 2579, 421, 2582, 204, 1729, 2350, 2422, + /* 790 */ 2577, 711, 172, 743, 428, 2533, 526, 2246, 1781, 680, + /* 800 */ 2134, 2370, 172, 742, 1322, 665, 1706, 2370, 464, 460, + /* 810 */ 2134, 1706, 2340, 2370, 797, 162, 161, 794, 793, 792, + /* 820 */ 159, 2422, 205, 2503, 2504, 589, 145, 2508, 1320, 1321, + /* 830 */ 1796, 795, 855, 2370, 2176, 742, 1725, 855, 1958, 681, + /* 840 */ 48, 713, 2576, 2403, 517, 227, 2441, 733, 516, 2467, + /* 850 */ 115, 2405, 746, 2407, 2408, 741, 515, 764, 665, 1761, + /* 860 */ 2582, 204, 2596, 447, 2495, 2577, 711, 274, 413, 2491, + /* 870 */ 160, 273, 760, 2132, 200, 2403, 1788, 1789, 2441, 257, + /* 880 */ 583, 2309, 115, 2405, 746, 2407, 2408, 741, 171, 764, + /* 890 */ 2581, 2370, 479, 2576, 2596, 180, 2495, 43, 42, 41, + /* 900 */ 413, 2491, 14, 13, 610, 606, 602, 598, 1729, 256, + /* 910 */ 1344, 1345, 2580, 1760, 1770, 1758, 2577, 2578, 40, 39, + /* 920 */ 1787, 1790, 46, 44, 43, 42, 41, 657, 1730, 656, + /* 930 */ 1701, 60, 1699, 667, 2309, 1701, 799, 1699, 662, 678, + /* 940 */ 99, 760, 2132, 375, 660, 54, 401, 62, 655, 199, + /* 950 */ 97, 1438, 1706, 254, 797, 162, 161, 794, 793, 792, + /* 960 */ 159, 498, 1704, 1705, 614, 613, 1437, 1704, 1705, 1757, + /* 970 */ 2108, 1759, 1762, 1763, 1764, 1765, 1766, 1767, 1768, 1769, + /* 980 */ 738, 762, 761, 1780, 1782, 1783, 1784, 1785, 2, 47, + /* 990 */ 45, 760, 2132, 2404, 1957, 681, 1761, 417, 2576, 1700, + /* 1000 */ 314, 315, 12, 1730, 1324, 313, 743, 431, 2546, 1829, + /* 1010 */ 1724, 511, 1786, 1956, 1698, 172, 2582, 204, 1341, 244, + /* 1020 */ 1340, 2577, 711, 2134, 2404, 1953, 1315, 1856, 253, 246, + /* 1030 */ 760, 2132, 2510, 547, 2422, 251, 587, 743, 666, 692, + /* 1040 */ 799, 472, 1781, 471, 9, 1322, 2370, 2370, 742, 2185, + /* 1050 */ 512, 714, 1758, 1342, 243, 1706, 760, 2132, 2505, 96, + /* 1060 */ 760, 2132, 760, 2132, 755, 2422, 2370, 1725, 1317, 1320, + /* 1070 */ 1321, 3, 1952, 470, 760, 2132, 513, 2370, 2370, 742, + /* 1080 */ 592, 855, 2129, 53, 48, 2128, 1951, 717, 2403, 681, + /* 1090 */ 1950, 2441, 2576, 2404, 277, 115, 2405, 746, 2407, 2408, + /* 1100 */ 741, 160, 764, 760, 2132, 726, 740, 2596, 77, 2495, + /* 1110 */ 2582, 204, 306, 413, 2491, 2577, 711, 760, 2132, 2403, + /* 1120 */ 1788, 1789, 2441, 285, 1730, 2370, 115, 2405, 746, 2407, + /* 1130 */ 2408, 741, 1949, 764, 2422, 760, 2132, 728, 2596, 2370, + /* 1140 */ 2495, 760, 2132, 2370, 413, 2491, 2370, 790, 742, 760, + /* 1150 */ 2132, 760, 2132, 760, 2132, 318, 681, 1760, 1770, 2576, + /* 1160 */ 88, 757, 631, 630, 1787, 1790, 275, 394, 393, 758, + /* 1170 */ 623, 325, 172, 432, 824, 822, 1649, 2582, 204, 1701, + /* 1180 */ 2135, 1699, 2577, 711, 1948, 2370, 338, 329, 2403, 2162, + /* 1190 */ 2185, 2441, 1970, 850, 1419, 360, 2405, 746, 2407, 2408, + /* 1200 */ 741, 739, 764, 730, 2460, 2184, 1947, 1946, 2229, 1945, + /* 1210 */ 160, 1704, 1705, 1757, 2110, 1759, 1762, 1763, 1764, 1765, + /* 1220 */ 1766, 1767, 1768, 1769, 738, 762, 761, 1780, 1782, 1783, + /* 1230 */ 1784, 1785, 2, 47, 45, 796, 100, 2370, 2176, 392, + /* 1240 */ 391, 417, 618, 1700, 1654, 1655, 642, 153, 2515, 1849, + /* 1250 */ 488, 140, 262, 2013, 264, 260, 1786, 263, 1698, 2370, + /* 1260 */ 2370, 654, 2370, 87, 620, 2004, 266, 1633, 619, 265, + /* 1270 */ 2002, 268, 624, 1849, 267, 638, 2404, 272, 688, 2391, + /* 1280 */ 286, 49, 49, 1758, 188, 1652, 1781, 640, 2121, 743, + /* 1290 */ 2117, 2569, 643, 645, 1937, 1938, 1417, 160, 1377, 1706, + /* 1300 */ 639, 637, 14, 13, 324, 323, 112, 269, 2404, 64, + /* 1310 */ 1686, 49, 1685, 49, 715, 109, 312, 2422, 173, 76, + /* 1320 */ 158, 743, 1709, 344, 101, 855, 2119, 2115, 15, 2370, + /* 1330 */ 160, 742, 2136, 1708, 2404, 282, 804, 2393, 737, 1378, + /* 1340 */ 342, 75, 198, 73, 74, 768, 158, 743, 71, 2422, + /* 1350 */ 2072, 70, 718, 1880, 371, 160, 1890, 1889, 141, 291, + /* 1360 */ 1396, 2370, 1955, 742, 1788, 1789, 237, 555, 553, 550, + /* 1370 */ 2539, 2403, 727, 299, 2441, 2422, 1996, 158, 115, 2405, + /* 1380 */ 746, 2407, 2408, 741, 1823, 764, 1771, 2370, 1602, 742, + /* 1390 */ 2596, 316, 2495, 293, 752, 320, 413, 2491, 805, 698, + /* 1400 */ 2423, 1760, 1770, 658, 142, 1464, 2441, 62, 1787, 1790, + /* 1410 */ 356, 2405, 746, 2407, 2408, 741, 2069, 764, 337, 2068, + /* 1420 */ 1492, 1496, 1394, 1701, 2255, 1699, 2529, 1986, 848, 2403, + /* 1430 */ 1503, 404, 2441, 1501, 695, 408, 177, 2405, 746, 2407, + /* 1440 */ 2408, 741, 438, 764, 702, 63, 749, 2256, 1992, 2173, + /* 1450 */ 674, 2530, 163, 723, 301, 1704, 1705, 1757, 298, 1759, + /* 1460 */ 1762, 1763, 1764, 1765, 1766, 1767, 1768, 1769, 738, 762, + /* 1470 */ 761, 1780, 1782, 1783, 1784, 1785, 2, 1689, 2540, 1688, + /* 1480 */ 305, 2094, 5, 441, 446, 454, 384, 455, 1733, 1712, + /* 1490 */ 712, 2597, 466, 2404, 85, 84, 477, 213, 465, 217, + /* 1500 */ 1711, 212, 468, 1626, 215, 332, 743, 1723, 2514, 482, + /* 1510 */ 1724, 226, 469, 467, 489, 491, 495, 497, 536, 502, + /* 1520 */ 514, 527, 525, 367, 2248, 532, 456, 535, 537, 453, + /* 1530 */ 449, 445, 442, 470, 2422, 548, 232, 546, 549, 434, + /* 1540 */ 433, 231, 551, 552, 234, 554, 2370, 556, 742, 1714, + /* 1550 */ 1731, 571, 4, 572, 579, 242, 580, 93, 1726, 582, + /* 1560 */ 245, 584, 1786, 1732, 1707, 585, 1734, 2404, 586, 248, + /* 1570 */ 588, 250, 306, 1735, 2327, 94, 95, 594, 255, 615, + /* 1580 */ 743, 617, 2122, 2264, 259, 117, 2118, 659, 2403, 646, + /* 1590 */ 647, 2441, 1781, 425, 424, 115, 2405, 746, 2407, 2408, + /* 1600 */ 741, 261, 764, 1690, 165, 1706, 364, 2596, 2422, 2495, + /* 1610 */ 98, 2404, 166, 413, 2491, 661, 1786, 2120, 1684, 2116, + /* 1620 */ 2370, 167, 742, 168, 743, 278, 1727, 333, 154, 669, + /* 1630 */ 2324, 735, 2323, 668, 676, 283, 673, 699, 685, 2545, + /* 1640 */ 2310, 750, 675, 281, 2404, 670, 1781, 8, 708, 683, + /* 1650 */ 686, 409, 2422, 684, 288, 2544, 300, 743, 179, 290, + /* 1660 */ 2517, 294, 2403, 296, 2370, 2441, 742, 292, 297, 115, + /* 1670 */ 2405, 746, 2407, 2408, 741, 719, 764, 716, 1849, 295, + /* 1680 */ 1728, 2470, 2575, 2495, 2599, 2422, 146, 413, 2491, 1854, + /* 1690 */ 2511, 1852, 191, 307, 155, 61, 334, 2370, 748, 742, + /* 1700 */ 1, 2278, 207, 753, 335, 2277, 2403, 157, 336, 2441, + /* 1710 */ 2476, 2276, 419, 116, 2405, 746, 2407, 2408, 741, 106, + /* 1720 */ 764, 2362, 2133, 754, 108, 2361, 766, 2495, 339, 1715, + /* 1730 */ 1299, 1710, 2492, 2177, 849, 852, 327, 164, 351, 2403, + /* 1740 */ 854, 52, 2441, 363, 343, 341, 115, 2405, 746, 2407, + /* 1750 */ 2408, 741, 2348, 764, 382, 383, 2404, 362, 2468, 352, + /* 1760 */ 2495, 1718, 1720, 82, 413, 2491, 2347, 2346, 2341, 743, + /* 1770 */ 443, 444, 1677, 1678, 210, 762, 761, 1780, 1782, 1783, + /* 1780 */ 1784, 1785, 448, 1691, 2339, 1687, 450, 451, 452, 2338, + /* 1790 */ 1676, 385, 2336, 457, 2335, 459, 2334, 2422, 461, 2333, + /* 1800 */ 2404, 463, 1665, 2314, 214, 2313, 216, 1629, 83, 2370, + /* 1810 */ 2291, 742, 1628, 743, 2290, 1692, 2289, 475, 476, 2288, + /* 1820 */ 2287, 2238, 480, 1572, 2235, 483, 2234, 2404, 2228, 762, + /* 1830 */ 761, 1780, 1782, 1783, 1784, 1785, 487, 486, 2225, 219, + /* 1840 */ 743, 2422, 2224, 86, 2223, 2222, 2227, 2226, 2221, 2220, + /* 1850 */ 221, 2403, 2218, 2370, 2441, 742, 2217, 2216, 115, 2405, + /* 1860 */ 746, 2407, 2408, 741, 223, 764, 503, 2215, 2422, 505, + /* 1870 */ 732, 2213, 2495, 2212, 2211, 2210, 413, 2491, 2233, 2209, + /* 1880 */ 2370, 2208, 742, 2207, 2231, 2214, 2404, 2206, 2205, 2204, + /* 1890 */ 2202, 2201, 2200, 2199, 2198, 2403, 2197, 2196, 2441, 743, + /* 1900 */ 225, 2195, 116, 2405, 746, 2407, 2408, 741, 92, 764, + /* 1910 */ 2194, 2193, 2232, 2230, 2192, 2191, 2495, 1578, 2190, 230, + /* 1920 */ 2494, 2491, 2403, 2189, 539, 2441, 2188, 2422, 541, 116, + /* 1930 */ 2405, 746, 2407, 2408, 741, 2187, 764, 2186, 1435, 2370, + /* 1940 */ 2034, 742, 1439, 2495, 1431, 233, 2404, 734, 2491, 2033, + /* 1950 */ 373, 235, 374, 2032, 2030, 2027, 557, 558, 2026, 743, + /* 1960 */ 562, 561, 2404, 236, 559, 2019, 565, 563, 2006, 567, + /* 1970 */ 569, 1981, 566, 238, 79, 743, 186, 1323, 1980, 2390, + /* 1980 */ 196, 744, 240, 577, 2441, 2312, 80, 2422, 116, 2405, + /* 1990 */ 746, 2407, 2408, 741, 2308, 764, 252, 249, 247, 2370, + /* 2000 */ 2298, 742, 2495, 2422, 2286, 2285, 377, 2491, 2262, 2111, + /* 2010 */ 1370, 2029, 2025, 596, 595, 2370, 597, 742, 2023, 599, + /* 2020 */ 2404, 600, 601, 2021, 603, 605, 604, 2018, 607, 2001, + /* 2030 */ 608, 609, 1999, 743, 1508, 1507, 2112, 406, 2000, 1998, + /* 2040 */ 1977, 2403, 2113, 2404, 2441, 641, 1407, 1421, 176, 2405, + /* 2050 */ 746, 2407, 2408, 741, 258, 764, 743, 2403, 1420, 1418, + /* 2060 */ 2441, 2422, 1416, 72, 361, 2405, 746, 2407, 2408, 741, + /* 2070 */ 1415, 764, 1414, 2370, 1413, 742, 821, 823, 1412, 2016, + /* 2080 */ 397, 2014, 1409, 398, 2422, 1408, 1406, 2005, 399, 2003, + /* 2090 */ 400, 2537, 644, 1976, 1975, 407, 2370, 1974, 742, 648, + /* 2100 */ 1973, 2404, 650, 1972, 652, 118, 1659, 1661, 1658, 1663, + /* 2110 */ 28, 2311, 1639, 67, 743, 2403, 280, 2404, 2441, 2307, + /* 2120 */ 1635, 1637, 361, 2405, 746, 2407, 2408, 741, 56, 764, + /* 2130 */ 740, 671, 57, 2297, 2284, 2283, 284, 20, 2403, 672, + /* 2140 */ 2404, 2441, 2422, 1614, 2581, 354, 2405, 746, 2407, 2408, + /* 2150 */ 741, 1613, 764, 743, 2370, 677, 742, 170, 2422, 17, + /* 2160 */ 30, 679, 687, 405, 1907, 1881, 287, 689, 6, 691, + /* 2170 */ 2370, 7, 742, 21, 65, 693, 22, 190, 201, 2391, + /* 2180 */ 178, 2422, 289, 1888, 2404, 189, 32, 31, 24, 1922, + /* 2190 */ 59, 707, 1875, 2370, 1927, 742, 2403, 743, 81, 2441, + /* 2200 */ 1928, 1921, 410, 177, 2405, 746, 2407, 2408, 741, 1926, + /* 2210 */ 764, 1925, 2403, 23, 663, 2441, 411, 303, 1846, 360, + /* 2220 */ 2405, 746, 2407, 2408, 741, 2422, 764, 181, 2461, 2282, + /* 2230 */ 1845, 2261, 858, 103, 58, 2403, 18, 2370, 2441, 742, + /* 2240 */ 25, 1798, 346, 2405, 746, 2407, 2408, 741, 331, 764, + /* 2250 */ 11, 1797, 102, 2404, 13, 1716, 1773, 38, 2598, 416, + /* 2260 */ 1808, 182, 1772, 16, 194, 26, 743, 192, 1742, 1750, + /* 2270 */ 27, 2404, 2260, 846, 842, 838, 834, 311, 328, 2403, + /* 2280 */ 104, 1883, 2441, 745, 743, 319, 361, 2405, 746, 2407, + /* 2290 */ 2408, 741, 193, 764, 2422, 317, 69, 105, 751, 109, + /* 2300 */ 322, 2446, 2445, 765, 1775, 763, 2370, 68, 742, 1493, + /* 2310 */ 767, 427, 2422, 769, 771, 774, 1490, 772, 775, 114, + /* 2320 */ 777, 778, 321, 1489, 2370, 1486, 742, 1480, 418, 780, + /* 2330 */ 2404, 781, 783, 1478, 784, 110, 326, 111, 1502, 78, + /* 2340 */ 1498, 1368, 798, 743, 1484, 1403, 1429, 1400, 2403, 1483, + /* 2350 */ 2404, 2441, 1399, 1398, 756, 361, 2405, 746, 2407, 2408, + /* 2360 */ 741, 1397, 764, 743, 1482, 1481, 2403, 1395, 1393, 2441, + /* 2370 */ 1392, 2422, 1391, 345, 2405, 746, 2407, 2408, 741, 208, + /* 2380 */ 764, 809, 1428, 2370, 1389, 742, 811, 1388, 2404, 1387, + /* 2390 */ 1386, 2422, 1425, 1385, 1384, 1383, 1423, 309, 1380, 1379, + /* 2400 */ 1376, 743, 1375, 2370, 308, 742, 1374, 1373, 2404, 2024, + /* 2410 */ 831, 832, 2022, 833, 835, 836, 837, 2020, 839, 2017, + /* 2420 */ 840, 743, 841, 279, 843, 2403, 844, 845, 2441, 2422, + /* 2430 */ 1997, 847, 347, 2405, 746, 2407, 2408, 741, 1312, 764, + /* 2440 */ 1971, 2370, 1300, 742, 851, 2403, 330, 853, 2441, 2422, + /* 2450 */ 1702, 340, 353, 2405, 746, 2407, 2408, 741, 856, 764, + /* 2460 */ 1941, 2370, 857, 742, 1941, 1941, 1941, 1941, 1941, 1941, + /* 2470 */ 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, + /* 2480 */ 1941, 1941, 1941, 2403, 1941, 2404, 2441, 1941, 1941, 1941, + /* 2490 */ 357, 2405, 746, 2407, 2408, 741, 1941, 764, 743, 1941, + /* 2500 */ 1941, 1941, 1941, 2403, 1941, 2404, 2441, 1941, 1941, 1941, + /* 2510 */ 348, 2405, 746, 2407, 2408, 741, 1941, 764, 743, 1941, + /* 2520 */ 1941, 1941, 1941, 1941, 1941, 1941, 2422, 1941, 1941, 1941, + /* 2530 */ 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 2370, 1941, + /* 2540 */ 742, 1941, 1941, 1941, 1941, 1941, 2422, 1941, 1941, 1941, + /* 2550 */ 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 2370, 1941, + /* 2560 */ 742, 1941, 1941, 2404, 1941, 1941, 1941, 1941, 1941, 1941, + /* 2570 */ 1941, 1941, 1941, 1941, 1941, 1941, 743, 1941, 1941, 1941, + /* 2580 */ 2403, 1941, 1941, 2441, 1941, 1941, 1941, 358, 2405, 746, + /* 2590 */ 2407, 2408, 741, 2404, 764, 1941, 1941, 1941, 1941, 1941, + /* 2600 */ 2403, 1941, 1941, 2441, 2422, 1941, 743, 349, 2405, 746, + /* 2610 */ 2407, 2408, 741, 1941, 764, 1941, 2370, 1941, 742, 1941, + /* 2620 */ 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, + /* 2630 */ 2404, 1941, 1941, 1941, 2422, 1941, 1941, 1941, 1941, 1941, + /* 2640 */ 1941, 1941, 1941, 743, 1941, 1941, 2370, 1941, 742, 1941, + /* 2650 */ 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 2403, 1941, + /* 2660 */ 1941, 2441, 1941, 2404, 1941, 359, 2405, 746, 2407, 2408, + /* 2670 */ 741, 2422, 764, 1941, 1941, 1941, 743, 1941, 1941, 1941, + /* 2680 */ 1941, 1941, 1941, 2370, 1941, 742, 1941, 1941, 2403, 1941, + /* 2690 */ 1941, 2441, 1941, 1941, 1941, 350, 2405, 746, 2407, 2408, + /* 2700 */ 741, 1941, 764, 1941, 2422, 1941, 1941, 1941, 1941, 2404, + /* 2710 */ 1941, 1941, 1941, 1941, 1941, 1941, 2370, 1941, 742, 1941, + /* 2720 */ 1941, 1941, 743, 1941, 1941, 2403, 1941, 1941, 2441, 1941, + /* 2730 */ 2404, 1941, 365, 2405, 746, 2407, 2408, 741, 1941, 764, + /* 2740 */ 1941, 1941, 1941, 743, 1941, 1941, 2404, 1941, 1941, 1941, + /* 2750 */ 2422, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 2403, 743, + /* 2760 */ 1941, 2441, 2370, 1941, 742, 366, 2405, 746, 2407, 2408, + /* 2770 */ 741, 2422, 764, 1941, 1941, 1941, 2404, 1941, 1941, 1941, + /* 2780 */ 1941, 1941, 1941, 2370, 1941, 742, 1941, 2422, 1941, 743, + /* 2790 */ 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 2370, + /* 2800 */ 1941, 742, 1941, 1941, 2403, 1941, 1941, 2441, 1941, 1941, + /* 2810 */ 1941, 2416, 2405, 746, 2407, 2408, 741, 2422, 764, 1941, + /* 2820 */ 1941, 1941, 1941, 1941, 1941, 2403, 1941, 1941, 2441, 2370, + /* 2830 */ 1941, 742, 2415, 2405, 746, 2407, 2408, 741, 1941, 764, + /* 2840 */ 1941, 2403, 1941, 1941, 2441, 2404, 1941, 1941, 2414, 2405, + /* 2850 */ 746, 2407, 2408, 741, 1941, 764, 1941, 1941, 743, 1941, + /* 2860 */ 2404, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, + /* 2870 */ 1941, 2403, 1941, 743, 2441, 1941, 1941, 1941, 379, 2405, + /* 2880 */ 746, 2407, 2408, 741, 1941, 764, 2422, 1941, 1941, 1941, + /* 2890 */ 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 2370, 1941, + /* 2900 */ 742, 2422, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, + /* 2910 */ 1941, 1941, 1941, 2370, 1941, 742, 1941, 1941, 2404, 1941, + /* 2920 */ 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, + /* 2930 */ 1941, 743, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, + /* 2940 */ 2403, 1941, 1941, 2441, 2404, 1941, 1941, 380, 2405, 746, + /* 2950 */ 2407, 2408, 741, 1941, 764, 2403, 1941, 743, 2441, 2422, + /* 2960 */ 1941, 1941, 376, 2405, 746, 2407, 2408, 741, 1941, 764, + /* 2970 */ 1941, 2370, 1941, 742, 1941, 1941, 1941, 1941, 1941, 1941, + /* 2980 */ 1941, 1941, 1941, 1941, 1941, 2422, 1941, 1941, 1941, 1941, + /* 2990 */ 1941, 1941, 1941, 1941, 1941, 1941, 1941, 2370, 1941, 742, + /* 3000 */ 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, + /* 3010 */ 1941, 1941, 1941, 2403, 1941, 1941, 2441, 1941, 2404, 1941, + /* 3020 */ 381, 2405, 746, 2407, 2408, 741, 1941, 764, 1941, 1941, + /* 3030 */ 1941, 743, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 744, + /* 3040 */ 1941, 1941, 2441, 1941, 1941, 1941, 356, 2405, 746, 2407, + /* 3050 */ 2408, 741, 1941, 764, 1941, 1941, 1941, 1941, 1941, 2422, + /* 3060 */ 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, + /* 3070 */ 1941, 2370, 1941, 742, 1941, 1941, 1941, 1941, 1941, 1941, + /* 3080 */ 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, + /* 3090 */ 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, + /* 3100 */ 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, + /* 3110 */ 1941, 1941, 1941, 2403, 1941, 1941, 2441, 1941, 1941, 1941, + /* 3120 */ 355, 2405, 746, 2407, 2408, 741, 1941, 764, }; static const YYCODETYPE yy_lookahead[] = { - /* 0 */ 375, 383, 361, 395, 430, 364, 365, 1, 2, 435, - /* 10 */ 0, 430, 12, 13, 14, 397, 480, 392, 410, 483, - /* 20 */ 20, 20, 22, 8, 9, 407, 401, 12, 13, 14, - /* 30 */ 15, 16, 353, 21, 355, 35, 0, 37, 502, 366, - /* 40 */ 367, 480, 506, 507, 483, 354, 469, 470, 36, 366, - /* 50 */ 38, 39, 40, 20, 480, 366, 367, 483, 367, 386, - /* 60 */ 373, 480, 501, 502, 483, 65, 393, 506, 507, 451, - /* 70 */ 452, 71, 465, 409, 467, 501, 502, 390, 78, 461, - /* 80 */ 506, 507, 501, 502, 409, 398, 395, 506, 507, 8, - /* 90 */ 9, 427, 428, 12, 13, 14, 15, 16, 407, 424, - /* 100 */ 409, 70, 427, 428, 104, 422, 423, 107, 366, 73, - /* 110 */ 74, 75, 76, 77, 108, 79, 80, 81, 82, 83, + /* 0 */ 471, 472, 387, 467, 431, 469, 366, 367, 455, 436, + /* 10 */ 395, 367, 12, 13, 14, 362, 366, 402, 403, 366, + /* 20 */ 20, 368, 22, 8, 9, 410, 386, 12, 13, 14, + /* 30 */ 15, 16, 409, 393, 481, 35, 0, 37, 20, 395, + /* 40 */ 8, 9, 21, 354, 12, 13, 14, 15, 16, 366, + /* 50 */ 427, 428, 394, 366, 367, 482, 367, 36, 485, 38, + /* 60 */ 39, 40, 8, 9, 406, 65, 12, 13, 14, 15, + /* 70 */ 16, 71, 422, 423, 70, 376, 503, 504, 78, 366, + /* 80 */ 367, 508, 509, 384, 395, 8, 9, 33, 3, 12, + /* 90 */ 13, 14, 15, 16, 411, 412, 407, 414, 409, 386, + /* 100 */ 4, 418, 458, 354, 104, 20, 393, 107, 20, 73, + /* 110 */ 74, 75, 76, 77, 71, 79, 80, 81, 82, 83, /* 120 */ 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - /* 130 */ 94, 95, 96, 97, 98, 99, 100, 0, 20, 448, - /* 140 */ 22, 107, 451, 143, 144, 454, 455, 456, 457, 458, - /* 150 */ 459, 20, 461, 411, 412, 37, 414, 466, 361, 468, - /* 160 */ 418, 364, 365, 472, 473, 476, 477, 478, 14, 480, - /* 170 */ 481, 161, 483, 55, 20, 165, 395, 395, 487, 480, - /* 180 */ 180, 181, 483, 173, 402, 20, 495, 187, 188, 108, - /* 190 */ 501, 502, 410, 366, 367, 506, 507, 0, 417, 107, - /* 200 */ 419, 502, 202, 107, 204, 506, 507, 70, 394, 194, - /* 210 */ 20, 8, 9, 408, 409, 12, 13, 14, 15, 16, - /* 220 */ 406, 24, 25, 26, 27, 28, 29, 30, 31, 32, - /* 230 */ 20, 366, 367, 87, 234, 235, 236, 236, 238, 239, + /* 130 */ 94, 95, 96, 97, 98, 99, 100, 353, 449, 355, + /* 140 */ 108, 452, 51, 143, 144, 456, 457, 458, 459, 460, + /* 150 */ 461, 60, 463, 395, 63, 64, 407, 468, 22, 470, + /* 160 */ 402, 0, 108, 474, 475, 478, 479, 480, 410, 482, + /* 170 */ 483, 382, 485, 37, 385, 366, 367, 395, 489, 482, + /* 180 */ 180, 181, 485, 22, 402, 108, 497, 187, 188, 383, + /* 190 */ 503, 504, 410, 108, 0, 508, 509, 0, 180, 181, + /* 200 */ 503, 504, 202, 107, 204, 508, 509, 366, 367, 194, + /* 210 */ 179, 8, 9, 407, 78, 12, 13, 14, 15, 16, + /* 220 */ 107, 24, 25, 26, 27, 28, 29, 30, 31, 32, + /* 230 */ 37, 143, 144, 136, 234, 235, 236, 140, 238, 239, /* 240 */ 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - /* 250 */ 250, 251, 252, 253, 254, 255, 12, 13, 56, 57, - /* 260 */ 20, 18, 480, 20, 20, 483, 22, 12, 13, 236, - /* 270 */ 27, 362, 354, 30, 71, 366, 20, 368, 35, 35, - /* 280 */ 415, 37, 65, 501, 502, 367, 138, 362, 506, 507, - /* 290 */ 142, 366, 37, 368, 51, 149, 53, 201, 20, 203, - /* 300 */ 367, 58, 59, 476, 477, 478, 272, 480, 481, 65, - /* 310 */ 354, 366, 69, 395, 299, 71, 104, 107, 115, 173, - /* 320 */ 174, 69, 78, 106, 137, 407, 109, 409, 395, 233, + /* 250 */ 250, 251, 252, 253, 254, 255, 12, 13, 452, 453, + /* 260 */ 454, 18, 14, 20, 20, 409, 22, 182, 20, 463, + /* 270 */ 27, 78, 354, 30, 71, 187, 188, 234, 35, 35, + /* 280 */ 424, 37, 22, 427, 428, 367, 477, 478, 479, 480, + /* 290 */ 259, 482, 483, 383, 51, 361, 53, 37, 364, 365, + /* 300 */ 269, 58, 59, 234, 12, 13, 14, 15, 16, 65, + /* 310 */ 408, 409, 69, 395, 299, 71, 104, 407, 115, 478, + /* 320 */ 479, 480, 78, 482, 483, 407, 395, 409, 371, 372, /* 330 */ 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, /* 340 */ 20, 129, 130, 131, 132, 133, 134, 135, 104, 106, - /* 350 */ 20, 107, 136, 137, 138, 139, 140, 141, 142, 211, - /* 360 */ 117, 0, 214, 407, 272, 217, 448, 219, 272, 451, - /* 370 */ 180, 181, 454, 455, 456, 457, 458, 459, 460, 461, - /* 380 */ 462, 463, 179, 143, 144, 440, 441, 143, 144, 456, - /* 390 */ 147, 148, 175, 150, 151, 152, 153, 154, 155, 156, - /* 400 */ 157, 158, 215, 216, 354, 162, 163, 164, 165, 166, - /* 410 */ 167, 168, 3, 170, 171, 172, 395, 366, 367, 176, - /* 420 */ 177, 178, 366, 367, 180, 181, 183, 187, 188, 20, - /* 430 */ 453, 187, 188, 20, 73, 74, 75, 386, 366, 367, - /* 440 */ 419, 80, 81, 82, 393, 14, 202, 86, 204, 197, - /* 450 */ 20, 20, 91, 92, 93, 94, 479, 407, 97, 204, - /* 460 */ 182, 100, 259, 260, 261, 262, 263, 264, 265, 266, - /* 470 */ 267, 268, 269, 143, 144, 70, 224, 225, 234, 235, - /* 480 */ 236, 71, 238, 239, 240, 241, 242, 243, 244, 245, + /* 350 */ 419, 107, 20, 284, 285, 286, 287, 288, 289, 290, + /* 360 */ 117, 0, 452, 453, 104, 362, 14, 449, 272, 366, + /* 370 */ 452, 368, 20, 463, 456, 457, 458, 459, 460, 461, + /* 380 */ 395, 463, 179, 397, 354, 272, 400, 143, 144, 87, + /* 390 */ 147, 148, 0, 150, 151, 152, 153, 154, 155, 156, + /* 400 */ 157, 158, 417, 107, 419, 162, 163, 164, 165, 166, + /* 410 */ 167, 168, 186, 170, 171, 172, 498, 499, 391, 176, + /* 420 */ 177, 178, 228, 20, 180, 181, 183, 107, 366, 367, + /* 430 */ 395, 187, 188, 375, 73, 74, 75, 407, 452, 107, + /* 440 */ 20, 80, 81, 82, 20, 410, 202, 86, 204, 463, + /* 450 */ 392, 149, 91, 92, 93, 94, 12, 13, 97, 401, + /* 460 */ 354, 100, 259, 260, 261, 262, 263, 264, 265, 266, + /* 470 */ 267, 268, 269, 446, 20, 173, 174, 415, 234, 235, + /* 480 */ 236, 37, 238, 239, 240, 241, 242, 243, 244, 245, /* 490 */ 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - /* 500 */ 256, 12, 13, 354, 20, 383, 22, 20, 3, 20, - /* 510 */ 0, 22, 387, 4, 236, 35, 367, 108, 405, 397, - /* 520 */ 395, 408, 409, 395, 35, 354, 37, 402, 403, 407, - /* 530 */ 402, 51, 476, 477, 478, 410, 480, 481, 410, 55, - /* 540 */ 60, 61, 62, 63, 395, 65, 373, 475, 476, 477, - /* 550 */ 478, 23, 480, 481, 65, 256, 407, 395, 409, 117, - /* 560 */ 71, 73, 74, 75, 402, 33, 186, 78, 80, 81, - /* 570 */ 82, 398, 410, 451, 86, 47, 48, 45, 407, 91, - /* 580 */ 92, 93, 94, 461, 234, 97, 106, 20, 100, 109, - /* 590 */ 256, 182, 258, 104, 107, 182, 107, 448, 366, 367, - /* 600 */ 451, 354, 375, 454, 455, 456, 457, 458, 459, 465, - /* 610 */ 461, 467, 182, 464, 367, 466, 467, 468, 386, 8, - /* 620 */ 9, 472, 473, 12, 13, 14, 15, 16, 401, 383, - /* 630 */ 22, 20, 143, 144, 284, 285, 286, 287, 288, 289, - /* 640 */ 290, 354, 395, 397, 234, 37, 136, 137, 138, 139, - /* 650 */ 140, 141, 142, 407, 407, 175, 409, 0, 278, 279, - /* 660 */ 280, 281, 366, 367, 184, 185, 236, 366, 367, 180, - /* 670 */ 181, 191, 192, 354, 107, 366, 187, 188, 21, 4, - /* 680 */ 0, 24, 25, 26, 27, 28, 29, 30, 31, 32, - /* 690 */ 210, 202, 376, 204, 407, 448, 382, 451, 451, 385, - /* 700 */ 384, 454, 455, 456, 457, 458, 459, 461, 461, 51, - /* 710 */ 354, 415, 104, 466, 430, 468, 415, 78, 60, 472, - /* 720 */ 473, 63, 64, 234, 235, 236, 407, 238, 239, 240, + /* 500 */ 256, 12, 13, 354, 278, 279, 280, 281, 20, 20, + /* 510 */ 22, 22, 395, 407, 361, 351, 367, 364, 365, 402, + /* 520 */ 65, 73, 74, 75, 35, 37, 37, 410, 80, 81, + /* 530 */ 82, 107, 180, 256, 86, 258, 354, 366, 367, 91, + /* 540 */ 92, 93, 94, 55, 395, 97, 143, 144, 100, 367, + /* 550 */ 3, 159, 160, 20, 65, 0, 407, 386, 409, 2, + /* 560 */ 71, 106, 366, 367, 109, 8, 9, 78, 272, 12, + /* 570 */ 13, 14, 15, 16, 366, 367, 21, 395, 373, 24, + /* 580 */ 25, 26, 27, 28, 29, 30, 31, 32, 236, 407, + /* 590 */ 20, 409, 272, 104, 386, 431, 107, 373, 449, 482, + /* 600 */ 436, 452, 485, 398, 272, 456, 457, 458, 459, 460, + /* 610 */ 461, 415, 463, 466, 390, 466, 469, 468, 469, 470, + /* 620 */ 503, 504, 398, 474, 475, 508, 509, 366, 367, 397, + /* 630 */ 175, 449, 143, 144, 452, 0, 182, 397, 456, 457, + /* 640 */ 458, 459, 460, 461, 20, 463, 482, 386, 204, 485, + /* 650 */ 468, 13, 470, 69, 455, 21, 474, 475, 24, 25, + /* 660 */ 26, 27, 28, 29, 30, 31, 32, 503, 504, 180, + /* 670 */ 181, 404, 508, 509, 407, 2, 187, 188, 0, 497, + /* 680 */ 481, 8, 9, 0, 452, 12, 13, 14, 15, 16, + /* 690 */ 236, 202, 452, 204, 405, 463, 354, 408, 409, 20, + /* 700 */ 8, 9, 395, 463, 12, 13, 14, 15, 16, 402, + /* 710 */ 366, 367, 20, 431, 8, 9, 78, 410, 12, 13, + /* 720 */ 14, 15, 16, 234, 235, 236, 354, 238, 239, 240, /* 730 */ 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - /* 740 */ 251, 252, 253, 254, 255, 12, 13, 14, 354, 440, - /* 750 */ 441, 366, 367, 20, 391, 22, 430, 137, 138, 272, - /* 760 */ 33, 367, 142, 407, 480, 357, 358, 483, 35, 21, - /* 770 */ 37, 386, 24, 25, 26, 27, 28, 29, 30, 31, - /* 780 */ 32, 354, 107, 274, 387, 501, 502, 366, 367, 395, - /* 790 */ 506, 507, 395, 182, 367, 395, 369, 34, 65, 294, - /* 800 */ 403, 407, 402, 409, 366, 367, 480, 386, 445, 483, - /* 810 */ 410, 78, 8, 9, 395, 387, 12, 13, 14, 15, - /* 820 */ 16, 402, 395, 395, 386, 371, 372, 501, 502, 410, - /* 830 */ 387, 403, 506, 507, 407, 108, 409, 104, 395, 272, - /* 840 */ 107, 42, 448, 366, 367, 451, 403, 236, 454, 455, - /* 850 */ 456, 457, 458, 459, 354, 461, 354, 354, 117, 22, - /* 860 */ 466, 4, 468, 386, 395, 354, 472, 473, 453, 367, - /* 870 */ 366, 367, 403, 354, 37, 448, 143, 144, 451, 0, - /* 880 */ 23, 454, 455, 456, 457, 458, 459, 354, 461, 495, - /* 890 */ 386, 4, 14, 466, 479, 468, 14, 395, 20, 472, - /* 900 */ 473, 436, 20, 46, 47, 48, 19, 407, 228, 407, - /* 910 */ 407, 409, 108, 180, 181, 78, 366, 367, 407, 0, - /* 920 */ 187, 188, 35, 8, 9, 20, 407, 12, 13, 14, - /* 930 */ 15, 16, 14, 15, 16, 202, 386, 204, 51, 22, - /* 940 */ 407, 104, 50, 380, 381, 58, 59, 272, 33, 395, - /* 950 */ 448, 37, 65, 451, 37, 430, 454, 455, 456, 457, - /* 960 */ 458, 459, 396, 461, 410, 371, 372, 234, 235, 236, - /* 970 */ 51, 238, 239, 240, 241, 242, 243, 244, 245, 246, + /* 740 */ 251, 252, 253, 254, 255, 12, 13, 14, 354, 407, + /* 750 */ 22, 395, 182, 20, 354, 22, 482, 4, 402, 485, + /* 760 */ 354, 367, 20, 369, 482, 37, 410, 485, 35, 236, + /* 770 */ 37, 136, 137, 138, 139, 140, 141, 142, 504, 407, + /* 780 */ 354, 197, 508, 509, 387, 503, 504, 20, 431, 395, + /* 790 */ 508, 509, 395, 367, 387, 369, 366, 367, 65, 50, + /* 800 */ 403, 407, 395, 409, 23, 366, 78, 407, 224, 225, + /* 810 */ 403, 78, 0, 407, 136, 137, 138, 139, 140, 141, + /* 820 */ 142, 395, 478, 479, 480, 20, 482, 483, 47, 48, + /* 830 */ 14, 404, 104, 407, 407, 409, 20, 104, 354, 482, + /* 840 */ 107, 294, 485, 449, 161, 415, 452, 467, 165, 469, + /* 850 */ 456, 457, 458, 459, 460, 461, 173, 463, 366, 180, + /* 860 */ 503, 504, 468, 51, 470, 508, 509, 138, 474, 475, + /* 870 */ 33, 142, 366, 367, 182, 449, 143, 144, 452, 35, + /* 880 */ 441, 442, 456, 457, 458, 459, 460, 461, 182, 463, + /* 890 */ 482, 407, 386, 485, 468, 51, 470, 14, 15, 16, + /* 900 */ 474, 475, 1, 2, 60, 61, 62, 63, 20, 65, + /* 910 */ 56, 57, 504, 180, 181, 236, 508, 509, 8, 9, + /* 920 */ 187, 188, 12, 13, 14, 15, 16, 218, 236, 220, + /* 930 */ 202, 182, 204, 441, 442, 202, 70, 204, 117, 190, + /* 940 */ 211, 366, 367, 214, 431, 108, 217, 107, 219, 182, + /* 950 */ 106, 22, 78, 109, 136, 137, 138, 139, 140, 141, + /* 960 */ 142, 386, 234, 235, 371, 372, 37, 234, 235, 236, + /* 970 */ 0, 238, 239, 240, 241, 242, 243, 244, 245, 246, /* 980 */ 247, 248, 249, 250, 251, 252, 253, 254, 255, 12, - /* 990 */ 13, 396, 78, 106, 354, 78, 109, 20, 354, 22, - /* 1000 */ 12, 13, 14, 15, 16, 480, 354, 354, 483, 396, - /* 1010 */ 508, 509, 35, 395, 37, 136, 137, 138, 139, 140, - /* 1020 */ 141, 142, 354, 108, 354, 354, 501, 502, 410, 8, - /* 1030 */ 9, 506, 507, 12, 13, 14, 15, 16, 367, 202, - /* 1040 */ 369, 204, 65, 179, 366, 367, 20, 407, 354, 366, - /* 1050 */ 367, 407, 22, 366, 367, 78, 366, 367, 180, 407, - /* 1060 */ 407, 367, 180, 369, 386, 464, 395, 37, 467, 386, - /* 1070 */ 271, 234, 235, 386, 182, 407, 386, 407, 407, 117, - /* 1080 */ 409, 104, 190, 354, 107, 180, 136, 8, 9, 395, - /* 1090 */ 140, 12, 13, 14, 15, 16, 367, 33, 369, 2, - /* 1100 */ 0, 407, 396, 409, 404, 8, 9, 407, 354, 12, - /* 1110 */ 13, 14, 15, 16, 236, 366, 367, 13, 236, 448, - /* 1120 */ 143, 144, 451, 259, 395, 454, 455, 456, 457, 458, - /* 1130 */ 459, 169, 461, 269, 104, 386, 407, 466, 409, 468, - /* 1140 */ 33, 236, 448, 472, 473, 451, 0, 175, 454, 455, - /* 1150 */ 456, 457, 458, 459, 0, 461, 354, 180, 181, 37, - /* 1160 */ 466, 407, 468, 37, 187, 188, 472, 473, 22, 366, - /* 1170 */ 367, 366, 367, 404, 366, 367, 407, 448, 206, 202, - /* 1180 */ 451, 204, 78, 454, 455, 456, 457, 458, 459, 386, - /* 1190 */ 461, 386, 430, 2, 386, 466, 42, 468, 33, 8, - /* 1200 */ 9, 472, 473, 12, 13, 14, 15, 16, 396, 407, - /* 1210 */ 45, 234, 235, 236, 396, 238, 239, 240, 241, 242, + /* 990 */ 13, 366, 367, 354, 354, 482, 180, 20, 485, 22, + /* 1000 */ 137, 138, 256, 236, 14, 142, 367, 387, 369, 108, + /* 1010 */ 20, 386, 35, 354, 37, 395, 503, 504, 20, 175, + /* 1020 */ 22, 508, 509, 403, 354, 354, 4, 274, 184, 185, + /* 1030 */ 366, 367, 455, 104, 395, 191, 192, 367, 431, 369, + /* 1040 */ 70, 201, 65, 203, 42, 23, 407, 407, 409, 395, + /* 1050 */ 386, 33, 236, 55, 210, 78, 366, 367, 481, 375, + /* 1060 */ 366, 367, 366, 367, 410, 395, 407, 20, 46, 47, + /* 1070 */ 48, 33, 354, 233, 366, 367, 386, 407, 407, 409, + /* 1080 */ 386, 104, 386, 45, 107, 401, 354, 33, 449, 482, + /* 1090 */ 354, 452, 485, 354, 386, 456, 457, 458, 459, 460, + /* 1100 */ 461, 33, 463, 366, 367, 431, 367, 468, 117, 470, + /* 1110 */ 503, 504, 272, 474, 475, 508, 509, 366, 367, 449, + /* 1120 */ 143, 144, 452, 386, 236, 407, 456, 457, 458, 459, + /* 1130 */ 460, 461, 354, 463, 395, 366, 367, 386, 468, 407, + /* 1140 */ 470, 366, 367, 407, 474, 475, 407, 117, 409, 366, + /* 1150 */ 367, 366, 367, 366, 367, 386, 482, 180, 181, 485, + /* 1160 */ 169, 386, 380, 381, 187, 188, 137, 39, 40, 386, + /* 1170 */ 13, 386, 395, 386, 380, 381, 108, 503, 504, 202, + /* 1180 */ 403, 204, 508, 509, 354, 407, 388, 34, 449, 391, + /* 1190 */ 395, 452, 357, 358, 37, 456, 457, 458, 459, 460, + /* 1200 */ 461, 462, 463, 464, 465, 410, 354, 354, 0, 354, + /* 1210 */ 33, 234, 235, 236, 0, 238, 239, 240, 241, 242, /* 1220 */ 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - /* 1230 */ 253, 254, 255, 12, 13, 39, 40, 366, 367, 453, - /* 1240 */ 0, 20, 480, 22, 33, 483, 366, 367, 380, 381, - /* 1250 */ 366, 367, 404, 270, 271, 407, 35, 386, 37, 159, - /* 1260 */ 160, 182, 236, 501, 502, 479, 386, 33, 506, 507, - /* 1270 */ 386, 388, 110, 33, 391, 113, 354, 110, 110, 13, - /* 1280 */ 113, 113, 110, 0, 0, 113, 65, 13, 33, 367, - /* 1290 */ 0, 369, 218, 65, 220, 49, 33, 33, 355, 78, - /* 1300 */ 143, 144, 396, 37, 37, 22, 22, 111, 112, 33, - /* 1310 */ 114, 37, 22, 1, 2, 384, 420, 395, 18, 108, - /* 1320 */ 510, 33, 33, 23, 33, 104, 204, 13, 107, 407, - /* 1330 */ 204, 409, 136, 499, 354, 33, 140, 109, 492, 33, - /* 1340 */ 40, 41, 108, 33, 44, 78, 33, 367, 370, 369, - /* 1350 */ 107, 37, 33, 107, 54, 33, 395, 33, 33, 116, - /* 1360 */ 296, 13, 383, 108, 143, 144, 66, 67, 68, 69, - /* 1370 */ 448, 108, 108, 451, 33, 395, 454, 455, 456, 457, - /* 1380 */ 458, 459, 383, 461, 108, 37, 420, 407, 466, 409, - /* 1390 */ 468, 0, 365, 420, 472, 473, 108, 108, 498, 108, - /* 1400 */ 498, 180, 181, 33, 33, 298, 498, 107, 187, 188, - /* 1410 */ 108, 429, 370, 420, 108, 367, 406, 420, 108, 498, - /* 1420 */ 420, 108, 437, 202, 482, 204, 503, 108, 448, 474, - /* 1430 */ 108, 451, 108, 108, 454, 455, 456, 457, 458, 459, - /* 1440 */ 385, 461, 485, 52, 275, 145, 466, 431, 468, 108, - /* 1450 */ 51, 450, 472, 473, 42, 234, 235, 236, 449, 238, + /* 1230 */ 253, 254, 255, 12, 13, 404, 175, 407, 407, 111, + /* 1240 */ 112, 20, 114, 22, 215, 216, 4, 33, 270, 271, + /* 1250 */ 42, 33, 110, 0, 110, 113, 35, 113, 37, 407, + /* 1260 */ 407, 19, 407, 45, 136, 0, 110, 206, 140, 113, + /* 1270 */ 0, 110, 13, 271, 113, 22, 354, 35, 33, 49, + /* 1280 */ 65, 33, 33, 236, 33, 108, 65, 22, 396, 367, + /* 1290 */ 396, 369, 22, 51, 143, 144, 37, 33, 37, 78, + /* 1300 */ 58, 59, 1, 2, 12, 13, 107, 65, 354, 33, + /* 1310 */ 37, 33, 37, 33, 296, 116, 33, 395, 18, 33, + /* 1320 */ 33, 367, 37, 23, 109, 104, 396, 396, 107, 407, + /* 1330 */ 33, 409, 396, 37, 354, 396, 13, 107, 396, 78, + /* 1340 */ 40, 41, 437, 33, 44, 33, 33, 367, 106, 395, + /* 1350 */ 384, 109, 298, 108, 54, 33, 108, 108, 33, 108, + /* 1360 */ 37, 407, 355, 409, 143, 144, 66, 67, 68, 69, + /* 1370 */ 420, 449, 108, 512, 452, 395, 0, 33, 456, 457, + /* 1380 */ 458, 459, 460, 461, 108, 463, 108, 407, 108, 409, + /* 1390 */ 468, 108, 470, 494, 108, 108, 474, 475, 13, 501, + /* 1400 */ 395, 180, 181, 449, 370, 108, 452, 107, 187, 188, + /* 1410 */ 456, 457, 458, 459, 460, 461, 383, 463, 108, 383, + /* 1420 */ 108, 108, 37, 202, 420, 204, 420, 365, 52, 449, + /* 1430 */ 108, 430, 452, 108, 500, 500, 456, 457, 458, 459, + /* 1440 */ 460, 461, 370, 463, 500, 145, 500, 420, 367, 406, + /* 1450 */ 438, 420, 108, 484, 505, 234, 235, 236, 476, 238, /* 1460 */ 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - /* 1470 */ 249, 250, 251, 252, 253, 254, 255, 20, 108, 108, - /* 1480 */ 442, 12, 13, 447, 354, 217, 375, 442, 375, 433, - /* 1490 */ 20, 22, 200, 366, 194, 195, 196, 367, 20, 199, - /* 1500 */ 367, 45, 416, 367, 35, 416, 37, 354, 179, 413, - /* 1510 */ 366, 366, 212, 213, 367, 416, 413, 379, 413, 413, - /* 1520 */ 367, 105, 103, 223, 366, 395, 226, 378, 102, 229, - /* 1530 */ 230, 231, 232, 233, 65, 20, 351, 407, 377, 409, - /* 1540 */ 366, 366, 354, 366, 50, 359, 363, 78, 395, 359, - /* 1550 */ 363, 442, 20, 375, 375, 367, 375, 409, 20, 20, - /* 1560 */ 407, 368, 409, 432, 375, 368, 20, 375, 366, 375, - /* 1570 */ 375, 359, 272, 104, 423, 375, 357, 395, 448, 395, - /* 1580 */ 366, 451, 357, 395, 454, 455, 456, 457, 458, 459, - /* 1590 */ 359, 461, 107, 395, 395, 407, 466, 409, 468, 395, - /* 1600 */ 395, 448, 472, 473, 451, 395, 221, 454, 455, 456, - /* 1610 */ 457, 458, 459, 395, 461, 430, 407, 395, 395, 466, - /* 1620 */ 435, 468, 395, 407, 407, 472, 473, 373, 20, 208, - /* 1630 */ 207, 373, 283, 409, 431, 366, 448, 407, 282, 451, - /* 1640 */ 439, 354, 454, 455, 456, 457, 458, 459, 291, 461, - /* 1650 */ 442, 444, 446, 438, 367, 491, 468, 425, 425, 193, - /* 1660 */ 472, 473, 491, 276, 494, 480, 493, 441, 483, 293, - /* 1670 */ 490, 202, 354, 204, 292, 431, 297, 300, 295, 271, - /* 1680 */ 20, 505, 395, 367, 117, 367, 501, 502, 453, 368, - /* 1690 */ 273, 506, 507, 373, 407, 425, 409, 425, 185, 354, - /* 1700 */ 373, 407, 489, 234, 235, 407, 407, 421, 407, 373, - /* 1710 */ 407, 491, 367, 395, 391, 373, 107, 248, 249, 250, - /* 1720 */ 251, 252, 253, 254, 488, 407, 367, 409, 486, 484, - /* 1730 */ 471, 107, 399, 504, 366, 448, 373, 407, 451, 22, - /* 1740 */ 395, 454, 455, 456, 457, 458, 459, 38, 461, 511, - /* 1750 */ 356, 359, 407, 360, 409, 468, 389, 354, 443, 472, - /* 1760 */ 473, 426, 434, 426, 389, 352, 448, 389, 0, 451, - /* 1770 */ 367, 374, 454, 455, 456, 457, 458, 459, 0, 461, - /* 1780 */ 0, 45, 0, 37, 227, 37, 468, 37, 37, 227, - /* 1790 */ 472, 473, 354, 448, 0, 37, 451, 37, 395, 454, - /* 1800 */ 455, 456, 457, 458, 459, 367, 461, 227, 37, 0, - /* 1810 */ 407, 227, 409, 0, 37, 0, 37, 0, 22, 0, - /* 1820 */ 37, 222, 354, 210, 0, 210, 204, 211, 202, 0, - /* 1830 */ 0, 0, 198, 395, 0, 367, 197, 0, 0, 148, - /* 1840 */ 49, 496, 497, 0, 49, 407, 0, 409, 37, 0, - /* 1850 */ 51, 448, 0, 37, 451, 49, 0, 454, 455, 456, - /* 1860 */ 457, 458, 459, 395, 461, 45, 0, 0, 400, 0, - /* 1870 */ 49, 468, 0, 0, 0, 407, 473, 409, 0, 0, - /* 1880 */ 0, 165, 37, 0, 165, 0, 448, 354, 0, 451, - /* 1890 */ 0, 0, 454, 455, 456, 457, 458, 459, 45, 461, - /* 1900 */ 367, 0, 354, 0, 0, 0, 0, 0, 0, 0, - /* 1910 */ 0, 0, 0, 0, 0, 367, 448, 354, 22, 451, - /* 1920 */ 0, 0, 454, 455, 456, 457, 458, 459, 395, 461, - /* 1930 */ 367, 49, 0, 400, 148, 497, 0, 0, 0, 0, - /* 1940 */ 407, 0, 409, 395, 0, 0, 0, 0, 147, 0, - /* 1950 */ 146, 0, 0, 22, 0, 407, 37, 409, 395, 65, - /* 1960 */ 0, 0, 22, 0, 65, 50, 50, 65, 0, 42, - /* 1970 */ 407, 0, 409, 51, 51, 42, 0, 51, 0, 37, - /* 1980 */ 37, 448, 0, 33, 451, 37, 14, 454, 455, 456, - /* 1990 */ 457, 458, 459, 37, 461, 42, 448, 354, 0, 451, - /* 2000 */ 45, 42, 454, 455, 456, 457, 458, 459, 43, 461, - /* 2010 */ 367, 448, 42, 49, 451, 354, 49, 454, 455, 456, - /* 2020 */ 457, 458, 459, 49, 461, 0, 0, 0, 367, 42, - /* 2030 */ 0, 0, 193, 49, 0, 0, 0, 37, 395, 0, - /* 2040 */ 354, 72, 0, 400, 51, 42, 37, 51, 500, 42, - /* 2050 */ 407, 0, 409, 367, 37, 51, 395, 42, 0, 37, - /* 2060 */ 42, 51, 0, 0, 0, 0, 0, 0, 407, 37, - /* 2070 */ 409, 0, 509, 115, 22, 113, 22, 37, 37, 0, - /* 2080 */ 37, 395, 37, 37, 37, 37, 400, 37, 33, 33, - /* 2090 */ 37, 448, 22, 407, 451, 409, 37, 454, 455, 456, - /* 2100 */ 457, 458, 459, 0, 461, 37, 22, 0, 22, 448, - /* 2110 */ 354, 0, 451, 53, 1, 454, 455, 456, 457, 458, - /* 2120 */ 459, 22, 461, 367, 463, 37, 0, 0, 0, 37, - /* 2130 */ 0, 37, 19, 0, 448, 20, 22, 451, 37, 37, - /* 2140 */ 454, 455, 456, 457, 458, 459, 354, 461, 35, 37, - /* 2150 */ 0, 395, 108, 49, 0, 182, 400, 182, 37, 367, - /* 2160 */ 22, 0, 22, 407, 51, 409, 209, 182, 107, 0, - /* 2170 */ 0, 205, 182, 60, 61, 62, 63, 354, 65, 107, - /* 2180 */ 185, 189, 3, 182, 33, 107, 189, 395, 108, 107, - /* 2190 */ 367, 108, 37, 37, 277, 50, 107, 50, 105, 407, - /* 2200 */ 103, 409, 49, 108, 448, 33, 33, 451, 108, 33, - /* 2210 */ 454, 455, 456, 457, 458, 459, 107, 461, 395, 106, - /* 2220 */ 49, 33, 109, 107, 107, 3, 108, 107, 33, 37, - /* 2230 */ 407, 108, 409, 108, 37, 37, 37, 37, 37, 108, - /* 2240 */ 448, 33, 108, 451, 0, 49, 454, 455, 456, 457, - /* 2250 */ 458, 459, 354, 461, 141, 49, 277, 277, 270, 0, - /* 2260 */ 42, 186, 0, 42, 107, 367, 107, 33, 116, 184, - /* 2270 */ 108, 448, 354, 108, 451, 107, 49, 454, 455, 456, - /* 2280 */ 457, 458, 459, 105, 461, 367, 105, 107, 354, 107, - /* 2290 */ 107, 22, 2, 395, 257, 108, 107, 184, 107, 49, - /* 2300 */ 107, 367, 108, 234, 191, 407, 49, 409, 22, 33, - /* 2310 */ 108, 107, 107, 395, 237, 108, 107, 37, 108, 37, - /* 2320 */ 117, 107, 37, 210, 108, 407, 107, 409, 108, 395, - /* 2330 */ 37, 107, 37, 108, 108, 107, 37, 107, 37, 108, - /* 2340 */ 107, 407, 37, 409, 107, 354, 448, 107, 107, 451, - /* 2350 */ 22, 128, 454, 455, 456, 457, 458, 459, 367, 461, - /* 2360 */ 128, 37, 71, 128, 128, 354, 448, 37, 72, 451, - /* 2370 */ 37, 37, 454, 455, 456, 457, 458, 459, 367, 461, - /* 2380 */ 37, 37, 448, 354, 37, 451, 395, 37, 454, 455, - /* 2390 */ 456, 457, 458, 459, 37, 461, 367, 78, 407, 101, - /* 2400 */ 409, 78, 33, 354, 101, 37, 395, 37, 37, 22, - /* 2410 */ 37, 37, 37, 78, 37, 37, 367, 37, 407, 37, - /* 2420 */ 409, 22, 37, 37, 395, 0, 37, 51, 0, 37, - /* 2430 */ 42, 0, 51, 42, 37, 42, 407, 0, 409, 448, - /* 2440 */ 37, 354, 451, 42, 395, 454, 455, 456, 457, 458, - /* 2450 */ 459, 51, 461, 51, 367, 0, 407, 37, 409, 448, - /* 2460 */ 37, 0, 451, 22, 21, 454, 455, 456, 457, 458, - /* 2470 */ 459, 33, 461, 22, 22, 22, 20, 448, 354, 21, - /* 2480 */ 451, 512, 395, 454, 455, 456, 457, 458, 459, 512, - /* 2490 */ 461, 367, 512, 512, 407, 512, 409, 448, 354, 512, - /* 2500 */ 451, 512, 512, 454, 455, 456, 457, 458, 459, 512, - /* 2510 */ 461, 367, 512, 512, 354, 512, 512, 512, 512, 395, - /* 2520 */ 512, 512, 512, 512, 512, 512, 512, 367, 512, 512, - /* 2530 */ 512, 407, 512, 409, 512, 448, 512, 512, 451, 395, - /* 2540 */ 512, 454, 455, 456, 457, 458, 459, 512, 461, 512, - /* 2550 */ 512, 407, 512, 409, 512, 395, 512, 512, 512, 512, - /* 2560 */ 512, 512, 512, 512, 512, 512, 512, 407, 512, 409, - /* 2570 */ 512, 512, 448, 512, 512, 451, 512, 512, 454, 455, - /* 2580 */ 456, 457, 458, 459, 512, 461, 512, 512, 512, 512, - /* 2590 */ 512, 512, 448, 512, 512, 451, 512, 512, 454, 455, - /* 2600 */ 456, 457, 458, 459, 512, 461, 512, 354, 448, 512, - /* 2610 */ 512, 451, 512, 512, 454, 455, 456, 457, 458, 459, - /* 2620 */ 367, 461, 512, 512, 512, 512, 354, 512, 512, 512, - /* 2630 */ 512, 512, 512, 512, 512, 512, 512, 512, 512, 367, - /* 2640 */ 512, 512, 512, 354, 512, 512, 512, 512, 395, 512, - /* 2650 */ 512, 512, 512, 512, 512, 512, 367, 512, 512, 512, - /* 2660 */ 407, 512, 409, 512, 512, 512, 512, 395, 512, 512, - /* 2670 */ 512, 512, 512, 512, 512, 512, 512, 512, 512, 407, - /* 2680 */ 512, 409, 512, 512, 395, 512, 512, 512, 512, 512, - /* 2690 */ 512, 512, 512, 512, 512, 512, 407, 512, 409, 512, - /* 2700 */ 354, 448, 512, 512, 451, 512, 512, 454, 455, 456, - /* 2710 */ 457, 458, 459, 367, 461, 512, 512, 512, 512, 512, - /* 2720 */ 448, 354, 512, 451, 512, 512, 454, 455, 456, 457, - /* 2730 */ 458, 459, 512, 461, 367, 512, 512, 448, 354, 512, - /* 2740 */ 451, 395, 512, 454, 455, 456, 457, 458, 459, 512, - /* 2750 */ 461, 367, 512, 407, 512, 409, 512, 512, 354, 512, - /* 2760 */ 512, 512, 395, 512, 512, 512, 512, 512, 512, 512, - /* 2770 */ 512, 367, 512, 512, 407, 512, 409, 512, 512, 395, - /* 2780 */ 512, 512, 512, 512, 512, 512, 512, 512, 512, 512, - /* 2790 */ 512, 407, 512, 409, 448, 512, 354, 451, 512, 395, - /* 2800 */ 454, 455, 456, 457, 458, 459, 512, 461, 512, 367, - /* 2810 */ 512, 407, 512, 409, 512, 448, 512, 512, 451, 512, - /* 2820 */ 512, 454, 455, 456, 457, 458, 459, 512, 461, 512, - /* 2830 */ 512, 512, 448, 354, 512, 451, 512, 395, 454, 455, - /* 2840 */ 456, 457, 458, 459, 512, 461, 367, 512, 512, 407, - /* 2850 */ 512, 409, 448, 512, 512, 451, 512, 512, 454, 455, - /* 2860 */ 456, 457, 458, 459, 512, 461, 512, 512, 512, 512, - /* 2870 */ 512, 512, 512, 512, 395, 512, 512, 512, 512, 512, - /* 2880 */ 512, 512, 512, 512, 512, 512, 407, 512, 409, 512, - /* 2890 */ 448, 512, 512, 451, 512, 512, 454, 455, 456, 457, - /* 2900 */ 458, 459, 512, 461, 512, 512, 512, 512, 512, 512, - /* 2910 */ 512, 512, 512, 512, 512, 512, 512, 512, 512, 512, - /* 2920 */ 512, 512, 512, 512, 512, 512, 512, 448, 512, 512, - /* 2930 */ 451, 512, 512, 454, 455, 456, 457, 458, 459, 512, - /* 2940 */ 461, 351, 351, 351, 351, 351, 351, 351, 351, 351, - /* 2950 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, - /* 2960 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, - /* 2970 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, - /* 2980 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, - /* 2990 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, - /* 3000 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, - /* 3010 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, - /* 3020 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, - /* 3030 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, - /* 3040 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, - /* 3050 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, - /* 3060 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, - /* 3070 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, - /* 3080 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, - /* 3090 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, - /* 3100 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, - /* 3110 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, - /* 3120 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, + /* 1470 */ 249, 250, 251, 252, 253, 254, 255, 204, 420, 204, + /* 1480 */ 487, 385, 275, 432, 51, 42, 451, 450, 20, 204, + /* 1490 */ 510, 511, 443, 354, 194, 195, 196, 375, 217, 199, + /* 1500 */ 204, 448, 443, 200, 375, 434, 367, 20, 369, 366, + /* 1510 */ 20, 45, 212, 213, 367, 416, 367, 416, 179, 413, + /* 1520 */ 366, 416, 367, 223, 366, 413, 226, 413, 413, 229, + /* 1530 */ 230, 231, 232, 233, 395, 105, 366, 103, 379, 12, + /* 1540 */ 13, 378, 102, 377, 366, 366, 407, 366, 409, 22, + /* 1550 */ 20, 359, 50, 363, 359, 375, 363, 375, 20, 443, + /* 1560 */ 375, 409, 35, 20, 37, 368, 20, 354, 433, 375, + /* 1570 */ 368, 375, 272, 20, 407, 375, 375, 366, 375, 359, + /* 1580 */ 367, 395, 395, 423, 395, 366, 395, 221, 449, 357, + /* 1590 */ 357, 452, 65, 12, 13, 456, 457, 458, 459, 460, + /* 1600 */ 461, 395, 463, 22, 395, 78, 359, 468, 395, 470, + /* 1610 */ 107, 354, 395, 474, 475, 447, 35, 395, 37, 395, + /* 1620 */ 407, 395, 409, 395, 367, 373, 20, 443, 445, 208, + /* 1630 */ 407, 104, 407, 207, 366, 373, 409, 283, 407, 493, + /* 1640 */ 442, 282, 432, 439, 354, 440, 65, 291, 193, 276, + /* 1650 */ 293, 300, 395, 292, 425, 493, 506, 367, 493, 425, + /* 1660 */ 496, 492, 449, 490, 407, 452, 409, 495, 432, 456, + /* 1670 */ 457, 458, 459, 460, 461, 297, 463, 295, 271, 491, + /* 1680 */ 20, 468, 507, 470, 513, 395, 367, 474, 475, 117, + /* 1690 */ 455, 273, 368, 373, 373, 107, 425, 407, 407, 409, + /* 1700 */ 488, 407, 486, 185, 425, 407, 449, 373, 391, 452, + /* 1710 */ 473, 407, 407, 456, 457, 458, 459, 460, 461, 373, + /* 1720 */ 463, 407, 367, 421, 107, 407, 399, 470, 366, 202, + /* 1730 */ 22, 204, 475, 407, 38, 356, 373, 360, 389, 449, + /* 1740 */ 359, 435, 452, 444, 352, 374, 456, 457, 458, 459, + /* 1750 */ 460, 461, 0, 463, 426, 426, 354, 389, 468, 389, + /* 1760 */ 470, 234, 235, 45, 474, 475, 0, 0, 0, 367, + /* 1770 */ 37, 227, 37, 37, 37, 248, 249, 250, 251, 252, + /* 1780 */ 253, 254, 227, 202, 0, 204, 37, 37, 227, 0, + /* 1790 */ 37, 227, 0, 37, 0, 37, 0, 395, 22, 0, + /* 1800 */ 354, 37, 222, 0, 210, 0, 210, 204, 211, 407, + /* 1810 */ 0, 409, 202, 367, 0, 234, 0, 198, 197, 0, + /* 1820 */ 0, 148, 49, 49, 0, 37, 0, 354, 0, 248, + /* 1830 */ 249, 250, 251, 252, 253, 254, 51, 37, 0, 49, + /* 1840 */ 367, 395, 0, 45, 0, 0, 0, 0, 0, 0, + /* 1850 */ 49, 449, 0, 407, 452, 409, 0, 0, 456, 457, + /* 1860 */ 458, 459, 460, 461, 165, 463, 37, 0, 395, 165, + /* 1870 */ 468, 0, 470, 0, 0, 0, 474, 475, 0, 0, + /* 1880 */ 407, 0, 409, 0, 0, 0, 354, 0, 0, 0, + /* 1890 */ 0, 0, 0, 0, 0, 449, 0, 0, 452, 367, + /* 1900 */ 49, 0, 456, 457, 458, 459, 460, 461, 45, 463, + /* 1910 */ 0, 0, 0, 0, 0, 0, 470, 22, 0, 148, + /* 1920 */ 474, 475, 449, 0, 147, 452, 0, 395, 146, 456, + /* 1930 */ 457, 458, 459, 460, 461, 0, 463, 0, 22, 407, + /* 1940 */ 0, 409, 22, 470, 37, 65, 354, 474, 475, 0, + /* 1950 */ 50, 65, 50, 0, 0, 0, 37, 51, 0, 367, + /* 1960 */ 51, 37, 354, 65, 42, 0, 37, 42, 0, 42, + /* 1970 */ 37, 0, 51, 45, 42, 367, 33, 14, 0, 49, + /* 1980 */ 49, 449, 43, 49, 452, 0, 42, 395, 456, 457, + /* 1990 */ 458, 459, 460, 461, 0, 463, 49, 193, 42, 407, + /* 2000 */ 0, 409, 470, 395, 0, 0, 474, 475, 0, 0, + /* 2010 */ 72, 0, 0, 51, 37, 407, 42, 409, 0, 37, + /* 2020 */ 354, 51, 42, 0, 37, 42, 51, 0, 37, 0, + /* 2030 */ 51, 42, 0, 367, 37, 22, 0, 429, 0, 0, + /* 2040 */ 0, 449, 0, 354, 452, 53, 22, 37, 456, 457, + /* 2050 */ 458, 459, 460, 461, 113, 463, 367, 449, 37, 37, + /* 2060 */ 452, 395, 37, 115, 456, 457, 458, 459, 460, 461, + /* 2070 */ 37, 463, 37, 407, 37, 409, 33, 33, 37, 0, + /* 2080 */ 22, 0, 37, 22, 395, 37, 37, 0, 22, 0, + /* 2090 */ 22, 499, 37, 0, 0, 429, 407, 0, 409, 37, + /* 2100 */ 0, 354, 37, 0, 22, 20, 37, 37, 37, 108, + /* 2110 */ 107, 0, 209, 107, 367, 449, 49, 354, 452, 0, + /* 2120 */ 37, 22, 456, 457, 458, 459, 460, 461, 182, 463, + /* 2130 */ 367, 22, 182, 0, 0, 0, 185, 33, 449, 182, + /* 2140 */ 354, 452, 395, 182, 3, 456, 457, 458, 459, 460, + /* 2150 */ 461, 182, 463, 367, 407, 189, 409, 205, 395, 277, + /* 2160 */ 107, 189, 37, 37, 108, 108, 107, 107, 50, 105, + /* 2170 */ 407, 50, 409, 33, 3, 103, 33, 33, 49, 49, + /* 2180 */ 107, 395, 108, 108, 354, 107, 33, 107, 33, 37, + /* 2190 */ 33, 502, 108, 407, 108, 409, 449, 367, 107, 452, + /* 2200 */ 108, 37, 37, 456, 457, 458, 459, 460, 461, 37, + /* 2210 */ 463, 37, 449, 277, 1, 452, 37, 49, 108, 456, + /* 2220 */ 457, 458, 459, 460, 461, 395, 463, 49, 465, 0, + /* 2230 */ 108, 0, 19, 42, 270, 449, 277, 407, 452, 409, + /* 2240 */ 33, 105, 456, 457, 458, 459, 460, 461, 35, 463, + /* 2250 */ 257, 105, 107, 354, 2, 22, 108, 107, 511, 429, + /* 2260 */ 234, 49, 108, 107, 51, 107, 367, 49, 108, 22, + /* 2270 */ 107, 354, 0, 60, 61, 62, 63, 108, 65, 449, + /* 2280 */ 42, 108, 452, 237, 367, 184, 456, 457, 458, 459, + /* 2290 */ 460, 461, 107, 463, 395, 107, 107, 107, 186, 116, + /* 2300 */ 49, 107, 107, 117, 108, 107, 407, 107, 409, 108, + /* 2310 */ 37, 37, 395, 107, 37, 37, 108, 107, 107, 106, + /* 2320 */ 37, 107, 109, 108, 407, 108, 409, 108, 429, 37, + /* 2330 */ 354, 107, 37, 108, 107, 107, 33, 107, 37, 107, + /* 2340 */ 22, 72, 71, 367, 128, 37, 78, 37, 449, 128, + /* 2350 */ 354, 452, 37, 37, 141, 456, 457, 458, 459, 460, + /* 2360 */ 461, 37, 463, 367, 128, 128, 449, 37, 37, 452, + /* 2370 */ 37, 395, 37, 456, 457, 458, 459, 460, 461, 33, + /* 2380 */ 463, 101, 78, 407, 37, 409, 101, 37, 354, 37, + /* 2390 */ 22, 395, 78, 37, 37, 37, 37, 184, 37, 37, + /* 2400 */ 37, 367, 37, 407, 191, 409, 22, 37, 354, 0, + /* 2410 */ 37, 51, 0, 42, 37, 51, 42, 0, 37, 0, + /* 2420 */ 51, 367, 42, 210, 37, 449, 51, 42, 452, 395, + /* 2430 */ 0, 37, 456, 457, 458, 459, 460, 461, 37, 463, + /* 2440 */ 0, 407, 22, 409, 33, 449, 22, 21, 452, 395, + /* 2450 */ 22, 22, 456, 457, 458, 459, 460, 461, 21, 463, + /* 2460 */ 514, 407, 20, 409, 514, 514, 514, 514, 514, 514, + /* 2470 */ 514, 514, 514, 514, 514, 514, 514, 514, 514, 514, + /* 2480 */ 514, 514, 514, 449, 514, 354, 452, 514, 514, 514, + /* 2490 */ 456, 457, 458, 459, 460, 461, 514, 463, 367, 514, + /* 2500 */ 514, 514, 514, 449, 514, 354, 452, 514, 514, 514, + /* 2510 */ 456, 457, 458, 459, 460, 461, 514, 463, 367, 514, + /* 2520 */ 514, 514, 514, 514, 514, 514, 395, 514, 514, 514, + /* 2530 */ 514, 514, 514, 514, 514, 514, 514, 514, 407, 514, + /* 2540 */ 409, 514, 514, 514, 514, 514, 395, 514, 514, 514, + /* 2550 */ 514, 514, 514, 514, 514, 514, 514, 514, 407, 514, + /* 2560 */ 409, 514, 514, 354, 514, 514, 514, 514, 514, 514, + /* 2570 */ 514, 514, 514, 514, 514, 514, 367, 514, 514, 514, + /* 2580 */ 449, 514, 514, 452, 514, 514, 514, 456, 457, 458, + /* 2590 */ 459, 460, 461, 354, 463, 514, 514, 514, 514, 514, + /* 2600 */ 449, 514, 514, 452, 395, 514, 367, 456, 457, 458, + /* 2610 */ 459, 460, 461, 514, 463, 514, 407, 514, 409, 514, + /* 2620 */ 514, 514, 514, 514, 514, 514, 514, 514, 514, 514, + /* 2630 */ 354, 514, 514, 514, 395, 514, 514, 514, 514, 514, + /* 2640 */ 514, 514, 514, 367, 514, 514, 407, 514, 409, 514, + /* 2650 */ 514, 514, 514, 514, 514, 514, 514, 514, 449, 514, + /* 2660 */ 514, 452, 514, 354, 514, 456, 457, 458, 459, 460, + /* 2670 */ 461, 395, 463, 514, 514, 514, 367, 514, 514, 514, + /* 2680 */ 514, 514, 514, 407, 514, 409, 514, 514, 449, 514, + /* 2690 */ 514, 452, 514, 514, 514, 456, 457, 458, 459, 460, + /* 2700 */ 461, 514, 463, 514, 395, 514, 514, 514, 514, 354, + /* 2710 */ 514, 514, 514, 514, 514, 514, 407, 514, 409, 514, + /* 2720 */ 514, 514, 367, 514, 514, 449, 514, 514, 452, 514, + /* 2730 */ 354, 514, 456, 457, 458, 459, 460, 461, 514, 463, + /* 2740 */ 514, 514, 514, 367, 514, 514, 354, 514, 514, 514, + /* 2750 */ 395, 514, 514, 514, 514, 514, 514, 514, 449, 367, + /* 2760 */ 514, 452, 407, 514, 409, 456, 457, 458, 459, 460, + /* 2770 */ 461, 395, 463, 514, 514, 514, 354, 514, 514, 514, + /* 2780 */ 514, 514, 514, 407, 514, 409, 514, 395, 514, 367, + /* 2790 */ 514, 514, 514, 514, 514, 514, 514, 514, 514, 407, + /* 2800 */ 514, 409, 514, 514, 449, 514, 514, 452, 514, 514, + /* 2810 */ 514, 456, 457, 458, 459, 460, 461, 395, 463, 514, + /* 2820 */ 514, 514, 514, 514, 514, 449, 514, 514, 452, 407, + /* 2830 */ 514, 409, 456, 457, 458, 459, 460, 461, 514, 463, + /* 2840 */ 514, 449, 514, 514, 452, 354, 514, 514, 456, 457, + /* 2850 */ 458, 459, 460, 461, 514, 463, 514, 514, 367, 514, + /* 2860 */ 354, 514, 514, 514, 514, 514, 514, 514, 514, 514, + /* 2870 */ 514, 449, 514, 367, 452, 514, 514, 514, 456, 457, + /* 2880 */ 458, 459, 460, 461, 514, 463, 395, 514, 514, 514, + /* 2890 */ 514, 514, 514, 514, 514, 514, 514, 514, 407, 514, + /* 2900 */ 409, 395, 514, 514, 514, 514, 514, 514, 514, 514, + /* 2910 */ 514, 514, 514, 407, 514, 409, 514, 514, 354, 514, + /* 2920 */ 514, 514, 514, 514, 514, 514, 514, 514, 514, 514, + /* 2930 */ 514, 367, 514, 514, 514, 514, 514, 514, 514, 514, + /* 2940 */ 449, 514, 514, 452, 354, 514, 514, 456, 457, 458, + /* 2950 */ 459, 460, 461, 514, 463, 449, 514, 367, 452, 395, + /* 2960 */ 514, 514, 456, 457, 458, 459, 460, 461, 514, 463, + /* 2970 */ 514, 407, 514, 409, 514, 514, 514, 514, 514, 514, + /* 2980 */ 514, 514, 514, 514, 514, 395, 514, 514, 514, 514, + /* 2990 */ 514, 514, 514, 514, 514, 514, 514, 407, 514, 409, + /* 3000 */ 514, 514, 514, 514, 514, 514, 514, 514, 514, 514, + /* 3010 */ 514, 514, 514, 449, 514, 514, 452, 514, 354, 514, + /* 3020 */ 456, 457, 458, 459, 460, 461, 514, 463, 514, 514, + /* 3030 */ 514, 367, 514, 514, 514, 514, 514, 514, 514, 449, + /* 3040 */ 514, 514, 452, 514, 514, 514, 456, 457, 458, 459, + /* 3050 */ 460, 461, 514, 463, 514, 514, 514, 514, 514, 395, + /* 3060 */ 514, 514, 514, 514, 514, 514, 514, 514, 514, 514, + /* 3070 */ 514, 407, 514, 409, 514, 514, 514, 514, 514, 514, + /* 3080 */ 514, 514, 514, 514, 514, 514, 514, 514, 514, 514, + /* 3090 */ 514, 514, 514, 514, 514, 514, 514, 514, 514, 514, + /* 3100 */ 514, 514, 514, 514, 514, 514, 514, 514, 514, 514, + /* 3110 */ 514, 514, 514, 449, 514, 514, 452, 514, 514, 514, + /* 3120 */ 456, 457, 458, 459, 460, 461, 514, 463, 351, 351, /* 3130 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, /* 3140 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, /* 3150 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, @@ -1197,225 +866,244 @@ static const YYCODETYPE yy_lookahead[] = { /* 3260 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, /* 3270 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, /* 3280 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, - /* 3290 */ 351, 351, + /* 3290 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, + /* 3300 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, + /* 3310 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, + /* 3320 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, + /* 3330 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, + /* 3340 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, + /* 3350 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, + /* 3360 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, + /* 3370 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, + /* 3380 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, + /* 3390 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, + /* 3400 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, + /* 3410 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, + /* 3420 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, + /* 3430 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, + /* 3440 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, + /* 3450 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, + /* 3460 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, + /* 3470 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, }; -#define YY_SHIFT_COUNT (851) +#define YY_SHIFT_COUNT (858) #define YY_SHIFT_MIN (0) -#define YY_SHIFT_MAX (2461) +#define YY_SHIFT_MAX (2442) static const unsigned short int yy_shift_ofst[] = { /* 0 */ 1300, 0, 244, 0, 489, 489, 489, 489, 489, 489, /* 10 */ 489, 489, 489, 489, 489, 489, 733, 977, 977, 1221, /* 20 */ 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, /* 30 */ 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, /* 40 */ 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, - /* 50 */ 977, 487, 567, 96, 210, 34, 92, 34, 34, 210, - /* 60 */ 210, 34, 1469, 34, 243, 1469, 1469, 675, 34, 131, - /* 70 */ 240, 165, 165, 857, 857, 240, 190, 330, 154, 154, - /* 80 */ 1, 165, 165, 165, 165, 165, 165, 165, 165, 165, - /* 90 */ 165, 165, 256, 320, 165, 165, 31, 131, 165, 256, - /* 100 */ 165, 131, 165, 165, 131, 165, 165, 131, 165, 131, - /* 110 */ 131, 131, 165, 405, 203, 203, 488, 748, 837, 837, - /* 120 */ 837, 837, 837, 837, 837, 837, 837, 837, 837, 837, - /* 130 */ 837, 837, 837, 837, 837, 837, 837, 1196, 409, 190, - /* 140 */ 330, 202, 202, 914, 413, 413, 413, 137, 334, 334, - /* 150 */ 1104, 914, 31, 442, 131, 131, 299, 131, 639, 131, - /* 160 */ 639, 639, 741, 763, 212, 212, 212, 212, 212, 212, - /* 170 */ 212, 212, 2113, 361, 657, 611, 15, 350, 380, 118, - /* 180 */ 878, 882, 255, 255, 278, 528, 430, 917, 917, 917, - /* 190 */ 892, 917, 905, 484, 33, 431, 950, 972, 33, 33, - /* 200 */ 1026, 983, 799, 505, 983, 532, 509, 1104, 1169, 1399, - /* 210 */ 1412, 1457, 1268, 31, 1457, 31, 1292, 1470, 1478, 1456, - /* 220 */ 1478, 1456, 1329, 1470, 1478, 1470, 1456, 1329, 1329, 1329, - /* 230 */ 1416, 1419, 1470, 1426, 1470, 1470, 1470, 1515, 1494, 1515, - /* 240 */ 1494, 1457, 31, 31, 1532, 31, 1538, 1539, 31, 1538, - /* 250 */ 31, 1546, 31, 31, 1470, 31, 1515, 131, 131, 131, - /* 260 */ 131, 131, 131, 131, 131, 131, 131, 131, 1470, 763, - /* 270 */ 763, 1515, 639, 639, 639, 1385, 1485, 1457, 405, 1608, - /* 280 */ 1421, 1423, 1532, 405, 1169, 1470, 639, 1349, 1356, 1349, - /* 290 */ 1356, 1357, 1466, 1349, 1376, 1382, 1387, 1169, 1377, 1379, - /* 300 */ 1383, 1408, 1478, 1660, 1567, 1417, 1538, 405, 405, 1356, - /* 310 */ 639, 639, 639, 639, 1356, 639, 1513, 405, 741, 405, - /* 320 */ 1478, 1609, 1624, 639, 1470, 405, 1717, 1709, 1515, 2941, - /* 330 */ 2941, 2941, 2941, 2941, 2941, 2941, 2941, 2941, 36, 480, - /* 340 */ 197, 887, 915, 81, 804, 510, 1097, 1191, 1079, 879, - /* 350 */ 1021, 1021, 1021, 1021, 1021, 1021, 1021, 1021, 1021, 216, - /* 360 */ 148, 12, 988, 988, 252, 217, 10, 146, 658, 1100, - /* 370 */ 608, 1030, 187, 620, 620, 918, 6, 864, 918, 918, - /* 380 */ 918, 919, 680, 727, 1154, 1165, 962, 1240, 1162, 1167, - /* 390 */ 1168, 1172, 1266, 1274, 1146, 1283, 1284, 1290, 1074, 1211, - /* 400 */ 1234, 1228, 1255, 1263, 1264, 1276, 1157, 1064, 1107, 1288, - /* 410 */ 1289, 1291, 1302, 1306, 1310, 1312, 1313, 410, 1319, 1246, - /* 420 */ 1322, 1324, 1325, 1341, 1370, 1371, 1243, 1122, 1126, 1314, - /* 430 */ 1348, 1267, 1391, 1768, 1778, 1780, 1736, 1782, 1746, 1557, - /* 440 */ 1748, 1750, 1751, 1562, 1794, 1758, 1760, 1580, 1771, 1809, - /* 450 */ 1584, 1813, 1777, 1815, 1779, 1817, 1796, 1819, 1783, 1599, - /* 460 */ 1834, 1613, 1824, 1615, 1616, 1622, 1626, 1829, 1830, 1831, - /* 470 */ 1634, 1639, 1837, 1838, 1691, 1791, 1795, 1843, 1811, 1846, - /* 480 */ 1849, 1816, 1799, 1852, 1806, 1856, 1820, 1866, 1867, 1869, - /* 490 */ 1821, 1872, 1873, 1874, 1878, 1879, 1880, 1716, 1845, 1883, - /* 500 */ 1719, 1885, 1888, 1890, 1891, 1901, 1903, 1904, 1905, 1906, - /* 510 */ 1907, 1908, 1909, 1910, 1911, 1912, 1913, 1914, 1920, 1921, - /* 520 */ 1882, 1932, 1853, 1936, 1937, 1938, 1939, 1941, 1944, 1945, - /* 530 */ 1896, 1946, 1786, 1947, 1801, 1949, 1804, 1951, 1952, 1931, - /* 540 */ 1915, 1940, 1916, 1954, 1894, 1919, 1960, 1899, 1961, 1902, - /* 550 */ 1963, 1968, 1942, 1922, 1927, 1971, 1943, 1923, 1933, 1976, - /* 560 */ 1948, 1926, 1953, 1978, 1956, 1982, 1955, 1959, 1950, 1964, - /* 570 */ 1967, 1972, 1974, 1998, 1965, 1970, 2025, 2026, 2027, 2039, - /* 580 */ 1987, 1839, 2030, 1964, 1984, 2031, 2034, 1969, 2035, 2036, - /* 590 */ 2000, 1993, 2003, 2042, 2009, 1996, 2007, 2051, 2017, 2004, - /* 600 */ 2015, 2058, 2022, 2010, 2018, 2062, 2063, 2064, 2065, 2066, - /* 610 */ 2067, 1958, 1962, 2032, 2052, 2071, 2040, 2041, 2043, 2045, - /* 620 */ 2046, 2047, 2048, 2050, 2055, 2056, 2053, 2059, 2054, 2068, - /* 630 */ 2079, 2070, 2103, 2084, 2107, 2086, 2060, 2111, 2099, 2088, - /* 640 */ 2126, 2127, 2128, 2092, 2130, 2094, 2133, 2114, 2115, 2101, - /* 650 */ 2102, 2112, 2044, 2061, 2150, 1973, 2072, 1957, 1964, 2104, - /* 660 */ 2154, 1975, 2121, 2138, 2161, 1966, 2140, 1985, 1995, 2169, - /* 670 */ 2170, 1990, 1992, 2001, 1997, 2179, 2151, 1917, 2078, 2080, - /* 680 */ 2082, 2083, 2155, 2156, 2089, 2145, 2093, 2147, 2097, 2095, - /* 690 */ 2172, 2173, 2100, 2109, 2116, 2117, 2118, 2176, 2153, 2171, - /* 700 */ 2120, 2188, 1979, 2123, 2125, 2222, 2195, 1980, 2192, 2197, - /* 710 */ 2198, 2199, 2200, 2201, 2131, 2134, 2196, 1988, 2208, 2206, - /* 720 */ 2244, 2259, 2157, 2218, 2159, 2162, 2165, 2168, 2180, 2075, - /* 730 */ 2182, 2262, 2221, 2085, 2183, 2152, 1964, 2227, 2234, 2178, - /* 740 */ 2037, 2181, 2290, 2269, 2069, 2189, 2187, 2191, 2194, 2193, - /* 750 */ 2202, 2250, 2204, 2205, 2257, 2207, 2286, 2077, 2209, 2203, - /* 760 */ 2210, 2280, 2282, 2214, 2216, 2285, 2219, 2220, 2293, 2224, - /* 770 */ 2225, 2295, 2228, 2226, 2299, 2230, 2231, 2301, 2233, 2223, - /* 780 */ 2232, 2235, 2236, 2237, 2276, 2240, 2305, 2241, 2276, 2276, - /* 790 */ 2328, 2296, 2291, 2324, 2330, 2333, 2334, 2343, 2344, 2347, - /* 800 */ 2350, 2357, 2319, 2298, 2323, 2303, 2369, 2368, 2370, 2371, - /* 810 */ 2387, 2373, 2374, 2375, 2335, 2055, 2377, 2056, 2378, 2380, - /* 820 */ 2382, 2385, 2399, 2386, 2425, 2389, 2376, 2388, 2428, 2392, - /* 830 */ 2381, 2391, 2431, 2397, 2400, 2393, 2437, 2403, 2402, 2401, - /* 840 */ 2455, 2420, 2423, 2461, 2441, 2438, 2451, 2443, 2452, 2453, - /* 850 */ 2458, 2456, + /* 50 */ 320, 332, 840, 424, 113, 296, 113, 113, 424, 424, + /* 60 */ 113, 1527, 113, 243, 1527, 96, 113, 420, 1581, 88, + /* 70 */ 624, 624, 1581, 1581, 1022, 1022, 88, 18, 403, 248, + /* 80 */ 248, 533, 624, 624, 624, 624, 624, 624, 624, 624, + /* 90 */ 624, 624, 624, 742, 805, 624, 624, 4, 420, 624, + /* 100 */ 742, 624, 420, 624, 624, 420, 624, 624, 420, 624, + /* 110 */ 420, 420, 420, 624, 866, 203, 203, 448, 634, 728, + /* 120 */ 728, 728, 728, 728, 728, 728, 728, 728, 728, 728, + /* 130 */ 728, 728, 728, 728, 728, 728, 728, 728, 1128, 85, + /* 140 */ 18, 403, 854, 854, 193, 570, 570, 570, 277, 277, + /* 150 */ 970, 638, 193, 4, 821, 420, 746, 420, 420, 874, + /* 160 */ 420, 874, 874, 1030, 1153, 212, 212, 212, 212, 212, + /* 170 */ 212, 212, 212, 2213, 361, 555, 692, 15, 69, 226, + /* 180 */ 488, 352, 816, 444, 444, 454, 781, 767, 136, 136, + /* 190 */ 136, 749, 679, 136, 998, 888, 990, 97, 1061, 888, + /* 200 */ 888, 1047, 978, 1002, 547, 978, 1038, 753, 638, 1207, + /* 210 */ 1433, 1443, 1468, 1281, 4, 1468, 4, 1303, 1487, 1490, + /* 220 */ 1466, 1490, 1466, 1339, 1487, 1490, 1487, 1466, 1339, 1339, + /* 230 */ 1339, 1430, 1434, 1487, 1440, 1487, 1487, 1487, 1530, 1502, + /* 240 */ 1530, 1502, 1468, 4, 4, 1538, 4, 1543, 1546, 4, + /* 250 */ 1543, 4, 1553, 4, 4, 1487, 4, 1530, 420, 420, + /* 260 */ 420, 420, 420, 420, 420, 420, 420, 420, 420, 1487, + /* 270 */ 1153, 1153, 1530, 874, 874, 874, 1366, 1503, 1468, 866, + /* 280 */ 1606, 1421, 1426, 1538, 866, 1207, 1487, 874, 1354, 1359, + /* 290 */ 1354, 1359, 1356, 1455, 1354, 1357, 1361, 1373, 1207, 1351, + /* 300 */ 1378, 1382, 1407, 1490, 1660, 1572, 1418, 1543, 866, 866, + /* 310 */ 1588, 1359, 874, 874, 874, 874, 1359, 874, 1518, 866, + /* 320 */ 1030, 866, 1490, 874, 874, 1617, 874, 1487, 866, 1708, + /* 330 */ 1696, 1530, 3128, 3128, 3128, 3128, 3128, 3128, 3128, 3128, + /* 340 */ 3128, 36, 844, 197, 1242, 54, 32, 77, 557, 673, + /* 350 */ 706, 635, 678, 910, 910, 910, 910, 910, 910, 910, + /* 360 */ 910, 910, 818, 729, 21, 292, 292, 584, 455, 683, + /* 370 */ 302, 91, 392, 260, 929, 1029, 883, 901, 31, 883, + /* 380 */ 883, 883, 863, 863, 812, 194, 837, 1208, 1218, 991, + /* 390 */ 1214, 1142, 1144, 1156, 1161, 1157, 1259, 161, 1253, 1265, + /* 400 */ 1270, 709, 1068, 1177, 1215, 1245, 1248, 1249, 1251, 1151, + /* 410 */ 1018, 1054, 1264, 1301, 1276, 43, 1278, 1230, 1280, 1283, + /* 420 */ 1286, 1287, 1297, 1292, 1273, 1275, 1310, 1312, 1313, 1322, + /* 430 */ 1325, 1344, 1199, 1285, 1296, 1323, 1385, 1261, 1376, 1752, + /* 440 */ 1766, 1767, 1718, 1768, 1733, 1544, 1735, 1736, 1737, 1555, + /* 450 */ 1784, 1749, 1750, 1561, 1753, 1789, 1564, 1792, 1756, 1794, + /* 460 */ 1758, 1796, 1776, 1799, 1764, 1580, 1803, 1594, 1805, 1596, + /* 470 */ 1597, 1603, 1610, 1810, 1814, 1816, 1619, 1621, 1819, 1820, + /* 480 */ 1673, 1773, 1774, 1824, 1788, 1826, 1828, 1800, 1785, 1838, + /* 490 */ 1790, 1842, 1798, 1844, 1845, 1846, 1801, 1847, 1848, 1849, + /* 500 */ 1852, 1856, 1857, 1699, 1829, 1867, 1704, 1871, 1873, 1874, + /* 510 */ 1875, 1878, 1879, 1881, 1883, 1884, 1885, 1887, 1888, 1889, + /* 520 */ 1890, 1891, 1892, 1893, 1894, 1896, 1851, 1897, 1863, 1901, + /* 530 */ 1910, 1911, 1912, 1913, 1914, 1915, 1895, 1918, 1771, 1923, + /* 540 */ 1777, 1926, 1782, 1935, 1937, 1916, 1900, 1920, 1902, 1940, + /* 550 */ 1880, 1907, 1949, 1886, 1953, 1898, 1954, 1955, 1919, 1906, + /* 560 */ 1922, 1958, 1924, 1909, 1925, 1965, 1929, 1921, 1927, 1968, + /* 570 */ 1933, 1971, 1928, 1932, 1943, 1930, 1931, 1963, 1934, 1978, + /* 580 */ 1939, 1944, 1985, 1994, 2000, 2004, 1956, 1804, 2005, 1930, + /* 590 */ 1947, 2008, 2009, 1938, 2011, 2012, 1977, 1962, 1974, 2018, + /* 600 */ 1982, 1970, 1980, 2023, 1987, 1975, 1983, 2027, 1991, 1979, + /* 610 */ 1989, 2029, 2032, 2038, 2039, 2040, 2042, 1948, 1941, 1997, + /* 620 */ 2013, 2036, 2010, 2021, 2022, 2025, 2033, 2035, 2037, 2041, + /* 630 */ 2043, 2044, 2045, 2048, 2024, 2049, 2079, 2058, 2081, 2061, + /* 640 */ 2087, 2066, 1992, 2089, 2068, 2055, 2093, 2094, 2097, 2062, + /* 650 */ 2100, 2065, 2103, 2082, 2085, 2069, 2070, 2071, 2001, 2003, + /* 660 */ 2111, 1946, 2006, 1903, 1930, 2067, 2119, 1950, 2083, 2099, + /* 670 */ 2133, 1952, 2109, 1957, 1951, 2134, 2135, 1961, 1966, 1969, + /* 680 */ 1972, 2141, 2104, 1882, 2053, 2056, 2059, 2057, 2125, 2126, + /* 690 */ 2060, 2118, 2064, 2121, 2072, 2074, 2140, 2143, 2075, 2073, + /* 700 */ 2078, 2080, 2084, 2144, 2129, 2130, 2091, 2153, 1936, 2086, + /* 710 */ 2092, 2171, 2155, 1959, 2152, 2164, 2165, 2172, 2174, 2179, + /* 720 */ 2110, 2122, 2168, 1964, 2157, 2178, 2229, 2231, 2145, 2191, + /* 730 */ 2207, 2136, 1993, 2146, 2252, 2233, 2026, 2148, 2150, 2154, + /* 740 */ 2212, 2156, 2158, 2218, 2160, 2247, 2046, 2163, 2169, 2173, + /* 750 */ 2185, 2188, 2112, 2189, 2272, 2238, 2101, 2190, 2183, 1930, + /* 760 */ 2251, 2194, 2195, 2196, 2198, 2200, 2186, 2201, 2273, 2274, + /* 770 */ 2206, 2208, 2277, 2210, 2215, 2278, 2211, 2217, 2283, 2214, + /* 780 */ 2219, 2292, 2224, 2225, 2295, 2227, 2216, 2221, 2236, 2237, + /* 790 */ 2228, 2303, 2230, 2301, 2232, 2303, 2303, 2318, 2269, 2271, + /* 800 */ 2308, 2310, 2315, 2316, 2324, 2330, 2331, 2333, 2335, 2268, + /* 810 */ 2280, 2304, 2285, 2346, 2347, 2350, 2352, 2368, 2356, 2357, + /* 820 */ 2358, 2314, 2043, 2359, 2044, 2361, 2362, 2363, 2365, 2384, + /* 830 */ 2370, 2409, 2373, 2360, 2371, 2412, 2377, 2364, 2374, 2417, + /* 840 */ 2381, 2369, 2380, 2419, 2387, 2375, 2385, 2430, 2394, 2401, + /* 850 */ 2440, 2420, 2411, 2424, 2426, 2428, 2429, 2437, 2442, }; -#define YY_REDUCE_COUNT (337) -#define YY_REDUCE_MIN (-464) -#define YY_REDUCE_MAX (2479) +#define YY_REDUCE_COUNT (340) +#define YY_REDUCE_MIN (-471) +#define YY_REDUCE_MAX (2664) static const short yy_reduce_ofst[] = { - /* 0 */ 1185, -309, 149, 394, 427, 671, 694, 729, 922, 980, - /* 10 */ 247, 1130, 1153, 1188, 1287, 1318, -82, 1345, 502, 1403, - /* 20 */ 1438, 1468, 1533, 1548, 1563, 1643, 1661, 1686, 1756, 1792, - /* 30 */ 1823, 1898, 1918, 1934, 1991, 2011, 2029, 2049, 2087, 2124, - /* 40 */ 2144, 2160, 2253, 2272, 2289, 2346, 2367, 2384, 2404, 2442, - /* 50 */ 2479, -311, -218, -426, 72, -419, 284, 326, 525, -173, - /* 60 */ 56, 762, -382, -439, -258, 122, 246, -464, -301, 125, - /* 70 */ -325, -327, 51, -359, -203, -336, -219, 113, -91, -75, - /* 80 */ -67, 385, 421, 438, 477, -135, 296, 232, 504, 550, - /* 90 */ 678, 301, -55, -317, 683, 687, -375, 128, 690, 309, - /* 100 */ 749, 162, 805, 808, 397, 871, 880, 400, 803, 428, - /* 110 */ 419, 443, 884, -313, -423, -423, 316, -321, -44, 50, - /* 120 */ 171, 287, 319, 356, 500, 503, 511, 519, 533, 640, - /* 130 */ 644, 652, 653, 668, 670, 754, 802, -186, -23, 21, - /* 140 */ -195, 454, 594, 563, -23, 415, 786, 173, -393, 144, - /* 150 */ 314, 868, 227, 363, -392, 554, 601, 469, 700, 618, - /* 160 */ 769, 848, 883, 408, 566, 595, 613, 706, 812, 818, - /* 170 */ 906, 812, 465, 931, 943, 896, 810, 834, 846, 978, - /* 180 */ 961, 961, 979, 999, 966, 1027, 973, 900, 902, 908, - /* 190 */ 982, 921, 961, 1042, 993, 1048, 1010, 985, 997, 1000, - /* 200 */ 961, 942, 942, 923, 942, 955, 957, 1055, 1016, 1001, - /* 210 */ 1009, 1038, 1036, 1111, 1045, 1113, 1056, 1127, 1133, 1086, - /* 220 */ 1136, 1089, 1096, 1144, 1147, 1145, 1099, 1103, 1105, 1106, - /* 230 */ 1138, 1149, 1158, 1161, 1174, 1175, 1177, 1186, 1183, 1190, - /* 240 */ 1187, 1109, 1178, 1179, 1148, 1181, 1193, 1131, 1189, 1197, - /* 250 */ 1192, 1151, 1194, 1195, 1202, 1200, 1212, 1182, 1184, 1198, - /* 260 */ 1199, 1204, 1205, 1210, 1218, 1222, 1223, 1227, 1214, 1219, - /* 270 */ 1225, 1231, 1209, 1216, 1217, 1206, 1207, 1208, 1254, 1226, - /* 280 */ 1201, 1215, 1224, 1258, 1203, 1269, 1230, 1164, 1232, 1171, - /* 290 */ 1233, 1170, 1173, 1220, 1180, 1213, 1236, 1244, 1238, 1176, - /* 300 */ 1229, 942, 1316, 1235, 1242, 1245, 1321, 1320, 1327, 1270, - /* 310 */ 1294, 1298, 1299, 1301, 1272, 1303, 1286, 1336, 1323, 1342, - /* 320 */ 1359, 1259, 1333, 1330, 1368, 1363, 1394, 1393, 1392, 1328, - /* 330 */ 1315, 1335, 1337, 1367, 1375, 1378, 1397, 1413, + /* 0 */ 164, -311, 149, 182, 394, 426, 639, 670, 922, 1139, + /* 10 */ 1213, 1290, 1402, 1446, 1473, 1532, 739, -82, 980, 1257, + /* 20 */ 1592, 1608, 1666, 1689, 1747, 1763, 1830, 1899, 954, 1786, + /* 30 */ 1917, 1976, 1996, 2034, 2054, 2131, 2151, 2209, 2239, 2276, + /* 40 */ 2309, 2355, 2376, 2392, 2422, 2491, 2506, 2564, 2590, 2664, + /* 50 */ -313, 117, -427, -191, 282, 357, 513, 607, -159, 344, + /* 60 */ 674, -194, -303, -317, -90, 274, 408, -385, -14, -144, + /* 70 */ -360, -287, 232, 240, -66, 153, -377, -15, 289, -347, + /* 80 */ 3, -356, 171, 208, 261, 506, 62, 196, 575, 625, + /* 90 */ 664, 690, 430, 439, -350, 694, 696, 58, -242, 708, + /* 100 */ 492, 737, -218, 751, 769, 397, 775, 783, 307, 785, + /* 110 */ 407, 356, 620, 787, 224, -471, -471, -301, -216, -251, + /* 120 */ 30, 106, 342, 372, 400, 406, 484, 640, 659, 671, + /* 130 */ 718, 732, 736, 778, 830, 852, 853, 855, -342, -447, + /* 140 */ -69, -98, -43, 593, 782, -447, 199, 577, -464, 380, + /* 150 */ 205, -211, 794, 684, 27, 35, 147, 654, 777, 267, + /* 160 */ 795, 427, 831, 798, 835, 892, 894, 930, 931, 936, + /* 170 */ 939, 942, 936, 905, 966, 1007, 950, 861, 898, 899, + /* 180 */ 1034, 1005, 1005, 1033, 1036, 1004, 1062, 1006, 934, 935, + /* 190 */ 944, 1001, 1005, 946, 1072, 1027, 1081, 1043, 1012, 1031, + /* 200 */ 1058, 1005, 969, 969, 949, 969, 982, 993, 1096, 1051, + /* 210 */ 1035, 1037, 1049, 1053, 1122, 1059, 1129, 1071, 1143, 1147, + /* 220 */ 1099, 1149, 1101, 1106, 1154, 1155, 1158, 1105, 1112, 1114, + /* 230 */ 1115, 1159, 1163, 1170, 1166, 1178, 1179, 1181, 1192, 1190, + /* 240 */ 1195, 1193, 1116, 1180, 1182, 1152, 1185, 1197, 1135, 1194, + /* 250 */ 1202, 1196, 1160, 1200, 1201, 1211, 1203, 1220, 1186, 1187, + /* 260 */ 1189, 1191, 1206, 1209, 1217, 1222, 1224, 1226, 1228, 1219, + /* 270 */ 1232, 1233, 1247, 1167, 1223, 1225, 1168, 1183, 1184, 1252, + /* 280 */ 1198, 1205, 1204, 1227, 1262, 1210, 1268, 1231, 1146, 1229, + /* 290 */ 1162, 1234, 1164, 1172, 1165, 1169, 1188, 1173, 1236, 1171, + /* 300 */ 1175, 1150, 969, 1319, 1235, 1212, 1216, 1324, 1320, 1321, + /* 310 */ 1237, 1271, 1291, 1294, 1298, 1304, 1279, 1305, 1302, 1334, + /* 320 */ 1317, 1346, 1355, 1314, 1318, 1327, 1326, 1362, 1363, 1379, + /* 330 */ 1377, 1381, 1306, 1299, 1328, 1329, 1349, 1368, 1370, 1371, + /* 340 */ 1392, }; static const YYACTIONTYPE yy_default[] = { - /* 0 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 10 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 20 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 30 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 40 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 50 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 60 */ 1905, 2245, 1905, 1905, 2208, 1905, 1905, 1905, 1905, 1905, - /* 70 */ 1905, 1905, 1905, 1905, 1905, 1905, 2215, 1905, 1905, 1905, - /* 80 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 90 */ 1905, 1905, 1905, 1905, 1905, 1905, 2004, 1905, 1905, 1905, - /* 100 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 110 */ 1905, 1905, 1905, 2002, 2448, 1905, 1905, 1905, 1905, 1905, - /* 120 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 130 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 2460, 1905, - /* 140 */ 1905, 1976, 1976, 1905, 2460, 2460, 2460, 2002, 2420, 2420, - /* 150 */ 1905, 1905, 2004, 2283, 1905, 1905, 1905, 1905, 1905, 1905, - /* 160 */ 1905, 1905, 2127, 1935, 1905, 1905, 1905, 1905, 2151, 1905, - /* 170 */ 1905, 1905, 2271, 1905, 1905, 2489, 2551, 1905, 2492, 1905, - /* 180 */ 1905, 1905, 1905, 1905, 2220, 1905, 2479, 1905, 1905, 1905, - /* 190 */ 1905, 1905, 1905, 1905, 1905, 1905, 2080, 2265, 1905, 1905, - /* 200 */ 1905, 2452, 2466, 2535, 2453, 2450, 2473, 1905, 2483, 1905, - /* 210 */ 2308, 1905, 2297, 2004, 1905, 2004, 2258, 2203, 1905, 2213, - /* 220 */ 1905, 2213, 2210, 1905, 1905, 1905, 2213, 2210, 2210, 2210, - /* 230 */ 2069, 2065, 1905, 2063, 1905, 1905, 1905, 1905, 1960, 1905, - /* 240 */ 1960, 1905, 2004, 2004, 1905, 2004, 1905, 1905, 2004, 1905, - /* 250 */ 2004, 1905, 2004, 2004, 1905, 2004, 1905, 1905, 1905, 1905, - /* 260 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 270 */ 1905, 1905, 1905, 1905, 1905, 2295, 2281, 1905, 2002, 1905, - /* 280 */ 2269, 2267, 1905, 2002, 2483, 1905, 1905, 2505, 2500, 2505, - /* 290 */ 2500, 2519, 2515, 2505, 2524, 2521, 2485, 2483, 2554, 2541, - /* 300 */ 2537, 2466, 1905, 1905, 2471, 2469, 1905, 2002, 2002, 2500, - /* 310 */ 1905, 1905, 1905, 1905, 2500, 1905, 1905, 2002, 1905, 2002, - /* 320 */ 1905, 1905, 2096, 1905, 1905, 2002, 1905, 1944, 1905, 2260, - /* 330 */ 2286, 2241, 2241, 2130, 2130, 2130, 2005, 1910, 1905, 1905, - /* 340 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 350 */ 2518, 2517, 2373, 1905, 2424, 2423, 2422, 2413, 2372, 2092, - /* 360 */ 1905, 1905, 2371, 2370, 1905, 1905, 1905, 1905, 1905, 1905, - /* 370 */ 1905, 1905, 1905, 2232, 2231, 2364, 1905, 1905, 2365, 2363, - /* 380 */ 2362, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 390 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 400 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 2538, 2542, 1905, - /* 410 */ 1905, 1905, 1905, 1905, 1905, 2449, 1905, 1905, 1905, 2344, - /* 420 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 430 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 440 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 450 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 460 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 470 */ 1905, 1905, 1905, 1905, 2209, 1905, 1905, 1905, 1905, 1905, - /* 480 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 490 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 500 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 510 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 520 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 530 */ 1905, 1905, 1905, 1905, 1905, 1905, 2224, 1905, 1905, 1905, - /* 540 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 550 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 560 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1949, 2351, - /* 570 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 580 */ 1905, 1905, 1905, 2354, 1905, 1905, 1905, 1905, 1905, 1905, - /* 590 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 600 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 610 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 620 */ 1905, 1905, 1905, 1905, 2044, 2043, 1905, 1905, 1905, 1905, - /* 630 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 640 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 650 */ 1905, 1905, 2355, 1905, 1905, 1905, 1905, 1905, 2346, 1905, - /* 660 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 670 */ 1905, 1905, 1905, 1905, 1905, 2534, 2486, 1905, 1905, 1905, - /* 680 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 690 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 2344, - /* 700 */ 1905, 2516, 1905, 1905, 2532, 1905, 2536, 1905, 1905, 1905, - /* 710 */ 1905, 1905, 1905, 1905, 2459, 2455, 1905, 1905, 2451, 1905, - /* 720 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 730 */ 1905, 1905, 1905, 1905, 1905, 1905, 2343, 1905, 2410, 1905, - /* 740 */ 1905, 1905, 2444, 1905, 1905, 2395, 1905, 1905, 1905, 1905, - /* 750 */ 1905, 1905, 1905, 1905, 1905, 2355, 1905, 2358, 1905, 1905, - /* 760 */ 1905, 1905, 1905, 2124, 1905, 1905, 1905, 1905, 1905, 1905, - /* 770 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 2108, - /* 780 */ 2106, 2105, 2104, 1905, 2137, 1905, 1905, 1905, 2133, 2132, - /* 790 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 800 */ 1905, 1905, 1905, 1905, 1905, 1905, 2023, 1905, 1905, 1905, - /* 810 */ 1905, 1905, 1905, 1905, 1905, 2015, 1905, 2014, 1905, 1905, - /* 820 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 830 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, - /* 840 */ 1905, 1905, 1905, 1905, 1905, 1934, 1905, 1905, 1905, 1905, - /* 850 */ 1905, 1905, + /* 0 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 10 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 20 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 30 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 40 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 50 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 60 */ 2279, 1939, 1939, 2242, 1939, 1939, 1939, 1939, 1939, 1939, + /* 70 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 2249, 1939, 1939, + /* 80 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 90 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 2038, 1939, 1939, + /* 100 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 110 */ 1939, 1939, 1939, 1939, 2036, 2497, 1939, 1939, 1939, 1939, + /* 120 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 130 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 2509, + /* 140 */ 1939, 1939, 2010, 2010, 1939, 2509, 2509, 2509, 2469, 2469, + /* 150 */ 2036, 1939, 1939, 2038, 2317, 1939, 1939, 1939, 1939, 1939, + /* 160 */ 1939, 1939, 1939, 2161, 1969, 1939, 1939, 1939, 1939, 2185, + /* 170 */ 1939, 1939, 1939, 2305, 1939, 1939, 2538, 2600, 1939, 2541, + /* 180 */ 1939, 1939, 1939, 1939, 1939, 2254, 1939, 2528, 1939, 1939, + /* 190 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 2114, 2299, 1939, + /* 200 */ 1939, 1939, 2501, 2515, 2584, 2502, 2499, 2522, 1939, 2532, + /* 210 */ 1939, 2342, 1939, 2331, 2038, 1939, 2038, 2292, 2237, 1939, + /* 220 */ 2247, 1939, 2247, 2244, 1939, 1939, 1939, 2247, 2244, 2244, + /* 230 */ 2244, 2103, 2099, 1939, 2097, 1939, 1939, 1939, 1939, 1994, + /* 240 */ 1939, 1994, 1939, 2038, 2038, 1939, 2038, 1939, 1939, 2038, + /* 250 */ 1939, 2038, 1939, 2038, 2038, 1939, 2038, 1939, 1939, 1939, + /* 260 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 270 */ 1939, 1939, 1939, 1939, 1939, 1939, 2329, 2315, 1939, 2036, + /* 280 */ 1939, 2303, 2301, 1939, 2036, 2532, 1939, 1939, 2554, 2549, + /* 290 */ 2554, 2549, 2568, 2564, 2554, 2573, 2570, 2534, 2532, 2603, + /* 300 */ 2590, 2586, 2515, 1939, 1939, 2520, 2518, 1939, 2036, 2036, + /* 310 */ 1939, 2549, 1939, 1939, 1939, 1939, 2549, 1939, 1939, 2036, + /* 320 */ 1939, 2036, 1939, 1939, 1939, 2130, 1939, 1939, 2036, 1939, + /* 330 */ 1978, 1939, 2294, 2320, 2275, 2275, 2164, 2164, 2164, 2039, + /* 340 */ 1944, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 350 */ 1939, 1939, 1939, 2567, 2566, 2421, 1939, 2473, 2472, 2471, + /* 360 */ 2462, 2420, 2126, 1939, 1939, 2419, 2418, 1939, 1939, 1939, + /* 370 */ 1939, 1939, 1939, 1939, 1939, 1939, 2412, 1939, 1939, 2413, + /* 380 */ 2411, 2410, 2266, 2265, 1939, 1939, 1939, 1939, 1939, 1939, + /* 390 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 400 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 410 */ 2587, 2591, 1939, 2498, 1939, 1939, 1939, 2392, 1939, 1939, + /* 420 */ 1939, 1939, 1939, 2360, 1939, 1939, 1939, 1939, 1939, 1939, + /* 430 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 440 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 450 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 460 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 470 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 480 */ 2243, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 490 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 500 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 510 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 520 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 530 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 540 */ 1939, 1939, 2258, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 550 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 560 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 570 */ 1939, 1939, 1939, 1939, 1983, 2399, 1939, 1939, 1939, 1939, + /* 580 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 2402, + /* 590 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 600 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 610 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 620 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 630 */ 2078, 2077, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 640 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 650 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 2403, 1939, + /* 660 */ 1939, 1939, 1939, 1939, 2394, 1939, 1939, 1939, 1939, 1939, + /* 670 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 680 */ 1939, 2583, 2535, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 690 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 700 */ 1939, 1939, 1939, 1939, 1939, 2392, 1939, 2565, 1939, 1939, + /* 710 */ 2581, 1939, 2585, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 720 */ 2508, 2504, 1939, 1939, 2500, 1939, 1939, 1939, 1939, 1939, + /* 730 */ 2459, 1939, 1939, 1939, 2493, 1939, 1939, 1939, 1939, 1939, + /* 740 */ 1939, 1939, 1939, 1939, 2403, 1939, 2406, 1939, 1939, 1939, + /* 750 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 2391, + /* 760 */ 1939, 2444, 2443, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 770 */ 2158, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 780 */ 1939, 1939, 1939, 1939, 1939, 1939, 2142, 2140, 2139, 2138, + /* 790 */ 1939, 2171, 1939, 1939, 1939, 2167, 2166, 1939, 1939, 1939, + /* 800 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 810 */ 1939, 1939, 1939, 2057, 1939, 1939, 1939, 1939, 1939, 1939, + /* 820 */ 1939, 1939, 2049, 1939, 2048, 1939, 1939, 1939, 1939, 1939, + /* 830 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 840 */ 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, 1939, + /* 850 */ 1939, 1939, 1968, 1939, 1939, 1939, 1939, 1939, 1939, }; /********** End of lemon-generated parsing tables *****************************/ @@ -1837,7 +1525,6 @@ struct yyParser { }; typedef struct yyParser yyParser; -#include #ifndef NDEBUG #include static FILE *yyTraceFILE = 0; @@ -2271,10 +1958,10 @@ static const char *const yyTokenName[] = { /* 394 */ "alter_table_options", /* 395 */ "column_name", /* 396 */ "type_name", - /* 397 */ "signed_literal", + /* 397 */ "tags_literal", /* 398 */ "create_subtable_clause", /* 399 */ "specific_cols_opt", - /* 400 */ "expression_list", + /* 400 */ "tags_literal_list", /* 401 */ "drop_table_clause", /* 402 */ "col_name_list", /* 403 */ "column_def", @@ -2303,89 +1990,91 @@ static const char *const yyTokenName[] = { /* 426 */ "sma_stream_opt", /* 427 */ "func", /* 428 */ "sma_func_name", - /* 429 */ "with_meta", - /* 430 */ "query_or_subquery", - /* 431 */ "where_clause_opt", - /* 432 */ "cgroup_name", - /* 433 */ "analyze_opt", - /* 434 */ "explain_options", - /* 435 */ "insert_query", - /* 436 */ "or_replace_opt", - /* 437 */ "agg_func_opt", - /* 438 */ "bufsize_opt", - /* 439 */ "language_opt", - /* 440 */ "full_view_name", - /* 441 */ "view_name", - /* 442 */ "stream_name", - /* 443 */ "stream_options", - /* 444 */ "col_list_opt", - /* 445 */ "tag_def_or_ref_opt", - /* 446 */ "subtable_opt", - /* 447 */ "ignore_opt", - /* 448 */ "expression", - /* 449 */ "on_vgroup_id", - /* 450 */ "dnode_list", - /* 451 */ "literal_func", - /* 452 */ "literal_list", - /* 453 */ "table_alias", - /* 454 */ "expr_or_subquery", - /* 455 */ "pseudo_column", - /* 456 */ "column_reference", - /* 457 */ "function_expression", - /* 458 */ "case_when_expression", - /* 459 */ "star_func", - /* 460 */ "star_func_para_list", - /* 461 */ "noarg_func", - /* 462 */ "other_para_list", - /* 463 */ "star_func_para", - /* 464 */ "when_then_list", - /* 465 */ "case_when_else_opt", - /* 466 */ "common_expression", - /* 467 */ "when_then_expr", - /* 468 */ "predicate", - /* 469 */ "compare_op", - /* 470 */ "in_op", - /* 471 */ "in_predicate_value", - /* 472 */ "boolean_value_expression", - /* 473 */ "boolean_primary", - /* 474 */ "from_clause_opt", - /* 475 */ "table_reference_list", - /* 476 */ "table_reference", - /* 477 */ "table_primary", - /* 478 */ "joined_table", - /* 479 */ "alias_opt", - /* 480 */ "subquery", - /* 481 */ "parenthesized_joined_table", - /* 482 */ "join_type", - /* 483 */ "query_specification", - /* 484 */ "hint_list", - /* 485 */ "set_quantifier_opt", - /* 486 */ "tag_mode_opt", - /* 487 */ "select_list", - /* 488 */ "partition_by_clause_opt", - /* 489 */ "range_opt", - /* 490 */ "every_opt", - /* 491 */ "fill_opt", - /* 492 */ "twindow_clause_opt", - /* 493 */ "group_by_clause_opt", - /* 494 */ "having_clause_opt", - /* 495 */ "select_item", - /* 496 */ "partition_list", - /* 497 */ "partition_item", - /* 498 */ "interval_sliding_duration_literal", - /* 499 */ "fill_mode", - /* 500 */ "group_by_list", - /* 501 */ "query_expression", - /* 502 */ "query_simple", - /* 503 */ "order_by_clause_opt", - /* 504 */ "slimit_clause_opt", - /* 505 */ "limit_clause_opt", - /* 506 */ "union_query_expression", - /* 507 */ "query_simple_or_subquery", - /* 508 */ "sort_specification_list", - /* 509 */ "sort_specification", - /* 510 */ "ordering_specification_opt", - /* 511 */ "null_ordering_opt", + /* 429 */ "expression_list", + /* 430 */ "with_meta", + /* 431 */ "query_or_subquery", + /* 432 */ "where_clause_opt", + /* 433 */ "cgroup_name", + /* 434 */ "analyze_opt", + /* 435 */ "explain_options", + /* 436 */ "insert_query", + /* 437 */ "or_replace_opt", + /* 438 */ "agg_func_opt", + /* 439 */ "bufsize_opt", + /* 440 */ "language_opt", + /* 441 */ "full_view_name", + /* 442 */ "view_name", + /* 443 */ "stream_name", + /* 444 */ "stream_options", + /* 445 */ "col_list_opt", + /* 446 */ "tag_def_or_ref_opt", + /* 447 */ "subtable_opt", + /* 448 */ "ignore_opt", + /* 449 */ "expression", + /* 450 */ "on_vgroup_id", + /* 451 */ "dnode_list", + /* 452 */ "literal_func", + /* 453 */ "signed_literal", + /* 454 */ "literal_list", + /* 455 */ "table_alias", + /* 456 */ "expr_or_subquery", + /* 457 */ "pseudo_column", + /* 458 */ "column_reference", + /* 459 */ "function_expression", + /* 460 */ "case_when_expression", + /* 461 */ "star_func", + /* 462 */ "star_func_para_list", + /* 463 */ "noarg_func", + /* 464 */ "other_para_list", + /* 465 */ "star_func_para", + /* 466 */ "when_then_list", + /* 467 */ "case_when_else_opt", + /* 468 */ "common_expression", + /* 469 */ "when_then_expr", + /* 470 */ "predicate", + /* 471 */ "compare_op", + /* 472 */ "in_op", + /* 473 */ "in_predicate_value", + /* 474 */ "boolean_value_expression", + /* 475 */ "boolean_primary", + /* 476 */ "from_clause_opt", + /* 477 */ "table_reference_list", + /* 478 */ "table_reference", + /* 479 */ "table_primary", + /* 480 */ "joined_table", + /* 481 */ "alias_opt", + /* 482 */ "subquery", + /* 483 */ "parenthesized_joined_table", + /* 484 */ "join_type", + /* 485 */ "query_specification", + /* 486 */ "hint_list", + /* 487 */ "set_quantifier_opt", + /* 488 */ "tag_mode_opt", + /* 489 */ "select_list", + /* 490 */ "partition_by_clause_opt", + /* 491 */ "range_opt", + /* 492 */ "every_opt", + /* 493 */ "fill_opt", + /* 494 */ "twindow_clause_opt", + /* 495 */ "group_by_clause_opt", + /* 496 */ "having_clause_opt", + /* 497 */ "select_item", + /* 498 */ "partition_list", + /* 499 */ "partition_item", + /* 500 */ "interval_sliding_duration_literal", + /* 501 */ "fill_mode", + /* 502 */ "group_by_list", + /* 503 */ "query_expression", + /* 504 */ "query_simple", + /* 505 */ "order_by_clause_opt", + /* 506 */ "slimit_clause_opt", + /* 507 */ "limit_clause_opt", + /* 508 */ "union_query_expression", + /* 509 */ "query_simple_or_subquery", + /* 510 */ "sort_specification_list", + /* 511 */ "sort_specification", + /* 512 */ "ordering_specification_opt", + /* 513 */ "null_ordering_opt", }; #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */ @@ -2574,10 +2263,10 @@ static const char *const yyRuleName[] = { /* 178 */ "alter_table_clause ::= full_table_name DROP TAG column_name", /* 179 */ "alter_table_clause ::= full_table_name MODIFY TAG column_name type_name", /* 180 */ "alter_table_clause ::= full_table_name RENAME TAG column_name column_name", - /* 181 */ "alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal", + /* 181 */ "alter_table_clause ::= full_table_name SET TAG column_name NK_EQ tags_literal", /* 182 */ "multi_create_clause ::= create_subtable_clause", /* 183 */ "multi_create_clause ::= multi_create_clause create_subtable_clause", - /* 184 */ "create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP expression_list NK_RP table_options", + /* 184 */ "create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP tags_literal_list NK_RP table_options", /* 185 */ "multi_drop_clause ::= drop_table_clause", /* 186 */ "multi_drop_clause ::= multi_drop_clause NK_COMMA drop_table_clause", /* 187 */ "drop_table_clause ::= exists_opt full_table_name", @@ -2802,246 +2491,261 @@ static const char *const yyRuleName[] = { /* 406 */ "cmd ::= insert_query", /* 407 */ "insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery", /* 408 */ "insert_query ::= INSERT INTO full_table_name query_or_subquery", - /* 409 */ "literal ::= NK_INTEGER", - /* 410 */ "literal ::= NK_FLOAT", - /* 411 */ "literal ::= NK_STRING", - /* 412 */ "literal ::= NK_BOOL", - /* 413 */ "literal ::= TIMESTAMP NK_STRING", - /* 414 */ "literal ::= duration_literal", - /* 415 */ "literal ::= NULL", - /* 416 */ "literal ::= NK_QUESTION", - /* 417 */ "duration_literal ::= NK_VARIABLE", - /* 418 */ "signed ::= NK_INTEGER", - /* 419 */ "signed ::= NK_PLUS NK_INTEGER", - /* 420 */ "signed ::= NK_MINUS NK_INTEGER", - /* 421 */ "signed ::= NK_FLOAT", - /* 422 */ "signed ::= NK_PLUS NK_FLOAT", - /* 423 */ "signed ::= NK_MINUS NK_FLOAT", - /* 424 */ "signed_literal ::= signed", - /* 425 */ "signed_literal ::= NK_STRING", - /* 426 */ "signed_literal ::= NK_BOOL", - /* 427 */ "signed_literal ::= TIMESTAMP NK_STRING", - /* 428 */ "signed_literal ::= duration_literal", - /* 429 */ "signed_literal ::= NULL", - /* 430 */ "signed_literal ::= literal_func", - /* 431 */ "signed_literal ::= NK_QUESTION", - /* 432 */ "literal_list ::= signed_literal", - /* 433 */ "literal_list ::= literal_list NK_COMMA signed_literal", - /* 434 */ "db_name ::= NK_ID", - /* 435 */ "table_name ::= NK_ID", - /* 436 */ "column_name ::= NK_ID", - /* 437 */ "function_name ::= NK_ID", - /* 438 */ "view_name ::= NK_ID", - /* 439 */ "table_alias ::= NK_ID", - /* 440 */ "column_alias ::= NK_ID", - /* 441 */ "column_alias ::= NK_ALIAS", - /* 442 */ "user_name ::= NK_ID", - /* 443 */ "topic_name ::= NK_ID", - /* 444 */ "stream_name ::= NK_ID", - /* 445 */ "cgroup_name ::= NK_ID", - /* 446 */ "index_name ::= NK_ID", - /* 447 */ "expr_or_subquery ::= expression", - /* 448 */ "expression ::= literal", - /* 449 */ "expression ::= pseudo_column", - /* 450 */ "expression ::= column_reference", - /* 451 */ "expression ::= function_expression", - /* 452 */ "expression ::= case_when_expression", - /* 453 */ "expression ::= NK_LP expression NK_RP", - /* 454 */ "expression ::= NK_PLUS expr_or_subquery", - /* 455 */ "expression ::= NK_MINUS expr_or_subquery", - /* 456 */ "expression ::= expr_or_subquery NK_PLUS expr_or_subquery", - /* 457 */ "expression ::= expr_or_subquery NK_MINUS expr_or_subquery", - /* 458 */ "expression ::= expr_or_subquery NK_STAR expr_or_subquery", - /* 459 */ "expression ::= expr_or_subquery NK_SLASH expr_or_subquery", - /* 460 */ "expression ::= expr_or_subquery NK_REM expr_or_subquery", - /* 461 */ "expression ::= column_reference NK_ARROW NK_STRING", - /* 462 */ "expression ::= expr_or_subquery NK_BITAND expr_or_subquery", - /* 463 */ "expression ::= expr_or_subquery NK_BITOR expr_or_subquery", - /* 464 */ "expression_list ::= expr_or_subquery", - /* 465 */ "expression_list ::= expression_list NK_COMMA expr_or_subquery", - /* 466 */ "column_reference ::= column_name", - /* 467 */ "column_reference ::= table_name NK_DOT column_name", - /* 468 */ "column_reference ::= NK_ALIAS", - /* 469 */ "column_reference ::= table_name NK_DOT NK_ALIAS", - /* 470 */ "pseudo_column ::= ROWTS", - /* 471 */ "pseudo_column ::= TBNAME", - /* 472 */ "pseudo_column ::= table_name NK_DOT TBNAME", - /* 473 */ "pseudo_column ::= QSTART", - /* 474 */ "pseudo_column ::= QEND", - /* 475 */ "pseudo_column ::= QDURATION", - /* 476 */ "pseudo_column ::= WSTART", - /* 477 */ "pseudo_column ::= WEND", - /* 478 */ "pseudo_column ::= WDURATION", - /* 479 */ "pseudo_column ::= IROWTS", - /* 480 */ "pseudo_column ::= ISFILLED", - /* 481 */ "pseudo_column ::= QTAGS", - /* 482 */ "function_expression ::= function_name NK_LP expression_list NK_RP", - /* 483 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP", - /* 484 */ "function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP", - /* 485 */ "function_expression ::= literal_func", - /* 486 */ "literal_func ::= noarg_func NK_LP NK_RP", - /* 487 */ "literal_func ::= NOW", - /* 488 */ "noarg_func ::= NOW", - /* 489 */ "noarg_func ::= TODAY", - /* 490 */ "noarg_func ::= TIMEZONE", - /* 491 */ "noarg_func ::= DATABASE", - /* 492 */ "noarg_func ::= CLIENT_VERSION", - /* 493 */ "noarg_func ::= SERVER_VERSION", - /* 494 */ "noarg_func ::= SERVER_STATUS", - /* 495 */ "noarg_func ::= CURRENT_USER", - /* 496 */ "noarg_func ::= USER", - /* 497 */ "star_func ::= COUNT", - /* 498 */ "star_func ::= FIRST", - /* 499 */ "star_func ::= LAST", - /* 500 */ "star_func ::= LAST_ROW", - /* 501 */ "star_func_para_list ::= NK_STAR", - /* 502 */ "star_func_para_list ::= other_para_list", - /* 503 */ "other_para_list ::= star_func_para", - /* 504 */ "other_para_list ::= other_para_list NK_COMMA star_func_para", - /* 505 */ "star_func_para ::= expr_or_subquery", - /* 506 */ "star_func_para ::= table_name NK_DOT NK_STAR", - /* 507 */ "case_when_expression ::= CASE when_then_list case_when_else_opt END", - /* 508 */ "case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END", - /* 509 */ "when_then_list ::= when_then_expr", - /* 510 */ "when_then_list ::= when_then_list when_then_expr", - /* 511 */ "when_then_expr ::= WHEN common_expression THEN common_expression", - /* 512 */ "case_when_else_opt ::=", - /* 513 */ "case_when_else_opt ::= ELSE common_expression", - /* 514 */ "predicate ::= expr_or_subquery compare_op expr_or_subquery", - /* 515 */ "predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery", - /* 516 */ "predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery", - /* 517 */ "predicate ::= expr_or_subquery IS NULL", - /* 518 */ "predicate ::= expr_or_subquery IS NOT NULL", - /* 519 */ "predicate ::= expr_or_subquery in_op in_predicate_value", - /* 520 */ "compare_op ::= NK_LT", - /* 521 */ "compare_op ::= NK_GT", - /* 522 */ "compare_op ::= NK_LE", - /* 523 */ "compare_op ::= NK_GE", - /* 524 */ "compare_op ::= NK_NE", - /* 525 */ "compare_op ::= NK_EQ", - /* 526 */ "compare_op ::= LIKE", - /* 527 */ "compare_op ::= NOT LIKE", - /* 528 */ "compare_op ::= MATCH", - /* 529 */ "compare_op ::= NMATCH", - /* 530 */ "compare_op ::= CONTAINS", - /* 531 */ "in_op ::= IN", - /* 532 */ "in_op ::= NOT IN", - /* 533 */ "in_predicate_value ::= NK_LP literal_list NK_RP", - /* 534 */ "boolean_value_expression ::= boolean_primary", - /* 535 */ "boolean_value_expression ::= NOT boolean_primary", - /* 536 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression", - /* 537 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression", - /* 538 */ "boolean_primary ::= predicate", - /* 539 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP", - /* 540 */ "common_expression ::= expr_or_subquery", - /* 541 */ "common_expression ::= boolean_value_expression", - /* 542 */ "from_clause_opt ::=", - /* 543 */ "from_clause_opt ::= FROM table_reference_list", - /* 544 */ "table_reference_list ::= table_reference", - /* 545 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference", - /* 546 */ "table_reference ::= table_primary", - /* 547 */ "table_reference ::= joined_table", - /* 548 */ "table_primary ::= table_name alias_opt", - /* 549 */ "table_primary ::= db_name NK_DOT table_name alias_opt", - /* 550 */ "table_primary ::= subquery alias_opt", - /* 551 */ "table_primary ::= parenthesized_joined_table", - /* 552 */ "alias_opt ::=", - /* 553 */ "alias_opt ::= table_alias", - /* 554 */ "alias_opt ::= AS table_alias", - /* 555 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP", - /* 556 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP", - /* 557 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition", - /* 558 */ "join_type ::=", - /* 559 */ "join_type ::= INNER", - /* 560 */ "query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt", - /* 561 */ "hint_list ::=", - /* 562 */ "hint_list ::= NK_HINT", - /* 563 */ "tag_mode_opt ::=", - /* 564 */ "tag_mode_opt ::= TAGS", - /* 565 */ "set_quantifier_opt ::=", - /* 566 */ "set_quantifier_opt ::= DISTINCT", - /* 567 */ "set_quantifier_opt ::= ALL", - /* 568 */ "select_list ::= select_item", - /* 569 */ "select_list ::= select_list NK_COMMA select_item", - /* 570 */ "select_item ::= NK_STAR", - /* 571 */ "select_item ::= common_expression", - /* 572 */ "select_item ::= common_expression column_alias", - /* 573 */ "select_item ::= common_expression AS column_alias", - /* 574 */ "select_item ::= table_name NK_DOT NK_STAR", - /* 575 */ "where_clause_opt ::=", - /* 576 */ "where_clause_opt ::= WHERE search_condition", - /* 577 */ "partition_by_clause_opt ::=", - /* 578 */ "partition_by_clause_opt ::= PARTITION BY partition_list", - /* 579 */ "partition_list ::= partition_item", - /* 580 */ "partition_list ::= partition_list NK_COMMA partition_item", - /* 581 */ "partition_item ::= expr_or_subquery", - /* 582 */ "partition_item ::= expr_or_subquery column_alias", - /* 583 */ "partition_item ::= expr_or_subquery AS column_alias", - /* 584 */ "twindow_clause_opt ::=", - /* 585 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP", - /* 586 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP", - /* 587 */ "twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt", - /* 588 */ "twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt", - /* 589 */ "twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition", - /* 590 */ "twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_RP", - /* 591 */ "twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP", - /* 592 */ "sliding_opt ::=", - /* 593 */ "sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP", - /* 594 */ "interval_sliding_duration_literal ::= NK_VARIABLE", - /* 595 */ "interval_sliding_duration_literal ::= NK_STRING", - /* 596 */ "interval_sliding_duration_literal ::= NK_INTEGER", - /* 597 */ "fill_opt ::=", - /* 598 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", - /* 599 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP", - /* 600 */ "fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP", - /* 601 */ "fill_mode ::= NONE", - /* 602 */ "fill_mode ::= PREV", - /* 603 */ "fill_mode ::= NULL", - /* 604 */ "fill_mode ::= NULL_F", - /* 605 */ "fill_mode ::= LINEAR", - /* 606 */ "fill_mode ::= NEXT", - /* 607 */ "group_by_clause_opt ::=", - /* 608 */ "group_by_clause_opt ::= GROUP BY group_by_list", - /* 609 */ "group_by_list ::= expr_or_subquery", - /* 610 */ "group_by_list ::= group_by_list NK_COMMA expr_or_subquery", - /* 611 */ "having_clause_opt ::=", - /* 612 */ "having_clause_opt ::= HAVING search_condition", - /* 613 */ "range_opt ::=", - /* 614 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP", - /* 615 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_RP", - /* 616 */ "every_opt ::=", - /* 617 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP", - /* 618 */ "query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt", - /* 619 */ "query_simple ::= query_specification", - /* 620 */ "query_simple ::= union_query_expression", - /* 621 */ "union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery", - /* 622 */ "union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery", - /* 623 */ "query_simple_or_subquery ::= query_simple", - /* 624 */ "query_simple_or_subquery ::= subquery", - /* 625 */ "query_or_subquery ::= query_expression", - /* 626 */ "query_or_subquery ::= subquery", - /* 627 */ "order_by_clause_opt ::=", - /* 628 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", - /* 629 */ "slimit_clause_opt ::=", - /* 630 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", - /* 631 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", - /* 632 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 633 */ "limit_clause_opt ::=", - /* 634 */ "limit_clause_opt ::= LIMIT NK_INTEGER", - /* 635 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", - /* 636 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 637 */ "subquery ::= NK_LP query_expression NK_RP", - /* 638 */ "subquery ::= NK_LP subquery NK_RP", - /* 639 */ "search_condition ::= common_expression", - /* 640 */ "sort_specification_list ::= sort_specification", - /* 641 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", - /* 642 */ "sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt", - /* 643 */ "ordering_specification_opt ::=", - /* 644 */ "ordering_specification_opt ::= ASC", - /* 645 */ "ordering_specification_opt ::= DESC", - /* 646 */ "null_ordering_opt ::=", - /* 647 */ "null_ordering_opt ::= NULLS FIRST", - /* 648 */ "null_ordering_opt ::= NULLS LAST", + /* 409 */ "tags_literal ::= NK_INTEGER", + /* 410 */ "tags_literal ::= NK_PLUS NK_INTEGER", + /* 411 */ "tags_literal ::= NK_MINUS NK_INTEGER", + /* 412 */ "tags_literal ::= NK_FLOAT", + /* 413 */ "tags_literal ::= NK_PLUS NK_FLOAT", + /* 414 */ "tags_literal ::= NK_MINUS NK_FLOAT", + /* 415 */ "tags_literal ::= NK_STRING", + /* 416 */ "tags_literal ::= NK_BOOL", + /* 417 */ "tags_literal ::= NULL", + /* 418 */ "tags_literal ::= literal_func", + /* 419 */ "tags_literal ::= literal_func NK_PLUS duration_literal", + /* 420 */ "tags_literal ::= literal_func NK_MINUS duration_literal", + /* 421 */ "tags_literal_list ::= tags_literal", + /* 422 */ "tags_literal_list ::= tags_literal_list NK_COMMA tags_literal", + /* 423 */ "literal ::= NK_INTEGER", + /* 424 */ "literal ::= NK_FLOAT", + /* 425 */ "literal ::= NK_STRING", + /* 426 */ "literal ::= NK_BOOL", + /* 427 */ "literal ::= TIMESTAMP NK_STRING", + /* 428 */ "literal ::= duration_literal", + /* 429 */ "literal ::= NULL", + /* 430 */ "literal ::= NK_QUESTION", + /* 431 */ "duration_literal ::= NK_VARIABLE", + /* 432 */ "signed ::= NK_INTEGER", + /* 433 */ "signed ::= NK_PLUS NK_INTEGER", + /* 434 */ "signed ::= NK_MINUS NK_INTEGER", + /* 435 */ "signed ::= NK_FLOAT", + /* 436 */ "signed ::= NK_PLUS NK_FLOAT", + /* 437 */ "signed ::= NK_MINUS NK_FLOAT", + /* 438 */ "signed_literal ::= signed", + /* 439 */ "signed_literal ::= NK_STRING", + /* 440 */ "signed_literal ::= NK_BOOL", + /* 441 */ "signed_literal ::= TIMESTAMP NK_STRING", + /* 442 */ "signed_literal ::= duration_literal", + /* 443 */ "signed_literal ::= NULL", + /* 444 */ "signed_literal ::= literal_func", + /* 445 */ "signed_literal ::= NK_QUESTION", + /* 446 */ "literal_list ::= signed_literal", + /* 447 */ "literal_list ::= literal_list NK_COMMA signed_literal", + /* 448 */ "db_name ::= NK_ID", + /* 449 */ "table_name ::= NK_ID", + /* 450 */ "column_name ::= NK_ID", + /* 451 */ "function_name ::= NK_ID", + /* 452 */ "view_name ::= NK_ID", + /* 453 */ "table_alias ::= NK_ID", + /* 454 */ "column_alias ::= NK_ID", + /* 455 */ "column_alias ::= NK_ALIAS", + /* 456 */ "user_name ::= NK_ID", + /* 457 */ "topic_name ::= NK_ID", + /* 458 */ "stream_name ::= NK_ID", + /* 459 */ "cgroup_name ::= NK_ID", + /* 460 */ "index_name ::= NK_ID", + /* 461 */ "expr_or_subquery ::= expression", + /* 462 */ "expression ::= literal", + /* 463 */ "expression ::= pseudo_column", + /* 464 */ "expression ::= column_reference", + /* 465 */ "expression ::= function_expression", + /* 466 */ "expression ::= case_when_expression", + /* 467 */ "expression ::= NK_LP expression NK_RP", + /* 468 */ "expression ::= NK_PLUS expr_or_subquery", + /* 469 */ "expression ::= NK_MINUS expr_or_subquery", + /* 470 */ "expression ::= expr_or_subquery NK_PLUS expr_or_subquery", + /* 471 */ "expression ::= expr_or_subquery NK_MINUS expr_or_subquery", + /* 472 */ "expression ::= expr_or_subquery NK_STAR expr_or_subquery", + /* 473 */ "expression ::= expr_or_subquery NK_SLASH expr_or_subquery", + /* 474 */ "expression ::= expr_or_subquery NK_REM expr_or_subquery", + /* 475 */ "expression ::= column_reference NK_ARROW NK_STRING", + /* 476 */ "expression ::= expr_or_subquery NK_BITAND expr_or_subquery", + /* 477 */ "expression ::= expr_or_subquery NK_BITOR expr_or_subquery", + /* 478 */ "expression_list ::= expr_or_subquery", + /* 479 */ "expression_list ::= expression_list NK_COMMA expr_or_subquery", + /* 480 */ "column_reference ::= column_name", + /* 481 */ "column_reference ::= table_name NK_DOT column_name", + /* 482 */ "column_reference ::= NK_ALIAS", + /* 483 */ "column_reference ::= table_name NK_DOT NK_ALIAS", + /* 484 */ "pseudo_column ::= ROWTS", + /* 485 */ "pseudo_column ::= TBNAME", + /* 486 */ "pseudo_column ::= table_name NK_DOT TBNAME", + /* 487 */ "pseudo_column ::= QSTART", + /* 488 */ "pseudo_column ::= QEND", + /* 489 */ "pseudo_column ::= QDURATION", + /* 490 */ "pseudo_column ::= WSTART", + /* 491 */ "pseudo_column ::= WEND", + /* 492 */ "pseudo_column ::= WDURATION", + /* 493 */ "pseudo_column ::= IROWTS", + /* 494 */ "pseudo_column ::= ISFILLED", + /* 495 */ "pseudo_column ::= QTAGS", + /* 496 */ "function_expression ::= function_name NK_LP expression_list NK_RP", + /* 497 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP", + /* 498 */ "function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP", + /* 499 */ "function_expression ::= literal_func", + /* 500 */ "literal_func ::= noarg_func NK_LP NK_RP", + /* 501 */ "literal_func ::= NOW", + /* 502 */ "literal_func ::= TODAY", + /* 503 */ "noarg_func ::= NOW", + /* 504 */ "noarg_func ::= TODAY", + /* 505 */ "noarg_func ::= TIMEZONE", + /* 506 */ "noarg_func ::= DATABASE", + /* 507 */ "noarg_func ::= CLIENT_VERSION", + /* 508 */ "noarg_func ::= SERVER_VERSION", + /* 509 */ "noarg_func ::= SERVER_STATUS", + /* 510 */ "noarg_func ::= CURRENT_USER", + /* 511 */ "noarg_func ::= USER", + /* 512 */ "star_func ::= COUNT", + /* 513 */ "star_func ::= FIRST", + /* 514 */ "star_func ::= LAST", + /* 515 */ "star_func ::= LAST_ROW", + /* 516 */ "star_func_para_list ::= NK_STAR", + /* 517 */ "star_func_para_list ::= other_para_list", + /* 518 */ "other_para_list ::= star_func_para", + /* 519 */ "other_para_list ::= other_para_list NK_COMMA star_func_para", + /* 520 */ "star_func_para ::= expr_or_subquery", + /* 521 */ "star_func_para ::= table_name NK_DOT NK_STAR", + /* 522 */ "case_when_expression ::= CASE when_then_list case_when_else_opt END", + /* 523 */ "case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END", + /* 524 */ "when_then_list ::= when_then_expr", + /* 525 */ "when_then_list ::= when_then_list when_then_expr", + /* 526 */ "when_then_expr ::= WHEN common_expression THEN common_expression", + /* 527 */ "case_when_else_opt ::=", + /* 528 */ "case_when_else_opt ::= ELSE common_expression", + /* 529 */ "predicate ::= expr_or_subquery compare_op expr_or_subquery", + /* 530 */ "predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery", + /* 531 */ "predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery", + /* 532 */ "predicate ::= expr_or_subquery IS NULL", + /* 533 */ "predicate ::= expr_or_subquery IS NOT NULL", + /* 534 */ "predicate ::= expr_or_subquery in_op in_predicate_value", + /* 535 */ "compare_op ::= NK_LT", + /* 536 */ "compare_op ::= NK_GT", + /* 537 */ "compare_op ::= NK_LE", + /* 538 */ "compare_op ::= NK_GE", + /* 539 */ "compare_op ::= NK_NE", + /* 540 */ "compare_op ::= NK_EQ", + /* 541 */ "compare_op ::= LIKE", + /* 542 */ "compare_op ::= NOT LIKE", + /* 543 */ "compare_op ::= MATCH", + /* 544 */ "compare_op ::= NMATCH", + /* 545 */ "compare_op ::= CONTAINS", + /* 546 */ "in_op ::= IN", + /* 547 */ "in_op ::= NOT IN", + /* 548 */ "in_predicate_value ::= NK_LP literal_list NK_RP", + /* 549 */ "boolean_value_expression ::= boolean_primary", + /* 550 */ "boolean_value_expression ::= NOT boolean_primary", + /* 551 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression", + /* 552 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression", + /* 553 */ "boolean_primary ::= predicate", + /* 554 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP", + /* 555 */ "common_expression ::= expr_or_subquery", + /* 556 */ "common_expression ::= boolean_value_expression", + /* 557 */ "from_clause_opt ::=", + /* 558 */ "from_clause_opt ::= FROM table_reference_list", + /* 559 */ "table_reference_list ::= table_reference", + /* 560 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference", + /* 561 */ "table_reference ::= table_primary", + /* 562 */ "table_reference ::= joined_table", + /* 563 */ "table_primary ::= table_name alias_opt", + /* 564 */ "table_primary ::= db_name NK_DOT table_name alias_opt", + /* 565 */ "table_primary ::= subquery alias_opt", + /* 566 */ "table_primary ::= parenthesized_joined_table", + /* 567 */ "alias_opt ::=", + /* 568 */ "alias_opt ::= table_alias", + /* 569 */ "alias_opt ::= AS table_alias", + /* 570 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP", + /* 571 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP", + /* 572 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition", + /* 573 */ "join_type ::=", + /* 574 */ "join_type ::= INNER", + /* 575 */ "query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt", + /* 576 */ "hint_list ::=", + /* 577 */ "hint_list ::= NK_HINT", + /* 578 */ "tag_mode_opt ::=", + /* 579 */ "tag_mode_opt ::= TAGS", + /* 580 */ "set_quantifier_opt ::=", + /* 581 */ "set_quantifier_opt ::= DISTINCT", + /* 582 */ "set_quantifier_opt ::= ALL", + /* 583 */ "select_list ::= select_item", + /* 584 */ "select_list ::= select_list NK_COMMA select_item", + /* 585 */ "select_item ::= NK_STAR", + /* 586 */ "select_item ::= common_expression", + /* 587 */ "select_item ::= common_expression column_alias", + /* 588 */ "select_item ::= common_expression AS column_alias", + /* 589 */ "select_item ::= table_name NK_DOT NK_STAR", + /* 590 */ "where_clause_opt ::=", + /* 591 */ "where_clause_opt ::= WHERE search_condition", + /* 592 */ "partition_by_clause_opt ::=", + /* 593 */ "partition_by_clause_opt ::= PARTITION BY partition_list", + /* 594 */ "partition_list ::= partition_item", + /* 595 */ "partition_list ::= partition_list NK_COMMA partition_item", + /* 596 */ "partition_item ::= expr_or_subquery", + /* 597 */ "partition_item ::= expr_or_subquery column_alias", + /* 598 */ "partition_item ::= expr_or_subquery AS column_alias", + /* 599 */ "twindow_clause_opt ::=", + /* 600 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP", + /* 601 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP", + /* 602 */ "twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt", + /* 603 */ "twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt", + /* 604 */ "twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition", + /* 605 */ "twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_RP", + /* 606 */ "twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP", + /* 607 */ "sliding_opt ::=", + /* 608 */ "sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP", + /* 609 */ "interval_sliding_duration_literal ::= NK_VARIABLE", + /* 610 */ "interval_sliding_duration_literal ::= NK_STRING", + /* 611 */ "interval_sliding_duration_literal ::= NK_INTEGER", + /* 612 */ "fill_opt ::=", + /* 613 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", + /* 614 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP", + /* 615 */ "fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP", + /* 616 */ "fill_mode ::= NONE", + /* 617 */ "fill_mode ::= PREV", + /* 618 */ "fill_mode ::= NULL", + /* 619 */ "fill_mode ::= NULL_F", + /* 620 */ "fill_mode ::= LINEAR", + /* 621 */ "fill_mode ::= NEXT", + /* 622 */ "group_by_clause_opt ::=", + /* 623 */ "group_by_clause_opt ::= GROUP BY group_by_list", + /* 624 */ "group_by_list ::= expr_or_subquery", + /* 625 */ "group_by_list ::= group_by_list NK_COMMA expr_or_subquery", + /* 626 */ "having_clause_opt ::=", + /* 627 */ "having_clause_opt ::= HAVING search_condition", + /* 628 */ "range_opt ::=", + /* 629 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP", + /* 630 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_RP", + /* 631 */ "every_opt ::=", + /* 632 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP", + /* 633 */ "query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt", + /* 634 */ "query_simple ::= query_specification", + /* 635 */ "query_simple ::= union_query_expression", + /* 636 */ "union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery", + /* 637 */ "union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery", + /* 638 */ "query_simple_or_subquery ::= query_simple", + /* 639 */ "query_simple_or_subquery ::= subquery", + /* 640 */ "query_or_subquery ::= query_expression", + /* 641 */ "query_or_subquery ::= subquery", + /* 642 */ "order_by_clause_opt ::=", + /* 643 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", + /* 644 */ "slimit_clause_opt ::=", + /* 645 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", + /* 646 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", + /* 647 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 648 */ "limit_clause_opt ::=", + /* 649 */ "limit_clause_opt ::= LIMIT NK_INTEGER", + /* 650 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", + /* 651 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 652 */ "subquery ::= NK_LP query_expression NK_RP", + /* 653 */ "subquery ::= NK_LP subquery NK_RP", + /* 654 */ "search_condition ::= common_expression", + /* 655 */ "sort_specification_list ::= sort_specification", + /* 656 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", + /* 657 */ "sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt", + /* 658 */ "ordering_specification_opt ::=", + /* 659 */ "ordering_specification_opt ::= ASC", + /* 660 */ "ordering_specification_opt ::= DESC", + /* 661 */ "null_ordering_opt ::=", + /* 662 */ "null_ordering_opt ::= NULLS FIRST", + /* 663 */ "null_ordering_opt ::= NULLS LAST", }; #endif /* NDEBUG */ @@ -3182,7 +2886,7 @@ static void yy_destructor( case 389: /* table_options */ case 393: /* alter_table_clause */ case 394: /* alter_table_options */ - case 397: /* signed_literal */ + case 397: /* tags_literal */ case 398: /* create_subtable_clause */ case 401: /* drop_table_clause */ case 403: /* column_def */ @@ -3199,61 +2903,62 @@ static void yy_destructor( case 425: /* sliding_opt */ case 426: /* sma_stream_opt */ case 427: /* func */ - case 430: /* query_or_subquery */ - case 431: /* where_clause_opt */ - case 434: /* explain_options */ - case 435: /* insert_query */ - case 440: /* full_view_name */ - case 443: /* stream_options */ - case 446: /* subtable_opt */ - case 448: /* expression */ - case 451: /* literal_func */ - case 454: /* expr_or_subquery */ - case 455: /* pseudo_column */ - case 456: /* column_reference */ - case 457: /* function_expression */ - case 458: /* case_when_expression */ - case 463: /* star_func_para */ - case 465: /* case_when_else_opt */ - case 466: /* common_expression */ - case 467: /* when_then_expr */ - case 468: /* predicate */ - case 471: /* in_predicate_value */ - case 472: /* boolean_value_expression */ - case 473: /* boolean_primary */ - case 474: /* from_clause_opt */ - case 475: /* table_reference_list */ - case 476: /* table_reference */ - case 477: /* table_primary */ - case 478: /* joined_table */ - case 480: /* subquery */ - case 481: /* parenthesized_joined_table */ - case 483: /* query_specification */ - case 489: /* range_opt */ - case 490: /* every_opt */ - case 491: /* fill_opt */ - case 492: /* twindow_clause_opt */ - case 494: /* having_clause_opt */ - case 495: /* select_item */ - case 497: /* partition_item */ - case 498: /* interval_sliding_duration_literal */ - case 501: /* query_expression */ - case 502: /* query_simple */ - case 504: /* slimit_clause_opt */ - case 505: /* limit_clause_opt */ - case 506: /* union_query_expression */ - case 507: /* query_simple_or_subquery */ - case 509: /* sort_specification */ + case 431: /* query_or_subquery */ + case 432: /* where_clause_opt */ + case 435: /* explain_options */ + case 436: /* insert_query */ + case 441: /* full_view_name */ + case 444: /* stream_options */ + case 447: /* subtable_opt */ + case 449: /* expression */ + case 452: /* literal_func */ + case 453: /* signed_literal */ + case 456: /* expr_or_subquery */ + case 457: /* pseudo_column */ + case 458: /* column_reference */ + case 459: /* function_expression */ + case 460: /* case_when_expression */ + case 465: /* star_func_para */ + case 467: /* case_when_else_opt */ + case 468: /* common_expression */ + case 469: /* when_then_expr */ + case 470: /* predicate */ + case 473: /* in_predicate_value */ + case 474: /* boolean_value_expression */ + case 475: /* boolean_primary */ + case 476: /* from_clause_opt */ + case 477: /* table_reference_list */ + case 478: /* table_reference */ + case 479: /* table_primary */ + case 480: /* joined_table */ + case 482: /* subquery */ + case 483: /* parenthesized_joined_table */ + case 485: /* query_specification */ + case 491: /* range_opt */ + case 492: /* every_opt */ + case 493: /* fill_opt */ + case 494: /* twindow_clause_opt */ + case 496: /* having_clause_opt */ + case 497: /* select_item */ + case 499: /* partition_item */ + case 500: /* interval_sliding_duration_literal */ + case 503: /* query_expression */ + case 504: /* query_simple */ + case 506: /* slimit_clause_opt */ + case 507: /* limit_clause_opt */ + case 508: /* union_query_expression */ + case 509: /* query_simple_or_subquery */ + case 511: /* sort_specification */ { - nodesDestroyNode((yypminor->yy360)); + nodesDestroyNode((yypminor->yy20)); } break; case 352: /* account_options */ case 353: /* alter_account_options */ case 355: /* alter_account_option */ case 377: /* speed_opt */ - case 429: /* with_meta */ - case 438: /* bufsize_opt */ + case 430: /* with_meta */ + case 439: /* bufsize_opt */ { } @@ -3270,29 +2975,30 @@ static void yy_destructor( case 391: /* tags_def */ case 392: /* multi_drop_clause */ case 399: /* specific_cols_opt */ - case 400: /* expression_list */ + case 400: /* tags_literal_list */ case 402: /* col_name_list */ case 404: /* duration_list */ case 405: /* rollup_func_list */ case 417: /* tag_list_opt */ case 424: /* func_list */ - case 444: /* col_list_opt */ - case 445: /* tag_def_or_ref_opt */ - case 450: /* dnode_list */ - case 452: /* literal_list */ - case 460: /* star_func_para_list */ - case 462: /* other_para_list */ - case 464: /* when_then_list */ - case 484: /* hint_list */ - case 487: /* select_list */ - case 488: /* partition_by_clause_opt */ - case 493: /* group_by_clause_opt */ - case 496: /* partition_list */ - case 500: /* group_by_list */ - case 503: /* order_by_clause_opt */ - case 508: /* sort_specification_list */ + case 429: /* expression_list */ + case 445: /* col_list_opt */ + case 446: /* tag_def_or_ref_opt */ + case 451: /* dnode_list */ + case 454: /* literal_list */ + case 462: /* star_func_para_list */ + case 464: /* other_para_list */ + case 466: /* when_then_list */ + case 486: /* hint_list */ + case 489: /* select_list */ + case 490: /* partition_by_clause_opt */ + case 495: /* group_by_clause_opt */ + case 498: /* partition_list */ + case 502: /* group_by_list */ + case 505: /* order_by_clause_opt */ + case 510: /* sort_specification_list */ { - nodesDestroyList((yypminor->yy536)); + nodesDestroyList((yypminor->yy1008)); } break; case 359: /* user_name */ @@ -3305,15 +3011,15 @@ static void yy_destructor( case 420: /* column_alias */ case 423: /* index_name */ case 428: /* sma_func_name */ - case 432: /* cgroup_name */ - case 439: /* language_opt */ - case 441: /* view_name */ - case 442: /* stream_name */ - case 449: /* on_vgroup_id */ - case 453: /* table_alias */ - case 459: /* star_func */ - case 461: /* noarg_func */ - case 479: /* alias_opt */ + case 433: /* cgroup_name */ + case 440: /* language_opt */ + case 442: /* view_name */ + case 443: /* stream_name */ + case 450: /* on_vgroup_id */ + case 455: /* table_alias */ + case 461: /* star_func */ + case 463: /* noarg_func */ + case 481: /* alias_opt */ { } @@ -3339,12 +3045,12 @@ static void yy_destructor( case 372: /* unsafe_opt */ case 373: /* not_exists_opt */ case 375: /* exists_opt */ - case 433: /* analyze_opt */ - case 436: /* or_replace_opt */ - case 437: /* agg_func_opt */ - case 447: /* ignore_opt */ - case 485: /* set_quantifier_opt */ - case 486: /* tag_mode_opt */ + case 434: /* analyze_opt */ + case 437: /* or_replace_opt */ + case 438: /* agg_func_opt */ + case 448: /* ignore_opt */ + case 487: /* set_quantifier_opt */ + case 488: /* tag_mode_opt */ { } @@ -3371,28 +3077,28 @@ static void yy_destructor( } break; - case 469: /* compare_op */ - case 470: /* in_op */ + case 471: /* compare_op */ + case 472: /* in_op */ { } break; - case 482: /* join_type */ + case 484: /* join_type */ { } break; - case 499: /* fill_mode */ + case 501: /* fill_mode */ { } break; - case 510: /* ordering_specification_opt */ + case 512: /* ordering_specification_opt */ { } break; - case 511: /* null_ordering_opt */ + case 513: /* null_ordering_opt */ { } @@ -3561,7 +3267,7 @@ static YYACTIONTYPE yy_find_shift_action( #endif /* YYWILDCARD */ return yy_default[stateno]; }else{ - assert( i>=0 && i<(int)(sizeof(yy_action)/sizeof(yy_action[0])) ); + assert( i>=0 && iyytos; +#ifndef NDEBUG + if( yyTraceFILE && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){ + yysize = yyRuleInfoNRhs[yyruleno]; + if( yysize ){ + fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n", + yyTracePrompt, + yyruleno, yyRuleName[yyruleno], + yyrulenoyytos - yypParser->yystack)>yypParser->yyhwm ){ + yypParser->yyhwm++; + assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack)); + } +#endif +#if YYSTACKDEPTH>0 + if( yypParser->yytos>=yypParser->yystackEnd ){ + yyStackOverflow(yypParser); + /* The call to yyStackOverflow() above pops the stack until it is + ** empty, causing the main parser loop to exit. So the return value + ** is never used and does not matter. */ + return 0; + } +#else + if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){ + if( yyGrowStack(yypParser) ){ + yyStackOverflow(yypParser); + /* The call to yyStackOverflow() above pops the stack until it is + ** empty, causing the main parser loop to exit. So the return value + ** is never used and does not matter. */ + return 0; + } + yymsp = yypParser->yytos; + } +#endif + } switch( yyruleno ){ /* Beginning here are the reduction cases. A typical example @@ -5077,15 +4861,15 @@ static YYACTIONTYPE yy_reduce( yy_destructor(yypParser,354,&yymsp[0].minor); break; case 24: /* ip_range_list ::= NK_STRING */ -{ yylhsminor.yy536 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy536 = yylhsminor.yy536; +{ yylhsminor.yy1008 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy1008 = yylhsminor.yy1008; break; case 25: /* ip_range_list ::= ip_range_list NK_COMMA NK_STRING */ -{ yylhsminor.yy536 = addNodeToList(pCxt, yymsp[-2].minor.yy536, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } - yymsp[-2].minor.yy536 = yylhsminor.yy536; +{ yylhsminor.yy1008 = addNodeToList(pCxt, yymsp[-2].minor.yy1008, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy1008 = yylhsminor.yy1008; break; case 26: /* white_list ::= HOST ip_range_list */ -{ yymsp[-1].minor.yy536 = yymsp[0].minor.yy536; } +{ yymsp[-1].minor.yy1008 = yymsp[0].minor.yy1008; } break; case 27: /* white_list_opt ::= */ case 188: /* specific_cols_opt ::= */ yytestcase(yyruleno==188); @@ -5093,135 +4877,135 @@ static YYACTIONTYPE yy_reduce( case 307: /* tag_list_opt ::= */ yytestcase(yyruleno==307); case 373: /* col_list_opt ::= */ yytestcase(yyruleno==373); case 375: /* tag_def_or_ref_opt ::= */ yytestcase(yyruleno==375); - case 577: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==577); - case 607: /* group_by_clause_opt ::= */ yytestcase(yyruleno==607); - case 627: /* order_by_clause_opt ::= */ yytestcase(yyruleno==627); -{ yymsp[1].minor.yy536 = NULL; } + case 592: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==592); + case 622: /* group_by_clause_opt ::= */ yytestcase(yyruleno==622); + case 642: /* order_by_clause_opt ::= */ yytestcase(yyruleno==642); +{ yymsp[1].minor.yy1008 = NULL; } break; case 28: /* white_list_opt ::= white_list */ case 220: /* tags_def_opt ::= tags_def */ yytestcase(yyruleno==220); case 376: /* tag_def_or_ref_opt ::= tags_def */ yytestcase(yyruleno==376); - case 502: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==502); -{ yylhsminor.yy536 = yymsp[0].minor.yy536; } - yymsp[0].minor.yy536 = yylhsminor.yy536; + case 517: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==517); +{ yylhsminor.yy1008 = yymsp[0].minor.yy1008; } + yymsp[0].minor.yy1008 = yylhsminor.yy1008; break; case 29: /* cmd ::= CREATE USER user_name PASS NK_STRING sysinfo_opt white_list_opt */ { - pCxt->pRootNode = createCreateUserStmt(pCxt, &yymsp[-4].minor.yy929, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy695); - pCxt->pRootNode = addCreateUserStmtWhiteList(pCxt, pCxt->pRootNode, yymsp[0].minor.yy536); + pCxt->pRootNode = createCreateUserStmt(pCxt, &yymsp[-4].minor.yy621, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy247); + pCxt->pRootNode = addCreateUserStmtWhiteList(pCxt, pCxt->pRootNode, yymsp[0].minor.yy1008); } break; case 30: /* cmd ::= ALTER USER user_name PASS NK_STRING */ -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy929, TSDB_ALTER_USER_PASSWD, &yymsp[0].minor.yy0); } +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy621, TSDB_ALTER_USER_PASSWD, &yymsp[0].minor.yy0); } break; case 31: /* cmd ::= ALTER USER user_name ENABLE NK_INTEGER */ -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy929, TSDB_ALTER_USER_ENABLE, &yymsp[0].minor.yy0); } +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy621, TSDB_ALTER_USER_ENABLE, &yymsp[0].minor.yy0); } break; case 32: /* cmd ::= ALTER USER user_name SYSINFO NK_INTEGER */ -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy929, TSDB_ALTER_USER_SYSINFO, &yymsp[0].minor.yy0); } +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy621, TSDB_ALTER_USER_SYSINFO, &yymsp[0].minor.yy0); } break; case 33: /* cmd ::= ALTER USER user_name ADD white_list */ -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy929, TSDB_ALTER_USER_ADD_WHITE_LIST, yymsp[0].minor.yy536); } +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy621, TSDB_ALTER_USER_ADD_WHITE_LIST, yymsp[0].minor.yy1008); } break; case 34: /* cmd ::= ALTER USER user_name DROP white_list */ -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy929, TSDB_ALTER_USER_DROP_WHITE_LIST, yymsp[0].minor.yy536); } +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy621, TSDB_ALTER_USER_DROP_WHITE_LIST, yymsp[0].minor.yy1008); } break; case 35: /* cmd ::= DROP USER user_name */ -{ pCxt->pRootNode = createDropUserStmt(pCxt, &yymsp[0].minor.yy929); } +{ pCxt->pRootNode = createDropUserStmt(pCxt, &yymsp[0].minor.yy621); } break; case 36: /* sysinfo_opt ::= */ -{ yymsp[1].minor.yy695 = 1; } +{ yymsp[1].minor.yy247 = 1; } break; case 37: /* sysinfo_opt ::= SYSINFO NK_INTEGER */ -{ yymsp[-1].minor.yy695 = taosStr2Int8(yymsp[0].minor.yy0.z, NULL, 10); } +{ yymsp[-1].minor.yy247 = taosStr2Int8(yymsp[0].minor.yy0.z, NULL, 10); } break; case 38: /* cmd ::= GRANT privileges ON priv_level with_opt TO user_name */ -{ pCxt->pRootNode = createGrantStmt(pCxt, yymsp[-5].minor.yy221, &yymsp[-3].minor.yy57, &yymsp[0].minor.yy929, yymsp[-2].minor.yy360); } +{ pCxt->pRootNode = createGrantStmt(pCxt, yymsp[-5].minor.yy181, &yymsp[-3].minor.yy577, &yymsp[0].minor.yy621, yymsp[-2].minor.yy20); } break; case 39: /* cmd ::= REVOKE privileges ON priv_level with_opt FROM user_name */ -{ pCxt->pRootNode = createRevokeStmt(pCxt, yymsp[-5].minor.yy221, &yymsp[-3].minor.yy57, &yymsp[0].minor.yy929, yymsp[-2].minor.yy360); } +{ pCxt->pRootNode = createRevokeStmt(pCxt, yymsp[-5].minor.yy181, &yymsp[-3].minor.yy577, &yymsp[0].minor.yy621, yymsp[-2].minor.yy20); } break; case 40: /* privileges ::= ALL */ -{ yymsp[0].minor.yy221 = PRIVILEGE_TYPE_ALL; } +{ yymsp[0].minor.yy181 = PRIVILEGE_TYPE_ALL; } break; case 41: /* privileges ::= priv_type_list */ case 43: /* priv_type_list ::= priv_type */ yytestcase(yyruleno==43); -{ yylhsminor.yy221 = yymsp[0].minor.yy221; } - yymsp[0].minor.yy221 = yylhsminor.yy221; +{ yylhsminor.yy181 = yymsp[0].minor.yy181; } + yymsp[0].minor.yy181 = yylhsminor.yy181; break; case 42: /* privileges ::= SUBSCRIBE */ -{ yymsp[0].minor.yy221 = PRIVILEGE_TYPE_SUBSCRIBE; } +{ yymsp[0].minor.yy181 = PRIVILEGE_TYPE_SUBSCRIBE; } break; case 44: /* priv_type_list ::= priv_type_list NK_COMMA priv_type */ -{ yylhsminor.yy221 = yymsp[-2].minor.yy221 | yymsp[0].minor.yy221; } - yymsp[-2].minor.yy221 = yylhsminor.yy221; +{ yylhsminor.yy181 = yymsp[-2].minor.yy181 | yymsp[0].minor.yy181; } + yymsp[-2].minor.yy181 = yylhsminor.yy181; break; case 45: /* priv_type ::= READ */ -{ yymsp[0].minor.yy221 = PRIVILEGE_TYPE_READ; } +{ yymsp[0].minor.yy181 = PRIVILEGE_TYPE_READ; } break; case 46: /* priv_type ::= WRITE */ -{ yymsp[0].minor.yy221 = PRIVILEGE_TYPE_WRITE; } +{ yymsp[0].minor.yy181 = PRIVILEGE_TYPE_WRITE; } break; case 47: /* priv_type ::= ALTER */ -{ yymsp[0].minor.yy221 = PRIVILEGE_TYPE_ALTER; } +{ yymsp[0].minor.yy181 = PRIVILEGE_TYPE_ALTER; } break; case 48: /* priv_level ::= NK_STAR NK_DOT NK_STAR */ -{ yylhsminor.yy57.first = yymsp[-2].minor.yy0; yylhsminor.yy57.second = yymsp[0].minor.yy0; } - yymsp[-2].minor.yy57 = yylhsminor.yy57; +{ yylhsminor.yy577.first = yymsp[-2].minor.yy0; yylhsminor.yy577.second = yymsp[0].minor.yy0; } + yymsp[-2].minor.yy577 = yylhsminor.yy577; break; case 49: /* priv_level ::= db_name NK_DOT NK_STAR */ -{ yylhsminor.yy57.first = yymsp[-2].minor.yy929; yylhsminor.yy57.second = yymsp[0].minor.yy0; } - yymsp[-2].minor.yy57 = yylhsminor.yy57; +{ yylhsminor.yy577.first = yymsp[-2].minor.yy621; yylhsminor.yy577.second = yymsp[0].minor.yy0; } + yymsp[-2].minor.yy577 = yylhsminor.yy577; break; case 50: /* priv_level ::= db_name NK_DOT table_name */ -{ yylhsminor.yy57.first = yymsp[-2].minor.yy929; yylhsminor.yy57.second = yymsp[0].minor.yy929; } - yymsp[-2].minor.yy57 = yylhsminor.yy57; +{ yylhsminor.yy577.first = yymsp[-2].minor.yy621; yylhsminor.yy577.second = yymsp[0].minor.yy621; } + yymsp[-2].minor.yy577 = yylhsminor.yy577; break; case 51: /* priv_level ::= topic_name */ -{ yylhsminor.yy57.first = yymsp[0].minor.yy929; yylhsminor.yy57.second = nil_token; } - yymsp[0].minor.yy57 = yylhsminor.yy57; +{ yylhsminor.yy577.first = yymsp[0].minor.yy621; yylhsminor.yy577.second = nil_token; } + yymsp[0].minor.yy577 = yylhsminor.yy577; break; case 52: /* with_opt ::= */ case 157: /* start_opt ::= */ yytestcase(yyruleno==157); case 161: /* end_opt ::= */ yytestcase(yyruleno==161); case 302: /* like_pattern_opt ::= */ yytestcase(yyruleno==302); case 387: /* subtable_opt ::= */ yytestcase(yyruleno==387); - case 512: /* case_when_else_opt ::= */ yytestcase(yyruleno==512); - case 542: /* from_clause_opt ::= */ yytestcase(yyruleno==542); - case 575: /* where_clause_opt ::= */ yytestcase(yyruleno==575); - case 584: /* twindow_clause_opt ::= */ yytestcase(yyruleno==584); - case 592: /* sliding_opt ::= */ yytestcase(yyruleno==592); - case 597: /* fill_opt ::= */ yytestcase(yyruleno==597); - case 611: /* having_clause_opt ::= */ yytestcase(yyruleno==611); - case 613: /* range_opt ::= */ yytestcase(yyruleno==613); - case 616: /* every_opt ::= */ yytestcase(yyruleno==616); - case 629: /* slimit_clause_opt ::= */ yytestcase(yyruleno==629); - case 633: /* limit_clause_opt ::= */ yytestcase(yyruleno==633); -{ yymsp[1].minor.yy360 = NULL; } + case 527: /* case_when_else_opt ::= */ yytestcase(yyruleno==527); + case 557: /* from_clause_opt ::= */ yytestcase(yyruleno==557); + case 590: /* where_clause_opt ::= */ yytestcase(yyruleno==590); + case 599: /* twindow_clause_opt ::= */ yytestcase(yyruleno==599); + case 607: /* sliding_opt ::= */ yytestcase(yyruleno==607); + case 612: /* fill_opt ::= */ yytestcase(yyruleno==612); + case 626: /* having_clause_opt ::= */ yytestcase(yyruleno==626); + case 628: /* range_opt ::= */ yytestcase(yyruleno==628); + case 631: /* every_opt ::= */ yytestcase(yyruleno==631); + case 644: /* slimit_clause_opt ::= */ yytestcase(yyruleno==644); + case 648: /* limit_clause_opt ::= */ yytestcase(yyruleno==648); +{ yymsp[1].minor.yy20 = NULL; } break; case 53: /* with_opt ::= WITH search_condition */ - case 543: /* from_clause_opt ::= FROM table_reference_list */ yytestcase(yyruleno==543); - case 576: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==576); - case 612: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==612); -{ yymsp[-1].minor.yy360 = yymsp[0].minor.yy360; } + case 558: /* from_clause_opt ::= FROM table_reference_list */ yytestcase(yyruleno==558); + case 591: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==591); + case 627: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==627); +{ yymsp[-1].minor.yy20 = yymsp[0].minor.yy20; } break; case 54: /* cmd ::= CREATE DNODE dnode_endpoint */ -{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[0].minor.yy929, NULL); } +{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[0].minor.yy621, NULL); } break; case 55: /* cmd ::= CREATE DNODE dnode_endpoint PORT NK_INTEGER */ -{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[-2].minor.yy929, &yymsp[0].minor.yy0); } +{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[-2].minor.yy621, &yymsp[0].minor.yy0); } break; case 56: /* cmd ::= DROP DNODE NK_INTEGER force_opt */ -{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy345, false); } +{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy709, false); } break; case 57: /* cmd ::= DROP DNODE dnode_endpoint force_opt */ -{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy929, yymsp[0].minor.yy345, false); } +{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy621, yymsp[0].minor.yy709, false); } break; case 58: /* cmd ::= DROP DNODE NK_INTEGER unsafe_opt */ -{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy0, false, yymsp[0].minor.yy345); } +{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy0, false, yymsp[0].minor.yy709); } break; case 59: /* cmd ::= DROP DNODE dnode_endpoint unsafe_opt */ -{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy929, false, yymsp[0].minor.yy345); } +{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy621, false, yymsp[0].minor.yy709); } break; case 60: /* cmd ::= ALTER DNODE NK_INTEGER NK_STRING */ { pCxt->pRootNode = createAlterDnodeStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, NULL); } @@ -5245,34 +5029,34 @@ static YYACTIONTYPE yy_reduce( case 330: /* sma_func_name ::= FIRST */ yytestcase(yyruleno==330); case 331: /* sma_func_name ::= LAST */ yytestcase(yyruleno==331); case 332: /* sma_func_name ::= LAST_ROW */ yytestcase(yyruleno==332); - case 434: /* db_name ::= NK_ID */ yytestcase(yyruleno==434); - case 435: /* table_name ::= NK_ID */ yytestcase(yyruleno==435); - case 436: /* column_name ::= NK_ID */ yytestcase(yyruleno==436); - case 437: /* function_name ::= NK_ID */ yytestcase(yyruleno==437); - case 438: /* view_name ::= NK_ID */ yytestcase(yyruleno==438); - case 439: /* table_alias ::= NK_ID */ yytestcase(yyruleno==439); - case 440: /* column_alias ::= NK_ID */ yytestcase(yyruleno==440); - case 441: /* column_alias ::= NK_ALIAS */ yytestcase(yyruleno==441); - case 442: /* user_name ::= NK_ID */ yytestcase(yyruleno==442); - case 443: /* topic_name ::= NK_ID */ yytestcase(yyruleno==443); - case 444: /* stream_name ::= NK_ID */ yytestcase(yyruleno==444); - case 445: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==445); - case 446: /* index_name ::= NK_ID */ yytestcase(yyruleno==446); - case 488: /* noarg_func ::= NOW */ yytestcase(yyruleno==488); - case 489: /* noarg_func ::= TODAY */ yytestcase(yyruleno==489); - case 490: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==490); - case 491: /* noarg_func ::= DATABASE */ yytestcase(yyruleno==491); - case 492: /* noarg_func ::= CLIENT_VERSION */ yytestcase(yyruleno==492); - case 493: /* noarg_func ::= SERVER_VERSION */ yytestcase(yyruleno==493); - case 494: /* noarg_func ::= SERVER_STATUS */ yytestcase(yyruleno==494); - case 495: /* noarg_func ::= CURRENT_USER */ yytestcase(yyruleno==495); - case 496: /* noarg_func ::= USER */ yytestcase(yyruleno==496); - case 497: /* star_func ::= COUNT */ yytestcase(yyruleno==497); - case 498: /* star_func ::= FIRST */ yytestcase(yyruleno==498); - case 499: /* star_func ::= LAST */ yytestcase(yyruleno==499); - case 500: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==500); -{ yylhsminor.yy929 = yymsp[0].minor.yy0; } - yymsp[0].minor.yy929 = yylhsminor.yy929; + case 448: /* db_name ::= NK_ID */ yytestcase(yyruleno==448); + case 449: /* table_name ::= NK_ID */ yytestcase(yyruleno==449); + case 450: /* column_name ::= NK_ID */ yytestcase(yyruleno==450); + case 451: /* function_name ::= NK_ID */ yytestcase(yyruleno==451); + case 452: /* view_name ::= NK_ID */ yytestcase(yyruleno==452); + case 453: /* table_alias ::= NK_ID */ yytestcase(yyruleno==453); + case 454: /* column_alias ::= NK_ID */ yytestcase(yyruleno==454); + case 455: /* column_alias ::= NK_ALIAS */ yytestcase(yyruleno==455); + case 456: /* user_name ::= NK_ID */ yytestcase(yyruleno==456); + case 457: /* topic_name ::= NK_ID */ yytestcase(yyruleno==457); + case 458: /* stream_name ::= NK_ID */ yytestcase(yyruleno==458); + case 459: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==459); + case 460: /* index_name ::= NK_ID */ yytestcase(yyruleno==460); + case 503: /* noarg_func ::= NOW */ yytestcase(yyruleno==503); + case 504: /* noarg_func ::= TODAY */ yytestcase(yyruleno==504); + case 505: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==505); + case 506: /* noarg_func ::= DATABASE */ yytestcase(yyruleno==506); + case 507: /* noarg_func ::= CLIENT_VERSION */ yytestcase(yyruleno==507); + case 508: /* noarg_func ::= SERVER_VERSION */ yytestcase(yyruleno==508); + case 509: /* noarg_func ::= SERVER_STATUS */ yytestcase(yyruleno==509); + case 510: /* noarg_func ::= CURRENT_USER */ yytestcase(yyruleno==510); + case 511: /* noarg_func ::= USER */ yytestcase(yyruleno==511); + case 512: /* star_func ::= COUNT */ yytestcase(yyruleno==512); + case 513: /* star_func ::= FIRST */ yytestcase(yyruleno==513); + case 514: /* star_func ::= LAST */ yytestcase(yyruleno==514); + case 515: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==515); +{ yylhsminor.yy621 = yymsp[0].minor.yy0; } + yymsp[0].minor.yy621 = yylhsminor.yy621; break; case 68: /* force_opt ::= */ case 94: /* not_exists_opt ::= */ yytestcase(yyruleno==94); @@ -5281,17 +5065,17 @@ static YYACTIONTYPE yy_reduce( case 357: /* agg_func_opt ::= */ yytestcase(yyruleno==357); case 363: /* or_replace_opt ::= */ yytestcase(yyruleno==363); case 389: /* ignore_opt ::= */ yytestcase(yyruleno==389); - case 563: /* tag_mode_opt ::= */ yytestcase(yyruleno==563); - case 565: /* set_quantifier_opt ::= */ yytestcase(yyruleno==565); -{ yymsp[1].minor.yy345 = false; } + case 578: /* tag_mode_opt ::= */ yytestcase(yyruleno==578); + case 580: /* set_quantifier_opt ::= */ yytestcase(yyruleno==580); +{ yymsp[1].minor.yy709 = false; } break; case 69: /* force_opt ::= FORCE */ case 70: /* unsafe_opt ::= UNSAFE */ yytestcase(yyruleno==70); case 351: /* analyze_opt ::= ANALYZE */ yytestcase(yyruleno==351); case 358: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==358); - case 564: /* tag_mode_opt ::= TAGS */ yytestcase(yyruleno==564); - case 566: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==566); -{ yymsp[0].minor.yy345 = true; } + case 579: /* tag_mode_opt ::= TAGS */ yytestcase(yyruleno==579); + case 581: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==581); +{ yymsp[0].minor.yy709 = true; } break; case 71: /* cmd ::= ALTER CLUSTER NK_STRING */ { pCxt->pRootNode = createAlterClusterStmt(pCxt, &yymsp[0].minor.yy0, NULL); } @@ -5339,241 +5123,241 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createRestoreComponentNodeStmt(pCxt, QUERY_NODE_RESTORE_VNODE_STMT, &yymsp[0].minor.yy0); } break; case 86: /* cmd ::= CREATE DATABASE not_exists_opt db_name db_options */ -{ pCxt->pRootNode = createCreateDatabaseStmt(pCxt, yymsp[-2].minor.yy345, &yymsp[-1].minor.yy929, yymsp[0].minor.yy360); } +{ pCxt->pRootNode = createCreateDatabaseStmt(pCxt, yymsp[-2].minor.yy709, &yymsp[-1].minor.yy621, yymsp[0].minor.yy20); } break; case 87: /* cmd ::= DROP DATABASE exists_opt db_name */ -{ pCxt->pRootNode = createDropDatabaseStmt(pCxt, yymsp[-1].minor.yy345, &yymsp[0].minor.yy929); } +{ pCxt->pRootNode = createDropDatabaseStmt(pCxt, yymsp[-1].minor.yy709, &yymsp[0].minor.yy621); } break; case 88: /* cmd ::= USE db_name */ -{ pCxt->pRootNode = createUseDatabaseStmt(pCxt, &yymsp[0].minor.yy929); } +{ pCxt->pRootNode = createUseDatabaseStmt(pCxt, &yymsp[0].minor.yy621); } break; case 89: /* cmd ::= ALTER DATABASE db_name alter_db_options */ -{ pCxt->pRootNode = createAlterDatabaseStmt(pCxt, &yymsp[-1].minor.yy929, yymsp[0].minor.yy360); } +{ pCxt->pRootNode = createAlterDatabaseStmt(pCxt, &yymsp[-1].minor.yy621, yymsp[0].minor.yy20); } break; case 90: /* cmd ::= FLUSH DATABASE db_name */ -{ pCxt->pRootNode = createFlushDatabaseStmt(pCxt, &yymsp[0].minor.yy929); } +{ pCxt->pRootNode = createFlushDatabaseStmt(pCxt, &yymsp[0].minor.yy621); } break; case 91: /* cmd ::= TRIM DATABASE db_name speed_opt */ -{ pCxt->pRootNode = createTrimDatabaseStmt(pCxt, &yymsp[-1].minor.yy929, yymsp[0].minor.yy580); } +{ pCxt->pRootNode = createTrimDatabaseStmt(pCxt, &yymsp[-1].minor.yy621, yymsp[0].minor.yy252); } break; case 92: /* cmd ::= COMPACT DATABASE db_name start_opt end_opt */ -{ pCxt->pRootNode = createCompactStmt(pCxt, &yymsp[-2].minor.yy929, yymsp[-1].minor.yy360, yymsp[0].minor.yy360); } +{ pCxt->pRootNode = createCompactStmt(pCxt, &yymsp[-2].minor.yy621, yymsp[-1].minor.yy20, yymsp[0].minor.yy20); } break; case 93: /* not_exists_opt ::= IF NOT EXISTS */ -{ yymsp[-2].minor.yy345 = true; } +{ yymsp[-2].minor.yy709 = true; } break; case 95: /* exists_opt ::= IF EXISTS */ case 364: /* or_replace_opt ::= OR REPLACE */ yytestcase(yyruleno==364); case 390: /* ignore_opt ::= IGNORE UNTREATED */ yytestcase(yyruleno==390); -{ yymsp[-1].minor.yy345 = true; } +{ yymsp[-1].minor.yy709 = true; } break; case 97: /* db_options ::= */ -{ yymsp[1].minor.yy360 = createDefaultDatabaseOptions(pCxt); } +{ yymsp[1].minor.yy20 = createDefaultDatabaseOptions(pCxt); } break; case 98: /* db_options ::= db_options BUFFER NK_INTEGER */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_BUFFER, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_BUFFER, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 99: /* db_options ::= db_options CACHEMODEL NK_STRING */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_CACHEMODEL, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_CACHEMODEL, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 100: /* db_options ::= db_options CACHESIZE NK_INTEGER */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_CACHESIZE, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_CACHESIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 101: /* db_options ::= db_options COMP NK_INTEGER */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_COMP, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_COMP, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 102: /* db_options ::= db_options DURATION NK_INTEGER */ case 103: /* db_options ::= db_options DURATION NK_VARIABLE */ yytestcase(yyruleno==103); -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_DAYS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_DAYS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 104: /* db_options ::= db_options MAXROWS NK_INTEGER */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_MAXROWS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_MAXROWS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 105: /* db_options ::= db_options MINROWS NK_INTEGER */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_MINROWS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_MINROWS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 106: /* db_options ::= db_options KEEP integer_list */ case 107: /* db_options ::= db_options KEEP variable_list */ yytestcase(yyruleno==107); -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_KEEP, yymsp[0].minor.yy536); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_KEEP, yymsp[0].minor.yy1008); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 108: /* db_options ::= db_options PAGES NK_INTEGER */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_PAGES, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_PAGES, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 109: /* db_options ::= db_options PAGESIZE NK_INTEGER */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_PAGESIZE, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_PAGESIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 110: /* db_options ::= db_options TSDB_PAGESIZE NK_INTEGER */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_TSDB_PAGESIZE, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_TSDB_PAGESIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 111: /* db_options ::= db_options PRECISION NK_STRING */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_PRECISION, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_PRECISION, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 112: /* db_options ::= db_options REPLICA NK_INTEGER */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_REPLICA, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_REPLICA, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 113: /* db_options ::= db_options VGROUPS NK_INTEGER */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_VGROUPS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_VGROUPS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 114: /* db_options ::= db_options SINGLE_STABLE NK_INTEGER */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_SINGLE_STABLE, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_SINGLE_STABLE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 115: /* db_options ::= db_options RETENTIONS retention_list */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_RETENTIONS, yymsp[0].minor.yy536); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_RETENTIONS, yymsp[0].minor.yy1008); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 116: /* db_options ::= db_options SCHEMALESS NK_INTEGER */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_SCHEMALESS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_SCHEMALESS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 117: /* db_options ::= db_options WAL_LEVEL NK_INTEGER */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_WAL, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_WAL, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 118: /* db_options ::= db_options WAL_FSYNC_PERIOD NK_INTEGER */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_FSYNC, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_FSYNC, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 119: /* db_options ::= db_options WAL_RETENTION_PERIOD NK_INTEGER */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_WAL_RETENTION_PERIOD, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_WAL_RETENTION_PERIOD, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 120: /* db_options ::= db_options WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-3].minor.yy360, DB_OPTION_WAL_RETENTION_PERIOD, &t); + yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-3].minor.yy20, DB_OPTION_WAL_RETENTION_PERIOD, &t); } - yymsp[-3].minor.yy360 = yylhsminor.yy360; + yymsp[-3].minor.yy20 = yylhsminor.yy20; break; case 121: /* db_options ::= db_options WAL_RETENTION_SIZE NK_INTEGER */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_WAL_RETENTION_SIZE, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_WAL_RETENTION_SIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 122: /* db_options ::= db_options WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-3].minor.yy360, DB_OPTION_WAL_RETENTION_SIZE, &t); + yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-3].minor.yy20, DB_OPTION_WAL_RETENTION_SIZE, &t); } - yymsp[-3].minor.yy360 = yylhsminor.yy360; + yymsp[-3].minor.yy20 = yylhsminor.yy20; break; case 123: /* db_options ::= db_options WAL_ROLL_PERIOD NK_INTEGER */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_WAL_ROLL_PERIOD, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_WAL_ROLL_PERIOD, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 124: /* db_options ::= db_options WAL_SEGMENT_SIZE NK_INTEGER */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_WAL_SEGMENT_SIZE, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_WAL_SEGMENT_SIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 125: /* db_options ::= db_options STT_TRIGGER NK_INTEGER */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_STT_TRIGGER, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_STT_TRIGGER, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 126: /* db_options ::= db_options TABLE_PREFIX signed */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_TABLE_PREFIX, yymsp[0].minor.yy360); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_TABLE_PREFIX, yymsp[0].minor.yy20); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 127: /* db_options ::= db_options TABLE_SUFFIX signed */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_TABLE_SUFFIX, yymsp[0].minor.yy360); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_TABLE_SUFFIX, yymsp[0].minor.yy20); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 128: /* db_options ::= db_options KEEP_TIME_OFFSET NK_INTEGER */ -{ yylhsminor.yy360 = setDatabaseOption(pCxt, yymsp[-2].minor.yy360, DB_OPTION_KEEP_TIME_OFFSET, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setDatabaseOption(pCxt, yymsp[-2].minor.yy20, DB_OPTION_KEEP_TIME_OFFSET, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 129: /* alter_db_options ::= alter_db_option */ -{ yylhsminor.yy360 = createAlterDatabaseOptions(pCxt); yylhsminor.yy360 = setAlterDatabaseOption(pCxt, yylhsminor.yy360, &yymsp[0].minor.yy797); } - yymsp[0].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createAlterDatabaseOptions(pCxt); yylhsminor.yy20 = setAlterDatabaseOption(pCxt, yylhsminor.yy20, &yymsp[0].minor.yy489); } + yymsp[0].minor.yy20 = yylhsminor.yy20; break; case 130: /* alter_db_options ::= alter_db_options alter_db_option */ -{ yylhsminor.yy360 = setAlterDatabaseOption(pCxt, yymsp[-1].minor.yy360, &yymsp[0].minor.yy797); } - yymsp[-1].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setAlterDatabaseOption(pCxt, yymsp[-1].minor.yy20, &yymsp[0].minor.yy489); } + yymsp[-1].minor.yy20 = yylhsminor.yy20; break; case 131: /* alter_db_option ::= BUFFER NK_INTEGER */ -{ yymsp[-1].minor.yy797.type = DB_OPTION_BUFFER; yymsp[-1].minor.yy797.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy489.type = DB_OPTION_BUFFER; yymsp[-1].minor.yy489.val = yymsp[0].minor.yy0; } break; case 132: /* alter_db_option ::= CACHEMODEL NK_STRING */ -{ yymsp[-1].minor.yy797.type = DB_OPTION_CACHEMODEL; yymsp[-1].minor.yy797.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy489.type = DB_OPTION_CACHEMODEL; yymsp[-1].minor.yy489.val = yymsp[0].minor.yy0; } break; case 133: /* alter_db_option ::= CACHESIZE NK_INTEGER */ -{ yymsp[-1].minor.yy797.type = DB_OPTION_CACHESIZE; yymsp[-1].minor.yy797.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy489.type = DB_OPTION_CACHESIZE; yymsp[-1].minor.yy489.val = yymsp[0].minor.yy0; } break; case 134: /* alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */ -{ yymsp[-1].minor.yy797.type = DB_OPTION_FSYNC; yymsp[-1].minor.yy797.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy489.type = DB_OPTION_FSYNC; yymsp[-1].minor.yy489.val = yymsp[0].minor.yy0; } break; case 135: /* alter_db_option ::= KEEP integer_list */ case 136: /* alter_db_option ::= KEEP variable_list */ yytestcase(yyruleno==136); -{ yymsp[-1].minor.yy797.type = DB_OPTION_KEEP; yymsp[-1].minor.yy797.pList = yymsp[0].minor.yy536; } +{ yymsp[-1].minor.yy489.type = DB_OPTION_KEEP; yymsp[-1].minor.yy489.pList = yymsp[0].minor.yy1008; } break; case 137: /* alter_db_option ::= PAGES NK_INTEGER */ -{ yymsp[-1].minor.yy797.type = DB_OPTION_PAGES; yymsp[-1].minor.yy797.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy489.type = DB_OPTION_PAGES; yymsp[-1].minor.yy489.val = yymsp[0].minor.yy0; } break; case 138: /* alter_db_option ::= REPLICA NK_INTEGER */ -{ yymsp[-1].minor.yy797.type = DB_OPTION_REPLICA; yymsp[-1].minor.yy797.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy489.type = DB_OPTION_REPLICA; yymsp[-1].minor.yy489.val = yymsp[0].minor.yy0; } break; case 139: /* alter_db_option ::= WAL_LEVEL NK_INTEGER */ -{ yymsp[-1].minor.yy797.type = DB_OPTION_WAL; yymsp[-1].minor.yy797.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy489.type = DB_OPTION_WAL; yymsp[-1].minor.yy489.val = yymsp[0].minor.yy0; } break; case 140: /* alter_db_option ::= STT_TRIGGER NK_INTEGER */ -{ yymsp[-1].minor.yy797.type = DB_OPTION_STT_TRIGGER; yymsp[-1].minor.yy797.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy489.type = DB_OPTION_STT_TRIGGER; yymsp[-1].minor.yy489.val = yymsp[0].minor.yy0; } break; case 141: /* alter_db_option ::= MINROWS NK_INTEGER */ -{ yymsp[-1].minor.yy797.type = DB_OPTION_MINROWS; yymsp[-1].minor.yy797.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy489.type = DB_OPTION_MINROWS; yymsp[-1].minor.yy489.val = yymsp[0].minor.yy0; } break; case 142: /* alter_db_option ::= WAL_RETENTION_PERIOD NK_INTEGER */ -{ yymsp[-1].minor.yy797.type = DB_OPTION_WAL_RETENTION_PERIOD; yymsp[-1].minor.yy797.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy489.type = DB_OPTION_WAL_RETENTION_PERIOD; yymsp[-1].minor.yy489.val = yymsp[0].minor.yy0; } break; case 143: /* alter_db_option ::= WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yymsp[-2].minor.yy797.type = DB_OPTION_WAL_RETENTION_PERIOD; yymsp[-2].minor.yy797.val = t; + yymsp[-2].minor.yy489.type = DB_OPTION_WAL_RETENTION_PERIOD; yymsp[-2].minor.yy489.val = t; } break; case 144: /* alter_db_option ::= WAL_RETENTION_SIZE NK_INTEGER */ -{ yymsp[-1].minor.yy797.type = DB_OPTION_WAL_RETENTION_SIZE; yymsp[-1].minor.yy797.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy489.type = DB_OPTION_WAL_RETENTION_SIZE; yymsp[-1].minor.yy489.val = yymsp[0].minor.yy0; } break; case 145: /* alter_db_option ::= WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yymsp[-2].minor.yy797.type = DB_OPTION_WAL_RETENTION_SIZE; yymsp[-2].minor.yy797.val = t; + yymsp[-2].minor.yy489.type = DB_OPTION_WAL_RETENTION_SIZE; yymsp[-2].minor.yy489.val = t; } break; case 146: /* alter_db_option ::= KEEP_TIME_OFFSET NK_INTEGER */ -{ yymsp[-1].minor.yy797.type = DB_OPTION_KEEP_TIME_OFFSET; yymsp[-1].minor.yy797.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy489.type = DB_OPTION_KEEP_TIME_OFFSET; yymsp[-1].minor.yy489.val = yymsp[0].minor.yy0; } break; case 147: /* integer_list ::= NK_INTEGER */ -{ yylhsminor.yy536 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy536 = yylhsminor.yy536; +{ yylhsminor.yy1008 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy1008 = yylhsminor.yy1008; break; case 148: /* integer_list ::= integer_list NK_COMMA NK_INTEGER */ case 403: /* dnode_list ::= dnode_list DNODE NK_INTEGER */ yytestcase(yyruleno==403); -{ yylhsminor.yy536 = addNodeToList(pCxt, yymsp[-2].minor.yy536, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } - yymsp[-2].minor.yy536 = yylhsminor.yy536; +{ yylhsminor.yy1008 = addNodeToList(pCxt, yymsp[-2].minor.yy1008, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy1008 = yylhsminor.yy1008; break; case 149: /* variable_list ::= NK_VARIABLE */ -{ yylhsminor.yy536 = createNodeList(pCxt, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy536 = yylhsminor.yy536; +{ yylhsminor.yy1008 = createNodeList(pCxt, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy1008 = yylhsminor.yy1008; break; case 150: /* variable_list ::= variable_list NK_COMMA NK_VARIABLE */ -{ yylhsminor.yy536 = addNodeToList(pCxt, yymsp[-2].minor.yy536, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[-2].minor.yy536 = yylhsminor.yy536; +{ yylhsminor.yy1008 = addNodeToList(pCxt, yymsp[-2].minor.yy1008, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy1008 = yylhsminor.yy1008; break; case 151: /* retention_list ::= retention */ case 182: /* multi_create_clause ::= create_subtable_clause */ yytestcase(yyruleno==182); @@ -5583,14 +5367,15 @@ static YYACTIONTYPE yy_reduce( case 241: /* col_name_list ::= col_name */ yytestcase(yyruleno==241); case 308: /* tag_list_opt ::= tag_item */ yytestcase(yyruleno==308); case 325: /* func_list ::= func */ yytestcase(yyruleno==325); - case 432: /* literal_list ::= signed_literal */ yytestcase(yyruleno==432); - case 503: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==503); - case 509: /* when_then_list ::= when_then_expr */ yytestcase(yyruleno==509); - case 568: /* select_list ::= select_item */ yytestcase(yyruleno==568); - case 579: /* partition_list ::= partition_item */ yytestcase(yyruleno==579); - case 640: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==640); -{ yylhsminor.yy536 = createNodeList(pCxt, yymsp[0].minor.yy360); } - yymsp[0].minor.yy536 = yylhsminor.yy536; + case 421: /* tags_literal_list ::= tags_literal */ yytestcase(yyruleno==421); + case 446: /* literal_list ::= signed_literal */ yytestcase(yyruleno==446); + case 518: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==518); + case 524: /* when_then_list ::= when_then_expr */ yytestcase(yyruleno==524); + case 583: /* select_list ::= select_item */ yytestcase(yyruleno==583); + case 594: /* partition_list ::= partition_item */ yytestcase(yyruleno==594); + case 655: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==655); +{ yylhsminor.yy1008 = createNodeList(pCxt, yymsp[0].minor.yy20); } + yymsp[0].minor.yy1008 = yylhsminor.yy1008; break; case 152: /* retention_list ::= retention_list NK_COMMA retention */ case 186: /* multi_drop_clause ::= multi_drop_clause NK_COMMA drop_table_clause */ yytestcase(yyruleno==186); @@ -5599,272 +5384,273 @@ static YYACTIONTYPE yy_reduce( case 242: /* col_name_list ::= col_name_list NK_COMMA col_name */ yytestcase(yyruleno==242); case 309: /* tag_list_opt ::= tag_list_opt NK_COMMA tag_item */ yytestcase(yyruleno==309); case 326: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==326); - case 433: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==433); - case 504: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==504); - case 569: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==569); - case 580: /* partition_list ::= partition_list NK_COMMA partition_item */ yytestcase(yyruleno==580); - case 641: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==641); -{ yylhsminor.yy536 = addNodeToList(pCxt, yymsp[-2].minor.yy536, yymsp[0].minor.yy360); } - yymsp[-2].minor.yy536 = yylhsminor.yy536; + case 422: /* tags_literal_list ::= tags_literal_list NK_COMMA tags_literal */ yytestcase(yyruleno==422); + case 447: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==447); + case 519: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==519); + case 584: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==584); + case 595: /* partition_list ::= partition_list NK_COMMA partition_item */ yytestcase(yyruleno==595); + case 656: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==656); +{ yylhsminor.yy1008 = addNodeToList(pCxt, yymsp[-2].minor.yy1008, yymsp[0].minor.yy20); } + yymsp[-2].minor.yy1008 = yylhsminor.yy1008; break; case 153: /* retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ case 154: /* retention ::= NK_MINUS NK_COLON NK_VARIABLE */ yytestcase(yyruleno==154); -{ yylhsminor.yy360 = createNodeListNodeEx(pCxt, createDurationValueNode(pCxt, &yymsp[-2].minor.yy0), createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createNodeListNodeEx(pCxt, createDurationValueNode(pCxt, &yymsp[-2].minor.yy0), createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 155: /* speed_opt ::= */ case 359: /* bufsize_opt ::= */ yytestcase(yyruleno==359); -{ yymsp[1].minor.yy580 = 0; } +{ yymsp[1].minor.yy252 = 0; } break; case 156: /* speed_opt ::= BWLIMIT NK_INTEGER */ case 360: /* bufsize_opt ::= BUFSIZE NK_INTEGER */ yytestcase(yyruleno==360); -{ yymsp[-1].minor.yy580 = taosStr2Int32(yymsp[0].minor.yy0.z, NULL, 10); } +{ yymsp[-1].minor.yy252 = taosStr2Int32(yymsp[0].minor.yy0.z, NULL, 10); } break; case 158: /* start_opt ::= START WITH NK_INTEGER */ case 162: /* end_opt ::= END WITH NK_INTEGER */ yytestcase(yyruleno==162); -{ yymsp[-2].minor.yy360 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); } +{ yymsp[-2].minor.yy20 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); } break; case 159: /* start_opt ::= START WITH NK_STRING */ case 163: /* end_opt ::= END WITH NK_STRING */ yytestcase(yyruleno==163); -{ yymsp[-2].minor.yy360 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } +{ yymsp[-2].minor.yy20 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } break; case 160: /* start_opt ::= START WITH TIMESTAMP NK_STRING */ case 164: /* end_opt ::= END WITH TIMESTAMP NK_STRING */ yytestcase(yyruleno==164); -{ yymsp[-3].minor.yy360 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } +{ yymsp[-3].minor.yy20 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } break; case 165: /* cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ case 167: /* cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ yytestcase(yyruleno==167); -{ pCxt->pRootNode = createCreateTableStmt(pCxt, yymsp[-6].minor.yy345, yymsp[-5].minor.yy360, yymsp[-3].minor.yy536, yymsp[-1].minor.yy536, yymsp[0].minor.yy360); } +{ pCxt->pRootNode = createCreateTableStmt(pCxt, yymsp[-6].minor.yy709, yymsp[-5].minor.yy20, yymsp[-3].minor.yy1008, yymsp[-1].minor.yy1008, yymsp[0].minor.yy20); } break; case 166: /* cmd ::= CREATE TABLE multi_create_clause */ -{ pCxt->pRootNode = createCreateMultiTableStmt(pCxt, yymsp[0].minor.yy536); } +{ pCxt->pRootNode = createCreateMultiTableStmt(pCxt, yymsp[0].minor.yy1008); } break; case 168: /* cmd ::= DROP TABLE multi_drop_clause */ -{ pCxt->pRootNode = createDropTableStmt(pCxt, yymsp[0].minor.yy536); } +{ pCxt->pRootNode = createDropTableStmt(pCxt, yymsp[0].minor.yy1008); } break; case 169: /* cmd ::= DROP STABLE exists_opt full_table_name */ -{ pCxt->pRootNode = createDropSuperTableStmt(pCxt, yymsp[-1].minor.yy345, yymsp[0].minor.yy360); } +{ pCxt->pRootNode = createDropSuperTableStmt(pCxt, yymsp[-1].minor.yy709, yymsp[0].minor.yy20); } break; case 170: /* cmd ::= ALTER TABLE alter_table_clause */ case 405: /* cmd ::= query_or_subquery */ yytestcase(yyruleno==405); case 406: /* cmd ::= insert_query */ yytestcase(yyruleno==406); -{ pCxt->pRootNode = yymsp[0].minor.yy360; } +{ pCxt->pRootNode = yymsp[0].minor.yy20; } break; case 171: /* cmd ::= ALTER STABLE alter_table_clause */ -{ pCxt->pRootNode = setAlterSuperTableType(yymsp[0].minor.yy360); } +{ pCxt->pRootNode = setAlterSuperTableType(yymsp[0].minor.yy20); } break; case 172: /* alter_table_clause ::= full_table_name alter_table_options */ -{ yylhsminor.yy360 = createAlterTableModifyOptions(pCxt, yymsp[-1].minor.yy360, yymsp[0].minor.yy360); } - yymsp[-1].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createAlterTableModifyOptions(pCxt, yymsp[-1].minor.yy20, yymsp[0].minor.yy20); } + yymsp[-1].minor.yy20 = yylhsminor.yy20; break; case 173: /* alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ -{ yylhsminor.yy360 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy360, TSDB_ALTER_TABLE_ADD_COLUMN, &yymsp[-1].minor.yy929, yymsp[0].minor.yy912); } - yymsp[-4].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy20, TSDB_ALTER_TABLE_ADD_COLUMN, &yymsp[-1].minor.yy621, yymsp[0].minor.yy324); } + yymsp[-4].minor.yy20 = yylhsminor.yy20; break; case 174: /* alter_table_clause ::= full_table_name DROP COLUMN column_name */ -{ yylhsminor.yy360 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy360, TSDB_ALTER_TABLE_DROP_COLUMN, &yymsp[0].minor.yy929); } - yymsp[-3].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy20, TSDB_ALTER_TABLE_DROP_COLUMN, &yymsp[0].minor.yy621); } + yymsp[-3].minor.yy20 = yylhsminor.yy20; break; case 175: /* alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ -{ yylhsminor.yy360 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy360, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, &yymsp[-1].minor.yy929, yymsp[0].minor.yy912); } - yymsp[-4].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy20, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, &yymsp[-1].minor.yy621, yymsp[0].minor.yy324); } + yymsp[-4].minor.yy20 = yylhsminor.yy20; break; case 176: /* alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ -{ yylhsminor.yy360 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy360, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &yymsp[-1].minor.yy929, &yymsp[0].minor.yy929); } - yymsp[-4].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy20, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &yymsp[-1].minor.yy621, &yymsp[0].minor.yy621); } + yymsp[-4].minor.yy20 = yylhsminor.yy20; break; case 177: /* alter_table_clause ::= full_table_name ADD TAG column_name type_name */ -{ yylhsminor.yy360 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy360, TSDB_ALTER_TABLE_ADD_TAG, &yymsp[-1].minor.yy929, yymsp[0].minor.yy912); } - yymsp[-4].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy20, TSDB_ALTER_TABLE_ADD_TAG, &yymsp[-1].minor.yy621, yymsp[0].minor.yy324); } + yymsp[-4].minor.yy20 = yylhsminor.yy20; break; case 178: /* alter_table_clause ::= full_table_name DROP TAG column_name */ -{ yylhsminor.yy360 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy360, TSDB_ALTER_TABLE_DROP_TAG, &yymsp[0].minor.yy929); } - yymsp[-3].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy20, TSDB_ALTER_TABLE_DROP_TAG, &yymsp[0].minor.yy621); } + yymsp[-3].minor.yy20 = yylhsminor.yy20; break; case 179: /* alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ -{ yylhsminor.yy360 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy360, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &yymsp[-1].minor.yy929, yymsp[0].minor.yy912); } - yymsp[-4].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy20, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &yymsp[-1].minor.yy621, yymsp[0].minor.yy324); } + yymsp[-4].minor.yy20 = yylhsminor.yy20; break; case 180: /* alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ -{ yylhsminor.yy360 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy360, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &yymsp[-1].minor.yy929, &yymsp[0].minor.yy929); } - yymsp[-4].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy20, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &yymsp[-1].minor.yy621, &yymsp[0].minor.yy621); } + yymsp[-4].minor.yy20 = yylhsminor.yy20; break; - case 181: /* alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ -{ yylhsminor.yy360 = createAlterTableSetTag(pCxt, yymsp[-5].minor.yy360, &yymsp[-2].minor.yy929, yymsp[0].minor.yy360); } - yymsp[-5].minor.yy360 = yylhsminor.yy360; + case 181: /* alter_table_clause ::= full_table_name SET TAG column_name NK_EQ tags_literal */ +{ yylhsminor.yy20 = createAlterTableSetTag(pCxt, yymsp[-5].minor.yy20, &yymsp[-2].minor.yy621, yymsp[0].minor.yy20); } + yymsp[-5].minor.yy20 = yylhsminor.yy20; break; case 183: /* multi_create_clause ::= multi_create_clause create_subtable_clause */ - case 510: /* when_then_list ::= when_then_list when_then_expr */ yytestcase(yyruleno==510); -{ yylhsminor.yy536 = addNodeToList(pCxt, yymsp[-1].minor.yy536, yymsp[0].minor.yy360); } - yymsp[-1].minor.yy536 = yylhsminor.yy536; + case 525: /* when_then_list ::= when_then_list when_then_expr */ yytestcase(yyruleno==525); +{ yylhsminor.yy1008 = addNodeToList(pCxt, yymsp[-1].minor.yy1008, yymsp[0].minor.yy20); } + yymsp[-1].minor.yy1008 = yylhsminor.yy1008; break; - case 184: /* create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP expression_list NK_RP table_options */ -{ yylhsminor.yy360 = createCreateSubTableClause(pCxt, yymsp[-9].minor.yy345, yymsp[-8].minor.yy360, yymsp[-6].minor.yy360, yymsp[-5].minor.yy536, yymsp[-2].minor.yy536, yymsp[0].minor.yy360); } - yymsp[-9].minor.yy360 = yylhsminor.yy360; + case 184: /* create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP tags_literal_list NK_RP table_options */ +{ yylhsminor.yy20 = createCreateSubTableClause(pCxt, yymsp[-9].minor.yy709, yymsp[-8].minor.yy20, yymsp[-6].minor.yy20, yymsp[-5].minor.yy1008, yymsp[-2].minor.yy1008, yymsp[0].minor.yy20); } + yymsp[-9].minor.yy20 = yylhsminor.yy20; break; case 187: /* drop_table_clause ::= exists_opt full_table_name */ -{ yylhsminor.yy360 = createDropTableClause(pCxt, yymsp[-1].minor.yy345, yymsp[0].minor.yy360); } - yymsp[-1].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createDropTableClause(pCxt, yymsp[-1].minor.yy709, yymsp[0].minor.yy20); } + yymsp[-1].minor.yy20 = yylhsminor.yy20; break; case 189: /* specific_cols_opt ::= NK_LP col_name_list NK_RP */ case 374: /* col_list_opt ::= NK_LP col_name_list NK_RP */ yytestcase(yyruleno==374); -{ yymsp[-2].minor.yy536 = yymsp[-1].minor.yy536; } +{ yymsp[-2].minor.yy1008 = yymsp[-1].minor.yy1008; } break; case 190: /* full_table_name ::= table_name */ -{ yylhsminor.yy360 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy929, NULL); } - yymsp[0].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy621, NULL); } + yymsp[0].minor.yy20 = yylhsminor.yy20; break; case 191: /* full_table_name ::= db_name NK_DOT table_name */ -{ yylhsminor.yy360 = createRealTableNode(pCxt, &yymsp[-2].minor.yy929, &yymsp[0].minor.yy929, NULL); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createRealTableNode(pCxt, &yymsp[-2].minor.yy621, &yymsp[0].minor.yy621, NULL); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 194: /* column_def ::= column_name type_name */ -{ yylhsminor.yy360 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy929, yymsp[0].minor.yy912, NULL); } - yymsp[-1].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy621, yymsp[0].minor.yy324, NULL); } + yymsp[-1].minor.yy20 = yylhsminor.yy20; break; case 195: /* type_name ::= BOOL */ -{ yymsp[0].minor.yy912 = createDataType(TSDB_DATA_TYPE_BOOL); } +{ yymsp[0].minor.yy324 = createDataType(TSDB_DATA_TYPE_BOOL); } break; case 196: /* type_name ::= TINYINT */ -{ yymsp[0].minor.yy912 = createDataType(TSDB_DATA_TYPE_TINYINT); } +{ yymsp[0].minor.yy324 = createDataType(TSDB_DATA_TYPE_TINYINT); } break; case 197: /* type_name ::= SMALLINT */ -{ yymsp[0].minor.yy912 = createDataType(TSDB_DATA_TYPE_SMALLINT); } +{ yymsp[0].minor.yy324 = createDataType(TSDB_DATA_TYPE_SMALLINT); } break; case 198: /* type_name ::= INT */ case 199: /* type_name ::= INTEGER */ yytestcase(yyruleno==199); -{ yymsp[0].minor.yy912 = createDataType(TSDB_DATA_TYPE_INT); } +{ yymsp[0].minor.yy324 = createDataType(TSDB_DATA_TYPE_INT); } break; case 200: /* type_name ::= BIGINT */ -{ yymsp[0].minor.yy912 = createDataType(TSDB_DATA_TYPE_BIGINT); } +{ yymsp[0].minor.yy324 = createDataType(TSDB_DATA_TYPE_BIGINT); } break; case 201: /* type_name ::= FLOAT */ -{ yymsp[0].minor.yy912 = createDataType(TSDB_DATA_TYPE_FLOAT); } +{ yymsp[0].minor.yy324 = createDataType(TSDB_DATA_TYPE_FLOAT); } break; case 202: /* type_name ::= DOUBLE */ -{ yymsp[0].minor.yy912 = createDataType(TSDB_DATA_TYPE_DOUBLE); } +{ yymsp[0].minor.yy324 = createDataType(TSDB_DATA_TYPE_DOUBLE); } break; case 203: /* type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy912 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy0); } +{ yymsp[-3].minor.yy324 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy0); } break; case 204: /* type_name ::= TIMESTAMP */ -{ yymsp[0].minor.yy912 = createDataType(TSDB_DATA_TYPE_TIMESTAMP); } +{ yymsp[0].minor.yy324 = createDataType(TSDB_DATA_TYPE_TIMESTAMP); } break; case 205: /* type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy912 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, &yymsp[-1].minor.yy0); } +{ yymsp[-3].minor.yy324 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, &yymsp[-1].minor.yy0); } break; case 206: /* type_name ::= TINYINT UNSIGNED */ -{ yymsp[-1].minor.yy912 = createDataType(TSDB_DATA_TYPE_UTINYINT); } +{ yymsp[-1].minor.yy324 = createDataType(TSDB_DATA_TYPE_UTINYINT); } break; case 207: /* type_name ::= SMALLINT UNSIGNED */ -{ yymsp[-1].minor.yy912 = createDataType(TSDB_DATA_TYPE_USMALLINT); } +{ yymsp[-1].minor.yy324 = createDataType(TSDB_DATA_TYPE_USMALLINT); } break; case 208: /* type_name ::= INT UNSIGNED */ -{ yymsp[-1].minor.yy912 = createDataType(TSDB_DATA_TYPE_UINT); } +{ yymsp[-1].minor.yy324 = createDataType(TSDB_DATA_TYPE_UINT); } break; case 209: /* type_name ::= BIGINT UNSIGNED */ -{ yymsp[-1].minor.yy912 = createDataType(TSDB_DATA_TYPE_UBIGINT); } +{ yymsp[-1].minor.yy324 = createDataType(TSDB_DATA_TYPE_UBIGINT); } break; case 210: /* type_name ::= JSON */ -{ yymsp[0].minor.yy912 = createDataType(TSDB_DATA_TYPE_JSON); } +{ yymsp[0].minor.yy324 = createDataType(TSDB_DATA_TYPE_JSON); } break; case 211: /* type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy912 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, &yymsp[-1].minor.yy0); } +{ yymsp[-3].minor.yy324 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, &yymsp[-1].minor.yy0); } break; case 212: /* type_name ::= MEDIUMBLOB */ -{ yymsp[0].minor.yy912 = createDataType(TSDB_DATA_TYPE_MEDIUMBLOB); } +{ yymsp[0].minor.yy324 = createDataType(TSDB_DATA_TYPE_MEDIUMBLOB); } break; case 213: /* type_name ::= BLOB */ -{ yymsp[0].minor.yy912 = createDataType(TSDB_DATA_TYPE_BLOB); } +{ yymsp[0].minor.yy324 = createDataType(TSDB_DATA_TYPE_BLOB); } break; case 214: /* type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy912 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, &yymsp[-1].minor.yy0); } +{ yymsp[-3].minor.yy324 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, &yymsp[-1].minor.yy0); } break; case 215: /* type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy912 = createVarLenDataType(TSDB_DATA_TYPE_GEOMETRY, &yymsp[-1].minor.yy0); } +{ yymsp[-3].minor.yy324 = createVarLenDataType(TSDB_DATA_TYPE_GEOMETRY, &yymsp[-1].minor.yy0); } break; case 216: /* type_name ::= DECIMAL */ -{ yymsp[0].minor.yy912 = createDataType(TSDB_DATA_TYPE_DECIMAL); } +{ yymsp[0].minor.yy324 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; case 217: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy912 = createDataType(TSDB_DATA_TYPE_DECIMAL); } +{ yymsp[-3].minor.yy324 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; case 218: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ -{ yymsp[-5].minor.yy912 = createDataType(TSDB_DATA_TYPE_DECIMAL); } +{ yymsp[-5].minor.yy324 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; case 221: /* tags_def ::= TAGS NK_LP column_def_list NK_RP */ case 377: /* tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP */ yytestcase(yyruleno==377); -{ yymsp[-3].minor.yy536 = yymsp[-1].minor.yy536; } +{ yymsp[-3].minor.yy1008 = yymsp[-1].minor.yy1008; } break; case 222: /* table_options ::= */ -{ yymsp[1].minor.yy360 = createDefaultTableOptions(pCxt); } +{ yymsp[1].minor.yy20 = createDefaultTableOptions(pCxt); } break; case 223: /* table_options ::= table_options COMMENT NK_STRING */ -{ yylhsminor.yy360 = setTableOption(pCxt, yymsp[-2].minor.yy360, TABLE_OPTION_COMMENT, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setTableOption(pCxt, yymsp[-2].minor.yy20, TABLE_OPTION_COMMENT, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 224: /* table_options ::= table_options MAX_DELAY duration_list */ -{ yylhsminor.yy360 = setTableOption(pCxt, yymsp[-2].minor.yy360, TABLE_OPTION_MAXDELAY, yymsp[0].minor.yy536); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setTableOption(pCxt, yymsp[-2].minor.yy20, TABLE_OPTION_MAXDELAY, yymsp[0].minor.yy1008); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 225: /* table_options ::= table_options WATERMARK duration_list */ -{ yylhsminor.yy360 = setTableOption(pCxt, yymsp[-2].minor.yy360, TABLE_OPTION_WATERMARK, yymsp[0].minor.yy536); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setTableOption(pCxt, yymsp[-2].minor.yy20, TABLE_OPTION_WATERMARK, yymsp[0].minor.yy1008); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 226: /* table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ -{ yylhsminor.yy360 = setTableOption(pCxt, yymsp[-4].minor.yy360, TABLE_OPTION_ROLLUP, yymsp[-1].minor.yy536); } - yymsp[-4].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setTableOption(pCxt, yymsp[-4].minor.yy20, TABLE_OPTION_ROLLUP, yymsp[-1].minor.yy1008); } + yymsp[-4].minor.yy20 = yylhsminor.yy20; break; case 227: /* table_options ::= table_options TTL NK_INTEGER */ -{ yylhsminor.yy360 = setTableOption(pCxt, yymsp[-2].minor.yy360, TABLE_OPTION_TTL, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setTableOption(pCxt, yymsp[-2].minor.yy20, TABLE_OPTION_TTL, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 228: /* table_options ::= table_options SMA NK_LP col_name_list NK_RP */ -{ yylhsminor.yy360 = setTableOption(pCxt, yymsp[-4].minor.yy360, TABLE_OPTION_SMA, yymsp[-1].minor.yy536); } - yymsp[-4].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setTableOption(pCxt, yymsp[-4].minor.yy20, TABLE_OPTION_SMA, yymsp[-1].minor.yy1008); } + yymsp[-4].minor.yy20 = yylhsminor.yy20; break; case 229: /* table_options ::= table_options DELETE_MARK duration_list */ -{ yylhsminor.yy360 = setTableOption(pCxt, yymsp[-2].minor.yy360, TABLE_OPTION_DELETE_MARK, yymsp[0].minor.yy536); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setTableOption(pCxt, yymsp[-2].minor.yy20, TABLE_OPTION_DELETE_MARK, yymsp[0].minor.yy1008); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 230: /* alter_table_options ::= alter_table_option */ -{ yylhsminor.yy360 = createAlterTableOptions(pCxt); yylhsminor.yy360 = setTableOption(pCxt, yylhsminor.yy360, yymsp[0].minor.yy797.type, &yymsp[0].minor.yy797.val); } - yymsp[0].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createAlterTableOptions(pCxt); yylhsminor.yy20 = setTableOption(pCxt, yylhsminor.yy20, yymsp[0].minor.yy489.type, &yymsp[0].minor.yy489.val); } + yymsp[0].minor.yy20 = yylhsminor.yy20; break; case 231: /* alter_table_options ::= alter_table_options alter_table_option */ -{ yylhsminor.yy360 = setTableOption(pCxt, yymsp[-1].minor.yy360, yymsp[0].minor.yy797.type, &yymsp[0].minor.yy797.val); } - yymsp[-1].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setTableOption(pCxt, yymsp[-1].minor.yy20, yymsp[0].minor.yy489.type, &yymsp[0].minor.yy489.val); } + yymsp[-1].minor.yy20 = yylhsminor.yy20; break; case 232: /* alter_table_option ::= COMMENT NK_STRING */ -{ yymsp[-1].minor.yy797.type = TABLE_OPTION_COMMENT; yymsp[-1].minor.yy797.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy489.type = TABLE_OPTION_COMMENT; yymsp[-1].minor.yy489.val = yymsp[0].minor.yy0; } break; case 233: /* alter_table_option ::= TTL NK_INTEGER */ -{ yymsp[-1].minor.yy797.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy797.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy489.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy489.val = yymsp[0].minor.yy0; } break; case 234: /* duration_list ::= duration_literal */ - case 464: /* expression_list ::= expr_or_subquery */ yytestcase(yyruleno==464); -{ yylhsminor.yy536 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy360)); } - yymsp[0].minor.yy536 = yylhsminor.yy536; + case 478: /* expression_list ::= expr_or_subquery */ yytestcase(yyruleno==478); +{ yylhsminor.yy1008 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy20)); } + yymsp[0].minor.yy1008 = yylhsminor.yy1008; break; case 235: /* duration_list ::= duration_list NK_COMMA duration_literal */ - case 465: /* expression_list ::= expression_list NK_COMMA expr_or_subquery */ yytestcase(yyruleno==465); -{ yylhsminor.yy536 = addNodeToList(pCxt, yymsp[-2].minor.yy536, releaseRawExprNode(pCxt, yymsp[0].minor.yy360)); } - yymsp[-2].minor.yy536 = yylhsminor.yy536; + case 479: /* expression_list ::= expression_list NK_COMMA expr_or_subquery */ yytestcase(yyruleno==479); +{ yylhsminor.yy1008 = addNodeToList(pCxt, yymsp[-2].minor.yy1008, releaseRawExprNode(pCxt, yymsp[0].minor.yy20)); } + yymsp[-2].minor.yy1008 = yylhsminor.yy1008; break; case 238: /* rollup_func_name ::= function_name */ -{ yylhsminor.yy360 = createFunctionNode(pCxt, &yymsp[0].minor.yy929, NULL); } - yymsp[0].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createFunctionNode(pCxt, &yymsp[0].minor.yy621, NULL); } + yymsp[0].minor.yy20 = yylhsminor.yy20; break; case 239: /* rollup_func_name ::= FIRST */ case 240: /* rollup_func_name ::= LAST */ yytestcase(yyruleno==240); case 311: /* tag_item ::= QTAGS */ yytestcase(yyruleno==311); -{ yylhsminor.yy360 = createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL); } - yymsp[0].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL); } + yymsp[0].minor.yy20 = yylhsminor.yy20; break; case 243: /* col_name ::= column_name */ case 312: /* tag_item ::= column_name */ yytestcase(yyruleno==312); -{ yylhsminor.yy360 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy929); } - yymsp[0].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy621); } + yymsp[0].minor.yy20 = yylhsminor.yy20; break; case 244: /* cmd ::= SHOW DNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DNODES_STMT); } @@ -5878,19 +5664,19 @@ static YYACTIONTYPE yy_reduce( case 247: /* cmd ::= SHOW db_kind_opt DATABASES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DATABASES_STMT); - setShowKind(pCxt, pCxt->pRootNode, yymsp[-1].minor.yy321); + setShowKind(pCxt, pCxt->pRootNode, yymsp[-1].minor.yy277); } break; case 248: /* cmd ::= SHOW table_kind_db_name_cond_opt TABLES like_pattern_opt */ { - pCxt->pRootNode = createShowTablesStmt(pCxt, yymsp[-2].minor.yy1005, yymsp[0].minor.yy360, OP_TYPE_LIKE); + pCxt->pRootNode = createShowTablesStmt(pCxt, yymsp[-2].minor.yy105, yymsp[0].minor.yy20, OP_TYPE_LIKE); } break; case 249: /* cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_STABLES_STMT, yymsp[-2].minor.yy360, yymsp[0].minor.yy360, OP_TYPE_LIKE); } +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_STABLES_STMT, yymsp[-2].minor.yy20, yymsp[0].minor.yy20, OP_TYPE_LIKE); } break; case 250: /* cmd ::= SHOW db_name_cond_opt VGROUPS */ -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, yymsp[-1].minor.yy360, NULL, OP_TYPE_LIKE); } +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, yymsp[-1].minor.yy20, NULL, OP_TYPE_LIKE); } break; case 251: /* cmd ::= SHOW MNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_MNODES_STMT); } @@ -5902,10 +5688,10 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_FUNCTIONS_STMT); } break; case 254: /* cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, yymsp[0].minor.yy360, yymsp[-1].minor.yy360, OP_TYPE_EQUAL); } +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, yymsp[0].minor.yy20, yymsp[-1].minor.yy20, OP_TYPE_EQUAL); } break; case 255: /* cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */ -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy929), createIdentifierValueNode(pCxt, &yymsp[0].minor.yy929), OP_TYPE_EQUAL); } +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy621), createIdentifierValueNode(pCxt, &yymsp[0].minor.yy621), OP_TYPE_EQUAL); } break; case 256: /* cmd ::= SHOW STREAMS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_STREAMS_STMT); } @@ -5933,13 +5719,13 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CLUSTER_MACHINES_STMT); } break; case 265: /* cmd ::= SHOW CREATE DATABASE db_name */ -{ pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &yymsp[0].minor.yy929); } +{ pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &yymsp[0].minor.yy621); } break; case 266: /* cmd ::= SHOW CREATE TABLE full_table_name */ -{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, yymsp[0].minor.yy360); } +{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, yymsp[0].minor.yy20); } break; case 267: /* cmd ::= SHOW CREATE STABLE full_table_name */ -{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, yymsp[0].minor.yy360); } +{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, yymsp[0].minor.yy20); } break; case 268: /* cmd ::= SHOW QUERIES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QUERIES_STMT); } @@ -5958,7 +5744,7 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT); } break; case 274: /* cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */ -{ pCxt->pRootNode = createShowDnodeVariablesStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[-2].minor.yy0), yymsp[0].minor.yy360); } +{ pCxt->pRootNode = createShowDnodeVariablesStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[-2].minor.yy0), yymsp[0].minor.yy20); } break; case 275: /* cmd ::= SHOW BNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_BNODES_STMT); } @@ -5973,7 +5759,7 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TRANSACTIONS_STMT); } break; case 279: /* cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ -{ pCxt->pRootNode = createShowTableDistributedStmt(pCxt, yymsp[0].minor.yy360); } +{ pCxt->pRootNode = createShowTableDistributedStmt(pCxt, yymsp[0].minor.yy20); } break; case 280: /* cmd ::= SHOW CONSUMERS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CONSUMERS_STMT); } @@ -5982,16 +5768,16 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT); } break; case 282: /* cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, yymsp[0].minor.yy360, yymsp[-1].minor.yy360, OP_TYPE_EQUAL); } +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, yymsp[0].minor.yy20, yymsp[-1].minor.yy20, OP_TYPE_EQUAL); } break; case 283: /* cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */ -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy929), createIdentifierValueNode(pCxt, &yymsp[0].minor.yy929), OP_TYPE_EQUAL); } +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy621), createIdentifierValueNode(pCxt, &yymsp[0].minor.yy621), OP_TYPE_EQUAL); } break; case 284: /* cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */ -{ pCxt->pRootNode = createShowTableTagsStmt(pCxt, yymsp[-1].minor.yy360, yymsp[0].minor.yy360, yymsp[-3].minor.yy536); } +{ pCxt->pRootNode = createShowTableTagsStmt(pCxt, yymsp[-1].minor.yy20, yymsp[0].minor.yy20, yymsp[-3].minor.yy1008); } break; case 285: /* cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */ -{ pCxt->pRootNode = createShowTableTagsStmt(pCxt, createIdentifierValueNode(pCxt, &yymsp[0].minor.yy929), createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy929), yymsp[-4].minor.yy536); } +{ pCxt->pRootNode = createShowTableTagsStmt(pCxt, createIdentifierValueNode(pCxt, &yymsp[0].minor.yy621), createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy621), yymsp[-4].minor.yy1008); } break; case 286: /* cmd ::= SHOW VNODES ON DNODE NK_INTEGER */ { pCxt->pRootNode = createShowVnodesStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0), NULL); } @@ -6000,16 +5786,16 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createShowVnodesStmt(pCxt, NULL, NULL); } break; case 288: /* cmd ::= SHOW db_name_cond_opt ALIVE */ -{ pCxt->pRootNode = createShowAliveStmt(pCxt, yymsp[-1].minor.yy360, QUERY_NODE_SHOW_DB_ALIVE_STMT); } +{ pCxt->pRootNode = createShowAliveStmt(pCxt, yymsp[-1].minor.yy20, QUERY_NODE_SHOW_DB_ALIVE_STMT); } break; case 289: /* cmd ::= SHOW CLUSTER ALIVE */ { pCxt->pRootNode = createShowAliveStmt(pCxt, NULL, QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT); } break; case 290: /* cmd ::= SHOW db_name_cond_opt VIEWS like_pattern_opt */ -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VIEWS_STMT, yymsp[-2].minor.yy360, yymsp[0].minor.yy360, OP_TYPE_LIKE); } +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VIEWS_STMT, yymsp[-2].minor.yy20, yymsp[0].minor.yy20, OP_TYPE_LIKE); } break; case 291: /* cmd ::= SHOW CREATE VIEW full_table_name */ -{ pCxt->pRootNode = createShowCreateViewStmt(pCxt, QUERY_NODE_SHOW_CREATE_VIEW_STMT, yymsp[0].minor.yy360); } +{ pCxt->pRootNode = createShowCreateViewStmt(pCxt, QUERY_NODE_SHOW_CREATE_VIEW_STMT, yymsp[0].minor.yy20); } break; case 292: /* cmd ::= SHOW COMPACTS */ { pCxt->pRootNode = createShowCompactsStmt(pCxt, QUERY_NODE_SHOW_COMPACTS_STMT); } @@ -6018,232 +5804,232 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createShowCompactDetailsStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } break; case 294: /* table_kind_db_name_cond_opt ::= */ -{ yymsp[1].minor.yy1005.kind = SHOW_KIND_ALL; yymsp[1].minor.yy1005.dbName = nil_token; } +{ yymsp[1].minor.yy105.kind = SHOW_KIND_ALL; yymsp[1].minor.yy105.dbName = nil_token; } break; case 295: /* table_kind_db_name_cond_opt ::= table_kind */ -{ yylhsminor.yy1005.kind = yymsp[0].minor.yy321; yylhsminor.yy1005.dbName = nil_token; } - yymsp[0].minor.yy1005 = yylhsminor.yy1005; +{ yylhsminor.yy105.kind = yymsp[0].minor.yy277; yylhsminor.yy105.dbName = nil_token; } + yymsp[0].minor.yy105 = yylhsminor.yy105; break; case 296: /* table_kind_db_name_cond_opt ::= db_name NK_DOT */ -{ yylhsminor.yy1005.kind = SHOW_KIND_ALL; yylhsminor.yy1005.dbName = yymsp[-1].minor.yy929; } - yymsp[-1].minor.yy1005 = yylhsminor.yy1005; +{ yylhsminor.yy105.kind = SHOW_KIND_ALL; yylhsminor.yy105.dbName = yymsp[-1].minor.yy621; } + yymsp[-1].minor.yy105 = yylhsminor.yy105; break; case 297: /* table_kind_db_name_cond_opt ::= table_kind db_name NK_DOT */ -{ yylhsminor.yy1005.kind = yymsp[-2].minor.yy321; yylhsminor.yy1005.dbName = yymsp[-1].minor.yy929; } - yymsp[-2].minor.yy1005 = yylhsminor.yy1005; +{ yylhsminor.yy105.kind = yymsp[-2].minor.yy277; yylhsminor.yy105.dbName = yymsp[-1].minor.yy621; } + yymsp[-2].minor.yy105 = yylhsminor.yy105; break; case 298: /* table_kind ::= NORMAL */ -{ yymsp[0].minor.yy321 = SHOW_KIND_TABLES_NORMAL; } +{ yymsp[0].minor.yy277 = SHOW_KIND_TABLES_NORMAL; } break; case 299: /* table_kind ::= CHILD */ -{ yymsp[0].minor.yy321 = SHOW_KIND_TABLES_CHILD; } +{ yymsp[0].minor.yy277 = SHOW_KIND_TABLES_CHILD; } break; case 300: /* db_name_cond_opt ::= */ case 305: /* from_db_opt ::= */ yytestcase(yyruleno==305); -{ yymsp[1].minor.yy360 = createDefaultDatabaseCondValue(pCxt); } +{ yymsp[1].minor.yy20 = createDefaultDatabaseCondValue(pCxt); } break; case 301: /* db_name_cond_opt ::= db_name NK_DOT */ -{ yylhsminor.yy360 = createIdentifierValueNode(pCxt, &yymsp[-1].minor.yy929); } - yymsp[-1].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createIdentifierValueNode(pCxt, &yymsp[-1].minor.yy621); } + yymsp[-1].minor.yy20 = yylhsminor.yy20; break; case 303: /* like_pattern_opt ::= LIKE NK_STRING */ -{ yymsp[-1].minor.yy360 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } +{ yymsp[-1].minor.yy20 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } break; case 304: /* table_name_cond ::= table_name */ -{ yylhsminor.yy360 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy929); } - yymsp[0].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy621); } + yymsp[0].minor.yy20 = yylhsminor.yy20; break; case 306: /* from_db_opt ::= FROM db_name */ -{ yymsp[-1].minor.yy360 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy929); } +{ yymsp[-1].minor.yy20 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy621); } break; case 310: /* tag_item ::= TBNAME */ -{ yylhsminor.yy360 = setProjectionAlias(pCxt, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL), &yymsp[0].minor.yy0); } - yymsp[0].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setProjectionAlias(pCxt, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL), &yymsp[0].minor.yy0); } + yymsp[0].minor.yy20 = yylhsminor.yy20; break; case 313: /* tag_item ::= column_name column_alias */ -{ yylhsminor.yy360 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-1].minor.yy929), &yymsp[0].minor.yy929); } - yymsp[-1].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-1].minor.yy621), &yymsp[0].minor.yy621); } + yymsp[-1].minor.yy20 = yylhsminor.yy20; break; case 314: /* tag_item ::= column_name AS column_alias */ -{ yylhsminor.yy360 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-2].minor.yy929), &yymsp[0].minor.yy929); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-2].minor.yy621), &yymsp[0].minor.yy621); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 315: /* db_kind_opt ::= */ -{ yymsp[1].minor.yy321 = SHOW_KIND_ALL; } +{ yymsp[1].minor.yy277 = SHOW_KIND_ALL; } break; case 316: /* db_kind_opt ::= USER */ -{ yymsp[0].minor.yy321 = SHOW_KIND_DATABASES_USER; } +{ yymsp[0].minor.yy277 = SHOW_KIND_DATABASES_USER; } break; case 317: /* db_kind_opt ::= SYSTEM */ -{ yymsp[0].minor.yy321 = SHOW_KIND_DATABASES_SYSTEM; } +{ yymsp[0].minor.yy277 = SHOW_KIND_DATABASES_SYSTEM; } break; case 318: /* cmd ::= CREATE SMA INDEX not_exists_opt col_name ON full_table_name index_options */ -{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_SMA, yymsp[-4].minor.yy345, yymsp[-3].minor.yy360, yymsp[-1].minor.yy360, NULL, yymsp[0].minor.yy360); } +{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_SMA, yymsp[-4].minor.yy709, yymsp[-3].minor.yy20, yymsp[-1].minor.yy20, NULL, yymsp[0].minor.yy20); } break; case 319: /* cmd ::= CREATE INDEX not_exists_opt col_name ON full_table_name NK_LP col_name_list NK_RP */ -{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_NORMAL, yymsp[-6].minor.yy345, yymsp[-5].minor.yy360, yymsp[-3].minor.yy360, yymsp[-1].minor.yy536, NULL); } +{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_NORMAL, yymsp[-6].minor.yy709, yymsp[-5].minor.yy20, yymsp[-3].minor.yy20, yymsp[-1].minor.yy1008, NULL); } break; case 320: /* cmd ::= DROP INDEX exists_opt full_index_name */ -{ pCxt->pRootNode = createDropIndexStmt(pCxt, yymsp[-1].minor.yy345, yymsp[0].minor.yy360); } +{ pCxt->pRootNode = createDropIndexStmt(pCxt, yymsp[-1].minor.yy709, yymsp[0].minor.yy20); } break; case 321: /* full_index_name ::= index_name */ -{ yylhsminor.yy360 = createRealTableNodeForIndexName(pCxt, NULL, &yymsp[0].minor.yy929); } - yymsp[0].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createRealTableNodeForIndexName(pCxt, NULL, &yymsp[0].minor.yy621); } + yymsp[0].minor.yy20 = yylhsminor.yy20; break; case 322: /* full_index_name ::= db_name NK_DOT index_name */ -{ yylhsminor.yy360 = createRealTableNodeForIndexName(pCxt, &yymsp[-2].minor.yy929, &yymsp[0].minor.yy929); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createRealTableNodeForIndexName(pCxt, &yymsp[-2].minor.yy621, &yymsp[0].minor.yy621); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 323: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ -{ yymsp[-9].minor.yy360 = createIndexOption(pCxt, yymsp[-7].minor.yy536, releaseRawExprNode(pCxt, yymsp[-3].minor.yy360), NULL, yymsp[-1].minor.yy360, yymsp[0].minor.yy360); } +{ yymsp[-9].minor.yy20 = createIndexOption(pCxt, yymsp[-7].minor.yy1008, releaseRawExprNode(pCxt, yymsp[-3].minor.yy20), NULL, yymsp[-1].minor.yy20, yymsp[0].minor.yy20); } break; case 324: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt */ -{ yymsp[-11].minor.yy360 = createIndexOption(pCxt, yymsp[-9].minor.yy536, releaseRawExprNode(pCxt, yymsp[-5].minor.yy360), releaseRawExprNode(pCxt, yymsp[-3].minor.yy360), yymsp[-1].minor.yy360, yymsp[0].minor.yy360); } +{ yymsp[-11].minor.yy20 = createIndexOption(pCxt, yymsp[-9].minor.yy1008, releaseRawExprNode(pCxt, yymsp[-5].minor.yy20), releaseRawExprNode(pCxt, yymsp[-3].minor.yy20), yymsp[-1].minor.yy20, yymsp[0].minor.yy20); } break; case 327: /* func ::= sma_func_name NK_LP expression_list NK_RP */ -{ yylhsminor.yy360 = createFunctionNode(pCxt, &yymsp[-3].minor.yy929, yymsp[-1].minor.yy536); } - yymsp[-3].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createFunctionNode(pCxt, &yymsp[-3].minor.yy621, yymsp[-1].minor.yy1008); } + yymsp[-3].minor.yy20 = yylhsminor.yy20; break; case 328: /* sma_func_name ::= function_name */ - case 553: /* alias_opt ::= table_alias */ yytestcase(yyruleno==553); -{ yylhsminor.yy929 = yymsp[0].minor.yy929; } - yymsp[0].minor.yy929 = yylhsminor.yy929; + case 568: /* alias_opt ::= table_alias */ yytestcase(yyruleno==568); +{ yylhsminor.yy621 = yymsp[0].minor.yy621; } + yymsp[0].minor.yy621 = yylhsminor.yy621; break; case 333: /* sma_stream_opt ::= */ case 378: /* stream_options ::= */ yytestcase(yyruleno==378); -{ yymsp[1].minor.yy360 = createStreamOptions(pCxt); } +{ yymsp[1].minor.yy20 = createStreamOptions(pCxt); } break; case 334: /* sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */ -{ ((SStreamOptions*)yymsp[-2].minor.yy360)->pWatermark = releaseRawExprNode(pCxt, yymsp[0].minor.yy360); yylhsminor.yy360 = yymsp[-2].minor.yy360; } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ ((SStreamOptions*)yymsp[-2].minor.yy20)->pWatermark = releaseRawExprNode(pCxt, yymsp[0].minor.yy20); yylhsminor.yy20 = yymsp[-2].minor.yy20; } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 335: /* sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */ -{ ((SStreamOptions*)yymsp[-2].minor.yy360)->pDelay = releaseRawExprNode(pCxt, yymsp[0].minor.yy360); yylhsminor.yy360 = yymsp[-2].minor.yy360; } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ ((SStreamOptions*)yymsp[-2].minor.yy20)->pDelay = releaseRawExprNode(pCxt, yymsp[0].minor.yy20); yylhsminor.yy20 = yymsp[-2].minor.yy20; } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 336: /* sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */ -{ ((SStreamOptions*)yymsp[-2].minor.yy360)->pDeleteMark = releaseRawExprNode(pCxt, yymsp[0].minor.yy360); yylhsminor.yy360 = yymsp[-2].minor.yy360; } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ ((SStreamOptions*)yymsp[-2].minor.yy20)->pDeleteMark = releaseRawExprNode(pCxt, yymsp[0].minor.yy20); yylhsminor.yy20 = yymsp[-2].minor.yy20; } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 337: /* with_meta ::= AS */ -{ yymsp[0].minor.yy580 = 0; } +{ yymsp[0].minor.yy252 = 0; } break; case 338: /* with_meta ::= WITH META AS */ -{ yymsp[-2].minor.yy580 = 1; } +{ yymsp[-2].minor.yy252 = 1; } break; case 339: /* with_meta ::= ONLY META AS */ -{ yymsp[-2].minor.yy580 = 2; } +{ yymsp[-2].minor.yy252 = 2; } break; case 340: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */ -{ pCxt->pRootNode = createCreateTopicStmtUseQuery(pCxt, yymsp[-3].minor.yy345, &yymsp[-2].minor.yy929, yymsp[0].minor.yy360); } +{ pCxt->pRootNode = createCreateTopicStmtUseQuery(pCxt, yymsp[-3].minor.yy709, &yymsp[-2].minor.yy621, yymsp[0].minor.yy20); } break; case 341: /* cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */ -{ pCxt->pRootNode = createCreateTopicStmtUseDb(pCxt, yymsp[-4].minor.yy345, &yymsp[-3].minor.yy929, &yymsp[0].minor.yy929, yymsp[-2].minor.yy580); } +{ pCxt->pRootNode = createCreateTopicStmtUseDb(pCxt, yymsp[-4].minor.yy709, &yymsp[-3].minor.yy621, &yymsp[0].minor.yy621, yymsp[-2].minor.yy252); } break; case 342: /* cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */ -{ pCxt->pRootNode = createCreateTopicStmtUseTable(pCxt, yymsp[-5].minor.yy345, &yymsp[-4].minor.yy929, yymsp[-1].minor.yy360, yymsp[-3].minor.yy580, yymsp[0].minor.yy360); } +{ pCxt->pRootNode = createCreateTopicStmtUseTable(pCxt, yymsp[-5].minor.yy709, &yymsp[-4].minor.yy621, yymsp[-1].minor.yy20, yymsp[-3].minor.yy252, yymsp[0].minor.yy20); } break; case 343: /* cmd ::= DROP TOPIC exists_opt topic_name */ -{ pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy345, &yymsp[0].minor.yy929); } +{ pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy709, &yymsp[0].minor.yy621); } break; case 344: /* cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ -{ pCxt->pRootNode = createDropCGroupStmt(pCxt, yymsp[-3].minor.yy345, &yymsp[-2].minor.yy929, &yymsp[0].minor.yy929); } +{ pCxt->pRootNode = createDropCGroupStmt(pCxt, yymsp[-3].minor.yy709, &yymsp[-2].minor.yy621, &yymsp[0].minor.yy621); } break; case 345: /* cmd ::= DESC full_table_name */ case 346: /* cmd ::= DESCRIBE full_table_name */ yytestcase(yyruleno==346); -{ pCxt->pRootNode = createDescribeStmt(pCxt, yymsp[0].minor.yy360); } +{ pCxt->pRootNode = createDescribeStmt(pCxt, yymsp[0].minor.yy20); } break; case 347: /* cmd ::= RESET QUERY CACHE */ { pCxt->pRootNode = createResetQueryCacheStmt(pCxt); } break; case 348: /* cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */ case 349: /* cmd ::= EXPLAIN analyze_opt explain_options insert_query */ yytestcase(yyruleno==349); -{ pCxt->pRootNode = createExplainStmt(pCxt, yymsp[-2].minor.yy345, yymsp[-1].minor.yy360, yymsp[0].minor.yy360); } +{ pCxt->pRootNode = createExplainStmt(pCxt, yymsp[-2].minor.yy709, yymsp[-1].minor.yy20, yymsp[0].minor.yy20); } break; case 352: /* explain_options ::= */ -{ yymsp[1].minor.yy360 = createDefaultExplainOptions(pCxt); } +{ yymsp[1].minor.yy20 = createDefaultExplainOptions(pCxt); } break; case 353: /* explain_options ::= explain_options VERBOSE NK_BOOL */ -{ yylhsminor.yy360 = setExplainVerbose(pCxt, yymsp[-2].minor.yy360, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setExplainVerbose(pCxt, yymsp[-2].minor.yy20, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 354: /* explain_options ::= explain_options RATIO NK_FLOAT */ -{ yylhsminor.yy360 = setExplainRatio(pCxt, yymsp[-2].minor.yy360, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setExplainRatio(pCxt, yymsp[-2].minor.yy20, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 355: /* cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */ -{ pCxt->pRootNode = createCreateFunctionStmt(pCxt, yymsp[-7].minor.yy345, yymsp[-9].minor.yy345, &yymsp[-6].minor.yy929, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy912, yymsp[-1].minor.yy580, &yymsp[0].minor.yy929, yymsp[-10].minor.yy345); } +{ pCxt->pRootNode = createCreateFunctionStmt(pCxt, yymsp[-7].minor.yy709, yymsp[-9].minor.yy709, &yymsp[-6].minor.yy621, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy324, yymsp[-1].minor.yy252, &yymsp[0].minor.yy621, yymsp[-10].minor.yy709); } break; case 356: /* cmd ::= DROP FUNCTION exists_opt function_name */ -{ pCxt->pRootNode = createDropFunctionStmt(pCxt, yymsp[-1].minor.yy345, &yymsp[0].minor.yy929); } +{ pCxt->pRootNode = createDropFunctionStmt(pCxt, yymsp[-1].minor.yy709, &yymsp[0].minor.yy621); } break; case 361: /* language_opt ::= */ case 400: /* on_vgroup_id ::= */ yytestcase(yyruleno==400); -{ yymsp[1].minor.yy929 = nil_token; } +{ yymsp[1].minor.yy621 = nil_token; } break; case 362: /* language_opt ::= LANGUAGE NK_STRING */ case 401: /* on_vgroup_id ::= ON NK_INTEGER */ yytestcase(yyruleno==401); -{ yymsp[-1].minor.yy929 = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy621 = yymsp[0].minor.yy0; } break; case 365: /* cmd ::= CREATE or_replace_opt VIEW full_view_name AS query_or_subquery */ -{ pCxt->pRootNode = createCreateViewStmt(pCxt, yymsp[-4].minor.yy345, yymsp[-2].minor.yy360, &yymsp[-1].minor.yy0, yymsp[0].minor.yy360); } +{ pCxt->pRootNode = createCreateViewStmt(pCxt, yymsp[-4].minor.yy709, yymsp[-2].minor.yy20, &yymsp[-1].minor.yy0, yymsp[0].minor.yy20); } break; case 366: /* cmd ::= DROP VIEW exists_opt full_view_name */ -{ pCxt->pRootNode = createDropViewStmt(pCxt, yymsp[-1].minor.yy345, yymsp[0].minor.yy360); } +{ pCxt->pRootNode = createDropViewStmt(pCxt, yymsp[-1].minor.yy709, yymsp[0].minor.yy20); } break; case 367: /* full_view_name ::= view_name */ -{ yylhsminor.yy360 = createViewNode(pCxt, NULL, &yymsp[0].minor.yy929); } - yymsp[0].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createViewNode(pCxt, NULL, &yymsp[0].minor.yy621); } + yymsp[0].minor.yy20 = yylhsminor.yy20; break; case 368: /* full_view_name ::= db_name NK_DOT view_name */ -{ yylhsminor.yy360 = createViewNode(pCxt, &yymsp[-2].minor.yy929, &yymsp[0].minor.yy929); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = createViewNode(pCxt, &yymsp[-2].minor.yy621, &yymsp[0].minor.yy621); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 369: /* cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery */ -{ pCxt->pRootNode = createCreateStreamStmt(pCxt, yymsp[-9].minor.yy345, &yymsp[-8].minor.yy929, yymsp[-5].minor.yy360, yymsp[-7].minor.yy360, yymsp[-3].minor.yy536, yymsp[-2].minor.yy360, yymsp[0].minor.yy360, yymsp[-4].minor.yy536); } +{ pCxt->pRootNode = createCreateStreamStmt(pCxt, yymsp[-9].minor.yy709, &yymsp[-8].minor.yy621, yymsp[-5].minor.yy20, yymsp[-7].minor.yy20, yymsp[-3].minor.yy1008, yymsp[-2].minor.yy20, yymsp[0].minor.yy20, yymsp[-4].minor.yy1008); } break; case 370: /* cmd ::= DROP STREAM exists_opt stream_name */ -{ pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy345, &yymsp[0].minor.yy929); } +{ pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy709, &yymsp[0].minor.yy621); } break; case 371: /* cmd ::= PAUSE STREAM exists_opt stream_name */ -{ pCxt->pRootNode = createPauseStreamStmt(pCxt, yymsp[-1].minor.yy345, &yymsp[0].minor.yy929); } +{ pCxt->pRootNode = createPauseStreamStmt(pCxt, yymsp[-1].minor.yy709, &yymsp[0].minor.yy621); } break; case 372: /* cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */ -{ pCxt->pRootNode = createResumeStreamStmt(pCxt, yymsp[-2].minor.yy345, yymsp[-1].minor.yy345, &yymsp[0].minor.yy929); } +{ pCxt->pRootNode = createResumeStreamStmt(pCxt, yymsp[-2].minor.yy709, yymsp[-1].minor.yy709, &yymsp[0].minor.yy621); } break; case 379: /* stream_options ::= stream_options TRIGGER AT_ONCE */ case 380: /* stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ yytestcase(yyruleno==380); -{ yylhsminor.yy360 = setStreamOptions(pCxt, yymsp[-2].minor.yy360, SOPT_TRIGGER_TYPE_SET, &yymsp[0].minor.yy0, NULL); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setStreamOptions(pCxt, yymsp[-2].minor.yy20, SOPT_TRIGGER_TYPE_SET, &yymsp[0].minor.yy0, NULL); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 381: /* stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ -{ yylhsminor.yy360 = setStreamOptions(pCxt, yymsp[-3].minor.yy360, SOPT_TRIGGER_TYPE_SET, &yymsp[-1].minor.yy0, releaseRawExprNode(pCxt, yymsp[0].minor.yy360)); } - yymsp[-3].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setStreamOptions(pCxt, yymsp[-3].minor.yy20, SOPT_TRIGGER_TYPE_SET, &yymsp[-1].minor.yy0, releaseRawExprNode(pCxt, yymsp[0].minor.yy20)); } + yymsp[-3].minor.yy20 = yylhsminor.yy20; break; case 382: /* stream_options ::= stream_options WATERMARK duration_literal */ -{ yylhsminor.yy360 = setStreamOptions(pCxt, yymsp[-2].minor.yy360, SOPT_WATERMARK_SET, NULL, releaseRawExprNode(pCxt, yymsp[0].minor.yy360)); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setStreamOptions(pCxt, yymsp[-2].minor.yy20, SOPT_WATERMARK_SET, NULL, releaseRawExprNode(pCxt, yymsp[0].minor.yy20)); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 383: /* stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ -{ yylhsminor.yy360 = setStreamOptions(pCxt, yymsp[-3].minor.yy360, SOPT_IGNORE_EXPIRED_SET, &yymsp[0].minor.yy0, NULL); } - yymsp[-3].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setStreamOptions(pCxt, yymsp[-3].minor.yy20, SOPT_IGNORE_EXPIRED_SET, &yymsp[0].minor.yy0, NULL); } + yymsp[-3].minor.yy20 = yylhsminor.yy20; break; case 384: /* stream_options ::= stream_options FILL_HISTORY NK_INTEGER */ -{ yylhsminor.yy360 = setStreamOptions(pCxt, yymsp[-2].minor.yy360, SOPT_FILL_HISTORY_SET, &yymsp[0].minor.yy0, NULL); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setStreamOptions(pCxt, yymsp[-2].minor.yy20, SOPT_FILL_HISTORY_SET, &yymsp[0].minor.yy0, NULL); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 385: /* stream_options ::= stream_options DELETE_MARK duration_literal */ -{ yylhsminor.yy360 = setStreamOptions(pCxt, yymsp[-2].minor.yy360, SOPT_DELETE_MARK_SET, NULL, releaseRawExprNode(pCxt, yymsp[0].minor.yy360)); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setStreamOptions(pCxt, yymsp[-2].minor.yy20, SOPT_DELETE_MARK_SET, NULL, releaseRawExprNode(pCxt, yymsp[0].minor.yy20)); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; case 386: /* stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */ -{ yylhsminor.yy360 = setStreamOptions(pCxt, yymsp[-3].minor.yy360, SOPT_IGNORE_UPDATE_SET, &yymsp[0].minor.yy0, NULL); } - yymsp[-3].minor.yy360 = yylhsminor.yy360; +{ yylhsminor.yy20 = setStreamOptions(pCxt, yymsp[-3].minor.yy20, SOPT_IGNORE_UPDATE_SET, &yymsp[0].minor.yy0, NULL); } + yymsp[-3].minor.yy20 = yylhsminor.yy20; break; case 388: /* subtable_opt ::= SUBTABLE NK_LP expression NK_RP */ - case 593: /* sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP */ yytestcase(yyruleno==593); - case 617: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==617); -{ yymsp[-3].minor.yy360 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy360); } + case 608: /* sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP */ yytestcase(yyruleno==608); + case 632: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==632); +{ yymsp[-3].minor.yy20 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy20); } break; case 391: /* cmd ::= KILL CONNECTION NK_INTEGER */ { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_CONNECTION_STMT, &yymsp[0].minor.yy0); } @@ -6261,604 +6047,657 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createBalanceVgroupStmt(pCxt); } break; case 396: /* cmd ::= BALANCE VGROUP LEADER on_vgroup_id */ -{ pCxt->pRootNode = createBalanceVgroupLeaderStmt(pCxt, &yymsp[0].minor.yy929); } +{ pCxt->pRootNode = createBalanceVgroupLeaderStmt(pCxt, &yymsp[0].minor.yy621); } break; case 397: /* cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ { pCxt->pRootNode = createMergeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } break; case 398: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ -{ pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy536); } +{ pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy1008); } break; case 399: /* cmd ::= SPLIT VGROUP NK_INTEGER */ { pCxt->pRootNode = createSplitVgroupStmt(pCxt, &yymsp[0].minor.yy0); } break; case 402: /* dnode_list ::= DNODE NK_INTEGER */ -{ yymsp[-1].minor.yy536 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } +{ yymsp[-1].minor.yy1008 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } break; case 404: /* cmd ::= DELETE FROM full_table_name where_clause_opt */ -{ pCxt->pRootNode = createDeleteStmt(pCxt, yymsp[-1].minor.yy360, yymsp[0].minor.yy360); } +{ pCxt->pRootNode = createDeleteStmt(pCxt, yymsp[-1].minor.yy20, yymsp[0].minor.yy20); } break; case 407: /* insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */ -{ yymsp[-6].minor.yy360 = createInsertStmt(pCxt, yymsp[-4].minor.yy360, yymsp[-2].minor.yy536, yymsp[0].minor.yy360); } +{ yymsp[-6].minor.yy20 = createInsertStmt(pCxt, yymsp[-4].minor.yy20, yymsp[-2].minor.yy1008, yymsp[0].minor.yy20); } break; case 408: /* insert_query ::= INSERT INTO full_table_name query_or_subquery */ -{ yymsp[-3].minor.yy360 = createInsertStmt(pCxt, yymsp[-1].minor.yy360, NULL, yymsp[0].minor.yy360); } +{ yymsp[-3].minor.yy20 = createInsertStmt(pCxt, yymsp[-1].minor.yy20, NULL, yymsp[0].minor.yy20); } break; - case 409: /* literal ::= NK_INTEGER */ -{ yylhsminor.yy360 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy360 = yylhsminor.yy360; + case 409: /* tags_literal ::= NK_INTEGER */ +{ yylhsminor.yy20 = createRawValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0, NULL); } + yymsp[0].minor.yy20 = yylhsminor.yy20; break; - case 410: /* literal ::= NK_FLOAT */ -{ yylhsminor.yy360 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy360 = yylhsminor.yy360; - break; - case 411: /* literal ::= NK_STRING */ -{ yylhsminor.yy360 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy360 = yylhsminor.yy360; - break; - case 412: /* literal ::= NK_BOOL */ -{ yylhsminor.yy360 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy360 = yylhsminor.yy360; - break; - case 413: /* literal ::= TIMESTAMP NK_STRING */ -{ yylhsminor.yy360 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); } - yymsp[-1].minor.yy360 = yylhsminor.yy360; - break; - case 414: /* literal ::= duration_literal */ - case 424: /* signed_literal ::= signed */ yytestcase(yyruleno==424); - case 447: /* expr_or_subquery ::= expression */ yytestcase(yyruleno==447); - case 448: /* expression ::= literal */ yytestcase(yyruleno==448); - case 450: /* expression ::= column_reference */ yytestcase(yyruleno==450); - case 451: /* expression ::= function_expression */ yytestcase(yyruleno==451); - case 452: /* expression ::= case_when_expression */ yytestcase(yyruleno==452); - case 485: /* function_expression ::= literal_func */ yytestcase(yyruleno==485); - case 534: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==534); - case 538: /* boolean_primary ::= predicate */ yytestcase(yyruleno==538); - case 540: /* common_expression ::= expr_or_subquery */ yytestcase(yyruleno==540); - case 541: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==541); - case 544: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==544); - case 546: /* table_reference ::= table_primary */ yytestcase(yyruleno==546); - case 547: /* table_reference ::= joined_table */ yytestcase(yyruleno==547); - case 551: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==551); - case 619: /* query_simple ::= query_specification */ yytestcase(yyruleno==619); - case 620: /* query_simple ::= union_query_expression */ yytestcase(yyruleno==620); - case 623: /* query_simple_or_subquery ::= query_simple */ yytestcase(yyruleno==623); - case 625: /* query_or_subquery ::= query_expression */ yytestcase(yyruleno==625); -{ yylhsminor.yy360 = yymsp[0].minor.yy360; } - yymsp[0].minor.yy360 = yylhsminor.yy360; - break; - case 415: /* literal ::= NULL */ -{ yylhsminor.yy360 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy360 = yylhsminor.yy360; - break; - case 416: /* literal ::= NK_QUESTION */ -{ yylhsminor.yy360 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy360 = yylhsminor.yy360; - break; - case 417: /* duration_literal ::= NK_VARIABLE */ - case 594: /* interval_sliding_duration_literal ::= NK_VARIABLE */ yytestcase(yyruleno==594); - case 595: /* interval_sliding_duration_literal ::= NK_STRING */ yytestcase(yyruleno==595); - case 596: /* interval_sliding_duration_literal ::= NK_INTEGER */ yytestcase(yyruleno==596); -{ yylhsminor.yy360 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy360 = yylhsminor.yy360; - break; - case 418: /* signed ::= NK_INTEGER */ -{ yylhsminor.yy360 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy360 = yylhsminor.yy360; - break; - case 419: /* signed ::= NK_PLUS NK_INTEGER */ -{ yymsp[-1].minor.yy360 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } - break; - case 420: /* signed ::= NK_MINUS NK_INTEGER */ + case 410: /* tags_literal ::= NK_PLUS NK_INTEGER */ + case 411: /* tags_literal ::= NK_MINUS NK_INTEGER */ yytestcase(yyruleno==411); { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy360 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &t); + yylhsminor.yy20 = createRawValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &t, NULL); } - yymsp[-1].minor.yy360 = yylhsminor.yy360; + yymsp[-1].minor.yy20 = yylhsminor.yy20; break; - case 421: /* signed ::= NK_FLOAT */ -{ yylhsminor.yy360 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy360 = yylhsminor.yy360; + case 412: /* tags_literal ::= NK_FLOAT */ +{ yylhsminor.yy20 = createRawValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0, NULL); } + yymsp[0].minor.yy20 = yylhsminor.yy20; break; - case 422: /* signed ::= NK_PLUS NK_FLOAT */ -{ yymsp[-1].minor.yy360 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } - break; - case 423: /* signed ::= NK_MINUS NK_FLOAT */ + case 413: /* tags_literal ::= NK_PLUS NK_FLOAT */ + case 414: /* tags_literal ::= NK_MINUS NK_FLOAT */ yytestcase(yyruleno==414); { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy360 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t); + yylhsminor.yy20 = createRawValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t, NULL); } - yymsp[-1].minor.yy360 = yylhsminor.yy360; + yymsp[-1].minor.yy20 = yylhsminor.yy20; break; - case 425: /* signed_literal ::= NK_STRING */ -{ yylhsminor.yy360 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy360 = yylhsminor.yy360; + case 415: /* tags_literal ::= NK_STRING */ +{ yylhsminor.yy20 = createRawValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0, NULL); } + yymsp[0].minor.yy20 = yylhsminor.yy20; break; - case 426: /* signed_literal ::= NK_BOOL */ -{ yylhsminor.yy360 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy360 = yylhsminor.yy360; + case 416: /* tags_literal ::= NK_BOOL */ +{ yylhsminor.yy20 = createRawValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0, NULL); } + yymsp[0].minor.yy20 = yylhsminor.yy20; break; - case 427: /* signed_literal ::= TIMESTAMP NK_STRING */ -{ yymsp[-1].minor.yy360 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } + case 417: /* tags_literal ::= NULL */ +{ yylhsminor.yy20 = createRawValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0, NULL); } + yymsp[0].minor.yy20 = yylhsminor.yy20; break; - case 428: /* signed_literal ::= duration_literal */ - case 430: /* signed_literal ::= literal_func */ yytestcase(yyruleno==430); - case 505: /* star_func_para ::= expr_or_subquery */ yytestcase(yyruleno==505); - case 571: /* select_item ::= common_expression */ yytestcase(yyruleno==571); - case 581: /* partition_item ::= expr_or_subquery */ yytestcase(yyruleno==581); - case 624: /* query_simple_or_subquery ::= subquery */ yytestcase(yyruleno==624); - case 626: /* query_or_subquery ::= subquery */ yytestcase(yyruleno==626); - case 639: /* search_condition ::= common_expression */ yytestcase(yyruleno==639); -{ yylhsminor.yy360 = releaseRawExprNode(pCxt, yymsp[0].minor.yy360); } - yymsp[0].minor.yy360 = yylhsminor.yy360; + case 418: /* tags_literal ::= literal_func */ +{ yylhsminor.yy20 = createRawValueNode(pCxt, TSDB_DATA_TYPE_BINARY, NULL, yymsp[0].minor.yy20); } + yymsp[0].minor.yy20 = yylhsminor.yy20; break; - case 429: /* signed_literal ::= NULL */ -{ yylhsminor.yy360 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy360 = yylhsminor.yy360; - break; - case 431: /* signed_literal ::= NK_QUESTION */ -{ yylhsminor.yy360 = createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy360 = yylhsminor.yy360; - break; - case 449: /* expression ::= pseudo_column */ -{ yylhsminor.yy360 = yymsp[0].minor.yy360; setRawExprNodeIsPseudoColumn(pCxt, yylhsminor.yy360, true); } - yymsp[0].minor.yy360 = yylhsminor.yy360; - break; - case 453: /* expression ::= NK_LP expression NK_RP */ - case 539: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==539); - case 638: /* subquery ::= NK_LP subquery NK_RP */ yytestcase(yyruleno==638); -{ yylhsminor.yy360 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy360)); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; - break; - case 454: /* expression ::= NK_PLUS expr_or_subquery */ + case 419: /* tags_literal ::= literal_func NK_PLUS duration_literal */ + case 420: /* tags_literal ::= literal_func NK_MINUS duration_literal */ yytestcase(yyruleno==420); { - SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy360); - yylhsminor.yy360 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy360)); + SToken l = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy20); + SToken r = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy20); + l.n = (r.z + r.n) - l.z; + yylhsminor.yy20 = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, yymsp[-2].minor.yy20, yymsp[0].minor.yy20); } - yymsp[-1].minor.yy360 = yylhsminor.yy360; + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; - case 455: /* expression ::= NK_MINUS expr_or_subquery */ + case 423: /* literal ::= NK_INTEGER */ +{ yylhsminor.yy20 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy20 = yylhsminor.yy20; + break; + case 424: /* literal ::= NK_FLOAT */ +{ yylhsminor.yy20 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy20 = yylhsminor.yy20; + break; + case 425: /* literal ::= NK_STRING */ +{ yylhsminor.yy20 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy20 = yylhsminor.yy20; + break; + case 426: /* literal ::= NK_BOOL */ +{ yylhsminor.yy20 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy20 = yylhsminor.yy20; + break; + case 427: /* literal ::= TIMESTAMP NK_STRING */ +{ yylhsminor.yy20 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); } + yymsp[-1].minor.yy20 = yylhsminor.yy20; + break; + case 428: /* literal ::= duration_literal */ + case 438: /* signed_literal ::= signed */ yytestcase(yyruleno==438); + case 461: /* expr_or_subquery ::= expression */ yytestcase(yyruleno==461); + case 462: /* expression ::= literal */ yytestcase(yyruleno==462); + case 464: /* expression ::= column_reference */ yytestcase(yyruleno==464); + case 465: /* expression ::= function_expression */ yytestcase(yyruleno==465); + case 466: /* expression ::= case_when_expression */ yytestcase(yyruleno==466); + case 499: /* function_expression ::= literal_func */ yytestcase(yyruleno==499); + case 549: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==549); + case 553: /* boolean_primary ::= predicate */ yytestcase(yyruleno==553); + case 555: /* common_expression ::= expr_or_subquery */ yytestcase(yyruleno==555); + case 556: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==556); + case 559: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==559); + case 561: /* table_reference ::= table_primary */ yytestcase(yyruleno==561); + case 562: /* table_reference ::= joined_table */ yytestcase(yyruleno==562); + case 566: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==566); + case 634: /* query_simple ::= query_specification */ yytestcase(yyruleno==634); + case 635: /* query_simple ::= union_query_expression */ yytestcase(yyruleno==635); + case 638: /* query_simple_or_subquery ::= query_simple */ yytestcase(yyruleno==638); + case 640: /* query_or_subquery ::= query_expression */ yytestcase(yyruleno==640); +{ yylhsminor.yy20 = yymsp[0].minor.yy20; } + yymsp[0].minor.yy20 = yylhsminor.yy20; + break; + case 429: /* literal ::= NULL */ +{ yylhsminor.yy20 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy20 = yylhsminor.yy20; + break; + case 430: /* literal ::= NK_QUESTION */ +{ yylhsminor.yy20 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy20 = yylhsminor.yy20; + break; + case 431: /* duration_literal ::= NK_VARIABLE */ + case 609: /* interval_sliding_duration_literal ::= NK_VARIABLE */ yytestcase(yyruleno==609); + case 610: /* interval_sliding_duration_literal ::= NK_STRING */ yytestcase(yyruleno==610); + case 611: /* interval_sliding_duration_literal ::= NK_INTEGER */ yytestcase(yyruleno==611); +{ yylhsminor.yy20 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy20 = yylhsminor.yy20; + break; + case 432: /* signed ::= NK_INTEGER */ +{ yylhsminor.yy20 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy20 = yylhsminor.yy20; + break; + case 433: /* signed ::= NK_PLUS NK_INTEGER */ +{ yymsp[-1].minor.yy20 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } + break; + case 434: /* signed ::= NK_MINUS NK_INTEGER */ { - SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy360); - yylhsminor.yy360 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy360), NULL)); + SToken t = yymsp[-1].minor.yy0; + t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; + yylhsminor.yy20 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &t); } - yymsp[-1].minor.yy360 = yylhsminor.yy360; + yymsp[-1].minor.yy20 = yylhsminor.yy20; break; - case 456: /* expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ + case 435: /* signed ::= NK_FLOAT */ +{ yylhsminor.yy20 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy20 = yylhsminor.yy20; + break; + case 436: /* signed ::= NK_PLUS NK_FLOAT */ +{ yymsp[-1].minor.yy20 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } + break; + case 437: /* signed ::= NK_MINUS NK_FLOAT */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy360); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy360); - yylhsminor.yy360 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_ADD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy360), releaseRawExprNode(pCxt, yymsp[0].minor.yy360))); + SToken t = yymsp[-1].minor.yy0; + t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; + yylhsminor.yy20 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; + yymsp[-1].minor.yy20 = yylhsminor.yy20; break; - case 457: /* expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ + case 439: /* signed_literal ::= NK_STRING */ +{ yylhsminor.yy20 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy20 = yylhsminor.yy20; + break; + case 440: /* signed_literal ::= NK_BOOL */ +{ yylhsminor.yy20 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy20 = yylhsminor.yy20; + break; + case 441: /* signed_literal ::= TIMESTAMP NK_STRING */ +{ yymsp[-1].minor.yy20 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } + break; + case 442: /* signed_literal ::= duration_literal */ + case 444: /* signed_literal ::= literal_func */ yytestcase(yyruleno==444); + case 520: /* star_func_para ::= expr_or_subquery */ yytestcase(yyruleno==520); + case 586: /* select_item ::= common_expression */ yytestcase(yyruleno==586); + case 596: /* partition_item ::= expr_or_subquery */ yytestcase(yyruleno==596); + case 639: /* query_simple_or_subquery ::= subquery */ yytestcase(yyruleno==639); + case 641: /* query_or_subquery ::= subquery */ yytestcase(yyruleno==641); + case 654: /* search_condition ::= common_expression */ yytestcase(yyruleno==654); +{ yylhsminor.yy20 = releaseRawExprNode(pCxt, yymsp[0].minor.yy20); } + yymsp[0].minor.yy20 = yylhsminor.yy20; + break; + case 443: /* signed_literal ::= NULL */ +{ yylhsminor.yy20 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy20 = yylhsminor.yy20; + break; + case 445: /* signed_literal ::= NK_QUESTION */ +{ yylhsminor.yy20 = createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy20 = yylhsminor.yy20; + break; + case 463: /* expression ::= pseudo_column */ +{ yylhsminor.yy20 = yymsp[0].minor.yy20; setRawExprNodeIsPseudoColumn(pCxt, yylhsminor.yy20, true); } + yymsp[0].minor.yy20 = yylhsminor.yy20; + break; + case 467: /* expression ::= NK_LP expression NK_RP */ + case 554: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==554); + case 653: /* subquery ::= NK_LP subquery NK_RP */ yytestcase(yyruleno==653); +{ yylhsminor.yy20 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy20)); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; + break; + case 468: /* expression ::= NK_PLUS expr_or_subquery */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy360); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy360); - yylhsminor.yy360 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_SUB, releaseRawExprNode(pCxt, yymsp[-2].minor.yy360), releaseRawExprNode(pCxt, yymsp[0].minor.yy360))); + SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy20); + yylhsminor.yy20 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy20)); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; + yymsp[-1].minor.yy20 = yylhsminor.yy20; break; - case 458: /* expression ::= expr_or_subquery NK_STAR expr_or_subquery */ + case 469: /* expression ::= NK_MINUS expr_or_subquery */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy360); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy360); - yylhsminor.yy360 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MULTI, releaseRawExprNode(pCxt, yymsp[-2].minor.yy360), releaseRawExprNode(pCxt, yymsp[0].minor.yy360))); + SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy20); + yylhsminor.yy20 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy20), NULL)); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; + yymsp[-1].minor.yy20 = yylhsminor.yy20; break; - case 459: /* expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ + case 470: /* expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy360); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy360); - yylhsminor.yy360 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_DIV, releaseRawExprNode(pCxt, yymsp[-2].minor.yy360), releaseRawExprNode(pCxt, yymsp[0].minor.yy360))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy20); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy20); + yylhsminor.yy20 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_ADD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy20), releaseRawExprNode(pCxt, yymsp[0].minor.yy20))); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; - case 460: /* expression ::= expr_or_subquery NK_REM expr_or_subquery */ + case 471: /* expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy360); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy360); - yylhsminor.yy360 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_REM, releaseRawExprNode(pCxt, yymsp[-2].minor.yy360), releaseRawExprNode(pCxt, yymsp[0].minor.yy360))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy20); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy20); + yylhsminor.yy20 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_SUB, releaseRawExprNode(pCxt, yymsp[-2].minor.yy20), releaseRawExprNode(pCxt, yymsp[0].minor.yy20))); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; - case 461: /* expression ::= column_reference NK_ARROW NK_STRING */ + case 472: /* expression ::= expr_or_subquery NK_STAR expr_or_subquery */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy360); - yylhsminor.yy360 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy360), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy20); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy20); + yylhsminor.yy20 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MULTI, releaseRawExprNode(pCxt, yymsp[-2].minor.yy20), releaseRawExprNode(pCxt, yymsp[0].minor.yy20))); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; - case 462: /* expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ + case 473: /* expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy360); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy360); - yylhsminor.yy360 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy360), releaseRawExprNode(pCxt, yymsp[0].minor.yy360))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy20); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy20); + yylhsminor.yy20 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_DIV, releaseRawExprNode(pCxt, yymsp[-2].minor.yy20), releaseRawExprNode(pCxt, yymsp[0].minor.yy20))); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; - case 463: /* expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ + case 474: /* expression ::= expr_or_subquery NK_REM expr_or_subquery */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy360); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy360); - yylhsminor.yy360 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy360), releaseRawExprNode(pCxt, yymsp[0].minor.yy360))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy20); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy20); + yylhsminor.yy20 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_REM, releaseRawExprNode(pCxt, yymsp[-2].minor.yy20), releaseRawExprNode(pCxt, yymsp[0].minor.yy20))); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; - case 466: /* column_reference ::= column_name */ -{ yylhsminor.yy360 = createRawExprNode(pCxt, &yymsp[0].minor.yy929, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy929)); } - yymsp[0].minor.yy360 = yylhsminor.yy360; - break; - case 467: /* column_reference ::= table_name NK_DOT column_name */ -{ yylhsminor.yy360 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy929, &yymsp[0].minor.yy929, createColumnNode(pCxt, &yymsp[-2].minor.yy929, &yymsp[0].minor.yy929)); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; - break; - case 468: /* column_reference ::= NK_ALIAS */ -{ yylhsminor.yy360 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy360 = yylhsminor.yy360; - break; - case 469: /* column_reference ::= table_name NK_DOT NK_ALIAS */ -{ yylhsminor.yy360 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy929, &yymsp[0].minor.yy0, createColumnNode(pCxt, &yymsp[-2].minor.yy929, &yymsp[0].minor.yy0)); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; - break; - case 470: /* pseudo_column ::= ROWTS */ - case 471: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==471); - case 473: /* pseudo_column ::= QSTART */ yytestcase(yyruleno==473); - case 474: /* pseudo_column ::= QEND */ yytestcase(yyruleno==474); - case 475: /* pseudo_column ::= QDURATION */ yytestcase(yyruleno==475); - case 476: /* pseudo_column ::= WSTART */ yytestcase(yyruleno==476); - case 477: /* pseudo_column ::= WEND */ yytestcase(yyruleno==477); - case 478: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==478); - case 479: /* pseudo_column ::= IROWTS */ yytestcase(yyruleno==479); - case 480: /* pseudo_column ::= ISFILLED */ yytestcase(yyruleno==480); - case 481: /* pseudo_column ::= QTAGS */ yytestcase(yyruleno==481); - case 487: /* literal_func ::= NOW */ yytestcase(yyruleno==487); -{ yylhsminor.yy360 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); } - yymsp[0].minor.yy360 = yylhsminor.yy360; - break; - case 472: /* pseudo_column ::= table_name NK_DOT TBNAME */ -{ yylhsminor.yy360 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy929, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy929)))); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; - break; - case 482: /* function_expression ::= function_name NK_LP expression_list NK_RP */ - case 483: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==483); -{ yylhsminor.yy360 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy929, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy929, yymsp[-1].minor.yy536)); } - yymsp[-3].minor.yy360 = yylhsminor.yy360; - break; - case 484: /* function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ -{ yylhsminor.yy360 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy360), yymsp[-1].minor.yy912)); } - yymsp[-5].minor.yy360 = yylhsminor.yy360; - break; - case 486: /* literal_func ::= noarg_func NK_LP NK_RP */ -{ yylhsminor.yy360 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy929, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy929, NULL)); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; - break; - case 501: /* star_func_para_list ::= NK_STAR */ -{ yylhsminor.yy536 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy536 = yylhsminor.yy536; - break; - case 506: /* star_func_para ::= table_name NK_DOT NK_STAR */ - case 574: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==574); -{ yylhsminor.yy360 = createColumnNode(pCxt, &yymsp[-2].minor.yy929, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; - break; - case 507: /* case_when_expression ::= CASE when_then_list case_when_else_opt END */ -{ yylhsminor.yy360 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, NULL, yymsp[-2].minor.yy536, yymsp[-1].minor.yy360)); } - yymsp[-3].minor.yy360 = yylhsminor.yy360; - break; - case 508: /* case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ -{ yylhsminor.yy360 = createRawExprNodeExt(pCxt, &yymsp[-4].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy360), yymsp[-2].minor.yy536, yymsp[-1].minor.yy360)); } - yymsp[-4].minor.yy360 = yylhsminor.yy360; - break; - case 511: /* when_then_expr ::= WHEN common_expression THEN common_expression */ -{ yymsp[-3].minor.yy360 = createWhenThenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy360), releaseRawExprNode(pCxt, yymsp[0].minor.yy360)); } - break; - case 513: /* case_when_else_opt ::= ELSE common_expression */ -{ yymsp[-1].minor.yy360 = releaseRawExprNode(pCxt, yymsp[0].minor.yy360); } - break; - case 514: /* predicate ::= expr_or_subquery compare_op expr_or_subquery */ - case 519: /* predicate ::= expr_or_subquery in_op in_predicate_value */ yytestcase(yyruleno==519); + case 475: /* expression ::= column_reference NK_ARROW NK_STRING */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy360); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy360); - yylhsminor.yy360 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, yymsp[-1].minor.yy252, releaseRawExprNode(pCxt, yymsp[-2].minor.yy360), releaseRawExprNode(pCxt, yymsp[0].minor.yy360))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy20); + yylhsminor.yy20 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy20), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0))); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; - case 515: /* predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ + case 476: /* expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy360); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy360); - yylhsminor.yy360 = createRawExprNodeExt(pCxt, &s, &e, createBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-4].minor.yy360), releaseRawExprNode(pCxt, yymsp[-2].minor.yy360), releaseRawExprNode(pCxt, yymsp[0].minor.yy360))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy20); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy20); + yylhsminor.yy20 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy20), releaseRawExprNode(pCxt, yymsp[0].minor.yy20))); } - yymsp[-4].minor.yy360 = yylhsminor.yy360; + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; - case 516: /* predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ + case 477: /* expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy360); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy360); - yylhsminor.yy360 = createRawExprNodeExt(pCxt, &s, &e, createNotBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy360), releaseRawExprNode(pCxt, yymsp[-2].minor.yy360), releaseRawExprNode(pCxt, yymsp[0].minor.yy360))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy20); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy20); + yylhsminor.yy20 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy20), releaseRawExprNode(pCxt, yymsp[0].minor.yy20))); } - yymsp[-5].minor.yy360 = yylhsminor.yy360; + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; - case 517: /* predicate ::= expr_or_subquery IS NULL */ + case 480: /* column_reference ::= column_name */ +{ yylhsminor.yy20 = createRawExprNode(pCxt, &yymsp[0].minor.yy621, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy621)); } + yymsp[0].minor.yy20 = yylhsminor.yy20; + break; + case 481: /* column_reference ::= table_name NK_DOT column_name */ +{ yylhsminor.yy20 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy621, &yymsp[0].minor.yy621, createColumnNode(pCxt, &yymsp[-2].minor.yy621, &yymsp[0].minor.yy621)); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; + break; + case 482: /* column_reference ::= NK_ALIAS */ +{ yylhsminor.yy20 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy20 = yylhsminor.yy20; + break; + case 483: /* column_reference ::= table_name NK_DOT NK_ALIAS */ +{ yylhsminor.yy20 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy621, &yymsp[0].minor.yy0, createColumnNode(pCxt, &yymsp[-2].minor.yy621, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; + break; + case 484: /* pseudo_column ::= ROWTS */ + case 485: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==485); + case 487: /* pseudo_column ::= QSTART */ yytestcase(yyruleno==487); + case 488: /* pseudo_column ::= QEND */ yytestcase(yyruleno==488); + case 489: /* pseudo_column ::= QDURATION */ yytestcase(yyruleno==489); + case 490: /* pseudo_column ::= WSTART */ yytestcase(yyruleno==490); + case 491: /* pseudo_column ::= WEND */ yytestcase(yyruleno==491); + case 492: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==492); + case 493: /* pseudo_column ::= IROWTS */ yytestcase(yyruleno==493); + case 494: /* pseudo_column ::= ISFILLED */ yytestcase(yyruleno==494); + case 495: /* pseudo_column ::= QTAGS */ yytestcase(yyruleno==495); + case 501: /* literal_func ::= NOW */ yytestcase(yyruleno==501); + case 502: /* literal_func ::= TODAY */ yytestcase(yyruleno==502); +{ yylhsminor.yy20 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); } + yymsp[0].minor.yy20 = yylhsminor.yy20; + break; + case 486: /* pseudo_column ::= table_name NK_DOT TBNAME */ +{ yylhsminor.yy20 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy621, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy621)))); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; + break; + case 496: /* function_expression ::= function_name NK_LP expression_list NK_RP */ + case 497: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==497); +{ yylhsminor.yy20 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy621, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy621, yymsp[-1].minor.yy1008)); } + yymsp[-3].minor.yy20 = yylhsminor.yy20; + break; + case 498: /* function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ +{ yylhsminor.yy20 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy20), yymsp[-1].minor.yy324)); } + yymsp[-5].minor.yy20 = yylhsminor.yy20; + break; + case 500: /* literal_func ::= noarg_func NK_LP NK_RP */ +{ yylhsminor.yy20 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy621, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy621, NULL)); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; + break; + case 516: /* star_func_para_list ::= NK_STAR */ +{ yylhsminor.yy1008 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy1008 = yylhsminor.yy1008; + break; + case 521: /* star_func_para ::= table_name NK_DOT NK_STAR */ + case 589: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==589); +{ yylhsminor.yy20 = createColumnNode(pCxt, &yymsp[-2].minor.yy621, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; + break; + case 522: /* case_when_expression ::= CASE when_then_list case_when_else_opt END */ +{ yylhsminor.yy20 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, NULL, yymsp[-2].minor.yy1008, yymsp[-1].minor.yy20)); } + yymsp[-3].minor.yy20 = yylhsminor.yy20; + break; + case 523: /* case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ +{ yylhsminor.yy20 = createRawExprNodeExt(pCxt, &yymsp[-4].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy20), yymsp[-2].minor.yy1008, yymsp[-1].minor.yy20)); } + yymsp[-4].minor.yy20 = yylhsminor.yy20; + break; + case 526: /* when_then_expr ::= WHEN common_expression THEN common_expression */ +{ yymsp[-3].minor.yy20 = createWhenThenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy20), releaseRawExprNode(pCxt, yymsp[0].minor.yy20)); } + break; + case 528: /* case_when_else_opt ::= ELSE common_expression */ +{ yymsp[-1].minor.yy20 = releaseRawExprNode(pCxt, yymsp[0].minor.yy20); } + break; + case 529: /* predicate ::= expr_or_subquery compare_op expr_or_subquery */ + case 534: /* predicate ::= expr_or_subquery in_op in_predicate_value */ yytestcase(yyruleno==534); { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy360); - yylhsminor.yy360 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy360), NULL)); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy20); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy20); + yylhsminor.yy20 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, yymsp[-1].minor.yy232, releaseRawExprNode(pCxt, yymsp[-2].minor.yy20), releaseRawExprNode(pCxt, yymsp[0].minor.yy20))); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; - case 518: /* predicate ::= expr_or_subquery IS NOT NULL */ + case 530: /* predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy360); - yylhsminor.yy360 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy360), NULL)); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy20); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy20); + yylhsminor.yy20 = createRawExprNodeExt(pCxt, &s, &e, createBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-4].minor.yy20), releaseRawExprNode(pCxt, yymsp[-2].minor.yy20), releaseRawExprNode(pCxt, yymsp[0].minor.yy20))); } - yymsp[-3].minor.yy360 = yylhsminor.yy360; + yymsp[-4].minor.yy20 = yylhsminor.yy20; break; - case 520: /* compare_op ::= NK_LT */ -{ yymsp[0].minor.yy252 = OP_TYPE_LOWER_THAN; } - break; - case 521: /* compare_op ::= NK_GT */ -{ yymsp[0].minor.yy252 = OP_TYPE_GREATER_THAN; } - break; - case 522: /* compare_op ::= NK_LE */ -{ yymsp[0].minor.yy252 = OP_TYPE_LOWER_EQUAL; } - break; - case 523: /* compare_op ::= NK_GE */ -{ yymsp[0].minor.yy252 = OP_TYPE_GREATER_EQUAL; } - break; - case 524: /* compare_op ::= NK_NE */ -{ yymsp[0].minor.yy252 = OP_TYPE_NOT_EQUAL; } - break; - case 525: /* compare_op ::= NK_EQ */ -{ yymsp[0].minor.yy252 = OP_TYPE_EQUAL; } - break; - case 526: /* compare_op ::= LIKE */ -{ yymsp[0].minor.yy252 = OP_TYPE_LIKE; } - break; - case 527: /* compare_op ::= NOT LIKE */ -{ yymsp[-1].minor.yy252 = OP_TYPE_NOT_LIKE; } - break; - case 528: /* compare_op ::= MATCH */ -{ yymsp[0].minor.yy252 = OP_TYPE_MATCH; } - break; - case 529: /* compare_op ::= NMATCH */ -{ yymsp[0].minor.yy252 = OP_TYPE_NMATCH; } - break; - case 530: /* compare_op ::= CONTAINS */ -{ yymsp[0].minor.yy252 = OP_TYPE_JSON_CONTAINS; } - break; - case 531: /* in_op ::= IN */ -{ yymsp[0].minor.yy252 = OP_TYPE_IN; } - break; - case 532: /* in_op ::= NOT IN */ -{ yymsp[-1].minor.yy252 = OP_TYPE_NOT_IN; } - break; - case 533: /* in_predicate_value ::= NK_LP literal_list NK_RP */ -{ yylhsminor.yy360 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy536)); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; - break; - case 535: /* boolean_value_expression ::= NOT boolean_primary */ + case 531: /* predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ { - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy360); - yylhsminor.yy360 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy360), NULL)); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy20); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy20); + yylhsminor.yy20 = createRawExprNodeExt(pCxt, &s, &e, createNotBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy20), releaseRawExprNode(pCxt, yymsp[-2].minor.yy20), releaseRawExprNode(pCxt, yymsp[0].minor.yy20))); } - yymsp[-1].minor.yy360 = yylhsminor.yy360; + yymsp[-5].minor.yy20 = yylhsminor.yy20; break; - case 536: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ + case 532: /* predicate ::= expr_or_subquery IS NULL */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy360); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy360); - yylhsminor.yy360 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy360), releaseRawExprNode(pCxt, yymsp[0].minor.yy360))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy20); + yylhsminor.yy20 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy20), NULL)); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; - case 537: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ + case 533: /* predicate ::= expr_or_subquery IS NOT NULL */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy360); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy360); - yylhsminor.yy360 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy360), releaseRawExprNode(pCxt, yymsp[0].minor.yy360))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy20); + yylhsminor.yy20 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy20), NULL)); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; + yymsp[-3].minor.yy20 = yylhsminor.yy20; break; - case 545: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */ -{ yylhsminor.yy360 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy360, yymsp[0].minor.yy360, NULL); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; + case 535: /* compare_op ::= NK_LT */ +{ yymsp[0].minor.yy232 = OP_TYPE_LOWER_THAN; } break; - case 548: /* table_primary ::= table_name alias_opt */ -{ yylhsminor.yy360 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy929, &yymsp[0].minor.yy929); } - yymsp[-1].minor.yy360 = yylhsminor.yy360; + case 536: /* compare_op ::= NK_GT */ +{ yymsp[0].minor.yy232 = OP_TYPE_GREATER_THAN; } break; - case 549: /* table_primary ::= db_name NK_DOT table_name alias_opt */ -{ yylhsminor.yy360 = createRealTableNode(pCxt, &yymsp[-3].minor.yy929, &yymsp[-1].minor.yy929, &yymsp[0].minor.yy929); } - yymsp[-3].minor.yy360 = yylhsminor.yy360; + case 537: /* compare_op ::= NK_LE */ +{ yymsp[0].minor.yy232 = OP_TYPE_LOWER_EQUAL; } break; - case 550: /* table_primary ::= subquery alias_opt */ -{ yylhsminor.yy360 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy360), &yymsp[0].minor.yy929); } - yymsp[-1].minor.yy360 = yylhsminor.yy360; + case 538: /* compare_op ::= NK_GE */ +{ yymsp[0].minor.yy232 = OP_TYPE_GREATER_EQUAL; } break; - case 552: /* alias_opt ::= */ -{ yymsp[1].minor.yy929 = nil_token; } + case 539: /* compare_op ::= NK_NE */ +{ yymsp[0].minor.yy232 = OP_TYPE_NOT_EQUAL; } break; - case 554: /* alias_opt ::= AS table_alias */ -{ yymsp[-1].minor.yy929 = yymsp[0].minor.yy929; } + case 540: /* compare_op ::= NK_EQ */ +{ yymsp[0].minor.yy232 = OP_TYPE_EQUAL; } break; - case 555: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - case 556: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==556); -{ yymsp[-2].minor.yy360 = yymsp[-1].minor.yy360; } + case 541: /* compare_op ::= LIKE */ +{ yymsp[0].minor.yy232 = OP_TYPE_LIKE; } break; - case 557: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ -{ yylhsminor.yy360 = createJoinTableNode(pCxt, yymsp[-4].minor.yy596, yymsp[-5].minor.yy360, yymsp[-2].minor.yy360, yymsp[0].minor.yy360); } - yymsp[-5].minor.yy360 = yylhsminor.yy360; + case 542: /* compare_op ::= NOT LIKE */ +{ yymsp[-1].minor.yy232 = OP_TYPE_NOT_LIKE; } break; - case 558: /* join_type ::= */ -{ yymsp[1].minor.yy596 = JOIN_TYPE_INNER; } + case 543: /* compare_op ::= MATCH */ +{ yymsp[0].minor.yy232 = OP_TYPE_MATCH; } break; - case 559: /* join_type ::= INNER */ -{ yymsp[0].minor.yy596 = JOIN_TYPE_INNER; } + case 544: /* compare_op ::= NMATCH */ +{ yymsp[0].minor.yy232 = OP_TYPE_NMATCH; } break; - case 560: /* query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ + case 545: /* compare_op ::= CONTAINS */ +{ yymsp[0].minor.yy232 = OP_TYPE_JSON_CONTAINS; } + break; + case 546: /* in_op ::= IN */ +{ yymsp[0].minor.yy232 = OP_TYPE_IN; } + break; + case 547: /* in_op ::= NOT IN */ +{ yymsp[-1].minor.yy232 = OP_TYPE_NOT_IN; } + break; + case 548: /* in_predicate_value ::= NK_LP literal_list NK_RP */ +{ yylhsminor.yy20 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy1008)); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; + break; + case 550: /* boolean_value_expression ::= NOT boolean_primary */ { - yymsp[-13].minor.yy360 = createSelectStmt(pCxt, yymsp[-11].minor.yy345, yymsp[-9].minor.yy536, yymsp[-8].minor.yy360, yymsp[-12].minor.yy536); - yymsp[-13].minor.yy360 = setSelectStmtTagMode(pCxt, yymsp[-13].minor.yy360, yymsp[-10].minor.yy345); - yymsp[-13].minor.yy360 = addWhereClause(pCxt, yymsp[-13].minor.yy360, yymsp[-7].minor.yy360); - yymsp[-13].minor.yy360 = addPartitionByClause(pCxt, yymsp[-13].minor.yy360, yymsp[-6].minor.yy536); - yymsp[-13].minor.yy360 = addWindowClauseClause(pCxt, yymsp[-13].minor.yy360, yymsp[-2].minor.yy360); - yymsp[-13].minor.yy360 = addGroupByClause(pCxt, yymsp[-13].minor.yy360, yymsp[-1].minor.yy536); - yymsp[-13].minor.yy360 = addHavingClause(pCxt, yymsp[-13].minor.yy360, yymsp[0].minor.yy360); - yymsp[-13].minor.yy360 = addRangeClause(pCxt, yymsp[-13].minor.yy360, yymsp[-5].minor.yy360); - yymsp[-13].minor.yy360 = addEveryClause(pCxt, yymsp[-13].minor.yy360, yymsp[-4].minor.yy360); - yymsp[-13].minor.yy360 = addFillClause(pCxt, yymsp[-13].minor.yy360, yymsp[-3].minor.yy360); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy20); + yylhsminor.yy20 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy20), NULL)); } + yymsp[-1].minor.yy20 = yylhsminor.yy20; break; - case 561: /* hint_list ::= */ -{ yymsp[1].minor.yy536 = createHintNodeList(pCxt, NULL); } - break; - case 562: /* hint_list ::= NK_HINT */ -{ yylhsminor.yy536 = createHintNodeList(pCxt, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy536 = yylhsminor.yy536; - break; - case 567: /* set_quantifier_opt ::= ALL */ -{ yymsp[0].minor.yy345 = false; } - break; - case 570: /* select_item ::= NK_STAR */ -{ yylhsminor.yy360 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy360 = yylhsminor.yy360; - break; - case 572: /* select_item ::= common_expression column_alias */ - case 582: /* partition_item ::= expr_or_subquery column_alias */ yytestcase(yyruleno==582); -{ yylhsminor.yy360 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy360), &yymsp[0].minor.yy929); } - yymsp[-1].minor.yy360 = yylhsminor.yy360; - break; - case 573: /* select_item ::= common_expression AS column_alias */ - case 583: /* partition_item ::= expr_or_subquery AS column_alias */ yytestcase(yyruleno==583); -{ yylhsminor.yy360 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy360), &yymsp[0].minor.yy929); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; - break; - case 578: /* partition_by_clause_opt ::= PARTITION BY partition_list */ - case 608: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==608); - case 628: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==628); -{ yymsp[-2].minor.yy536 = yymsp[0].minor.yy536; } - break; - case 585: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP */ -{ yymsp[-5].minor.yy360 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy360), releaseRawExprNode(pCxt, yymsp[-1].minor.yy360)); } - break; - case 586: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ -{ yymsp[-3].minor.yy360 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy360)); } - break; - case 587: /* twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ -{ yymsp[-5].minor.yy360 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy360), NULL, yymsp[-1].minor.yy360, yymsp[0].minor.yy360); } - break; - case 588: /* twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ -{ yymsp[-7].minor.yy360 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy360), releaseRawExprNode(pCxt, yymsp[-3].minor.yy360), yymsp[-1].minor.yy360, yymsp[0].minor.yy360); } - break; - case 589: /* twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ -{ yymsp[-6].minor.yy360 = createEventWindowNode(pCxt, yymsp[-3].minor.yy360, yymsp[0].minor.yy360); } - break; - case 590: /* twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy360 = createCountWindowNode(pCxt, &yymsp[-1].minor.yy0, &yymsp[-1].minor.yy0); } - break; - case 591: /* twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ -{ yymsp[-5].minor.yy360 = createCountWindowNode(pCxt, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0); } - break; - case 598: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ -{ yymsp[-3].minor.yy360 = createFillNode(pCxt, yymsp[-1].minor.yy358, NULL); } - break; - case 599: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ -{ yymsp[-5].minor.yy360 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy536)); } - break; - case 600: /* fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ -{ yymsp[-5].minor.yy360 = createFillNode(pCxt, FILL_MODE_VALUE_F, createNodeListNode(pCxt, yymsp[-1].minor.yy536)); } - break; - case 601: /* fill_mode ::= NONE */ -{ yymsp[0].minor.yy358 = FILL_MODE_NONE; } - break; - case 602: /* fill_mode ::= PREV */ -{ yymsp[0].minor.yy358 = FILL_MODE_PREV; } - break; - case 603: /* fill_mode ::= NULL */ -{ yymsp[0].minor.yy358 = FILL_MODE_NULL; } - break; - case 604: /* fill_mode ::= NULL_F */ -{ yymsp[0].minor.yy358 = FILL_MODE_NULL_F; } - break; - case 605: /* fill_mode ::= LINEAR */ -{ yymsp[0].minor.yy358 = FILL_MODE_LINEAR; } - break; - case 606: /* fill_mode ::= NEXT */ -{ yymsp[0].minor.yy358 = FILL_MODE_NEXT; } - break; - case 609: /* group_by_list ::= expr_or_subquery */ -{ yylhsminor.yy536 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy360))); } - yymsp[0].minor.yy536 = yylhsminor.yy536; - break; - case 610: /* group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ -{ yylhsminor.yy536 = addNodeToList(pCxt, yymsp[-2].minor.yy536, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy360))); } - yymsp[-2].minor.yy536 = yylhsminor.yy536; - break; - case 614: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ -{ yymsp[-5].minor.yy360 = createInterpTimeRange(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy360), releaseRawExprNode(pCxt, yymsp[-1].minor.yy360)); } - break; - case 615: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ -{ yymsp[-3].minor.yy360 = createInterpTimePoint(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy360)); } - break; - case 618: /* query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ + case 551: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ { - yylhsminor.yy360 = addOrderByClause(pCxt, yymsp[-3].minor.yy360, yymsp[-2].minor.yy536); - yylhsminor.yy360 = addSlimitClause(pCxt, yylhsminor.yy360, yymsp[-1].minor.yy360); - yylhsminor.yy360 = addLimitClause(pCxt, yylhsminor.yy360, yymsp[0].minor.yy360); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy20); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy20); + yylhsminor.yy20 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy20), releaseRawExprNode(pCxt, yymsp[0].minor.yy20))); } - yymsp[-3].minor.yy360 = yylhsminor.yy360; + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; - case 621: /* union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ -{ yylhsminor.yy360 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy360, yymsp[0].minor.yy360); } - yymsp[-3].minor.yy360 = yylhsminor.yy360; + case 552: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ +{ + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy20); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy20); + yylhsminor.yy20 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy20), releaseRawExprNode(pCxt, yymsp[0].minor.yy20))); + } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; - case 622: /* union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ -{ yylhsminor.yy360 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy360, yymsp[0].minor.yy360); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; + case 560: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */ +{ yylhsminor.yy20 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy20, yymsp[0].minor.yy20, NULL); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; break; - case 630: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ - case 634: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==634); -{ yymsp[-1].minor.yy360 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); } + case 563: /* table_primary ::= table_name alias_opt */ +{ yylhsminor.yy20 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy621, &yymsp[0].minor.yy621); } + yymsp[-1].minor.yy20 = yylhsminor.yy20; break; - case 631: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - case 635: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==635); -{ yymsp[-3].minor.yy360 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } + case 564: /* table_primary ::= db_name NK_DOT table_name alias_opt */ +{ yylhsminor.yy20 = createRealTableNode(pCxt, &yymsp[-3].minor.yy621, &yymsp[-1].minor.yy621, &yymsp[0].minor.yy621); } + yymsp[-3].minor.yy20 = yylhsminor.yy20; break; - case 632: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - case 636: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==636); -{ yymsp[-3].minor.yy360 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); } + case 565: /* table_primary ::= subquery alias_opt */ +{ yylhsminor.yy20 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy20), &yymsp[0].minor.yy621); } + yymsp[-1].minor.yy20 = yylhsminor.yy20; break; - case 637: /* subquery ::= NK_LP query_expression NK_RP */ -{ yylhsminor.yy360 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy360); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; + case 567: /* alias_opt ::= */ +{ yymsp[1].minor.yy621 = nil_token; } break; - case 642: /* sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ -{ yylhsminor.yy360 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy360), yymsp[-1].minor.yy642, yymsp[0].minor.yy585); } - yymsp[-2].minor.yy360 = yylhsminor.yy360; + case 569: /* alias_opt ::= AS table_alias */ +{ yymsp[-1].minor.yy621 = yymsp[0].minor.yy621; } break; - case 643: /* ordering_specification_opt ::= */ -{ yymsp[1].minor.yy642 = ORDER_ASC; } + case 570: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */ + case 571: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==571); +{ yymsp[-2].minor.yy20 = yymsp[-1].minor.yy20; } break; - case 644: /* ordering_specification_opt ::= ASC */ -{ yymsp[0].minor.yy642 = ORDER_ASC; } + case 572: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ +{ yylhsminor.yy20 = createJoinTableNode(pCxt, yymsp[-4].minor.yy432, yymsp[-5].minor.yy20, yymsp[-2].minor.yy20, yymsp[0].minor.yy20); } + yymsp[-5].minor.yy20 = yylhsminor.yy20; break; - case 645: /* ordering_specification_opt ::= DESC */ -{ yymsp[0].minor.yy642 = ORDER_DESC; } + case 573: /* join_type ::= */ +{ yymsp[1].minor.yy432 = JOIN_TYPE_INNER; } break; - case 646: /* null_ordering_opt ::= */ -{ yymsp[1].minor.yy585 = NULL_ORDER_DEFAULT; } + case 574: /* join_type ::= INNER */ +{ yymsp[0].minor.yy432 = JOIN_TYPE_INNER; } break; - case 647: /* null_ordering_opt ::= NULLS FIRST */ -{ yymsp[-1].minor.yy585 = NULL_ORDER_FIRST; } + case 575: /* query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ +{ + yymsp[-13].minor.yy20 = createSelectStmt(pCxt, yymsp[-11].minor.yy709, yymsp[-9].minor.yy1008, yymsp[-8].minor.yy20, yymsp[-12].minor.yy1008); + yymsp[-13].minor.yy20 = setSelectStmtTagMode(pCxt, yymsp[-13].minor.yy20, yymsp[-10].minor.yy709); + yymsp[-13].minor.yy20 = addWhereClause(pCxt, yymsp[-13].minor.yy20, yymsp[-7].minor.yy20); + yymsp[-13].minor.yy20 = addPartitionByClause(pCxt, yymsp[-13].minor.yy20, yymsp[-6].minor.yy1008); + yymsp[-13].minor.yy20 = addWindowClauseClause(pCxt, yymsp[-13].minor.yy20, yymsp[-2].minor.yy20); + yymsp[-13].minor.yy20 = addGroupByClause(pCxt, yymsp[-13].minor.yy20, yymsp[-1].minor.yy1008); + yymsp[-13].minor.yy20 = addHavingClause(pCxt, yymsp[-13].minor.yy20, yymsp[0].minor.yy20); + yymsp[-13].minor.yy20 = addRangeClause(pCxt, yymsp[-13].minor.yy20, yymsp[-5].minor.yy20); + yymsp[-13].minor.yy20 = addEveryClause(pCxt, yymsp[-13].minor.yy20, yymsp[-4].minor.yy20); + yymsp[-13].minor.yy20 = addFillClause(pCxt, yymsp[-13].minor.yy20, yymsp[-3].minor.yy20); + } break; - case 648: /* null_ordering_opt ::= NULLS LAST */ -{ yymsp[-1].minor.yy585 = NULL_ORDER_LAST; } + case 576: /* hint_list ::= */ +{ yymsp[1].minor.yy1008 = createHintNodeList(pCxt, NULL); } + break; + case 577: /* hint_list ::= NK_HINT */ +{ yylhsminor.yy1008 = createHintNodeList(pCxt, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy1008 = yylhsminor.yy1008; + break; + case 582: /* set_quantifier_opt ::= ALL */ +{ yymsp[0].minor.yy709 = false; } + break; + case 585: /* select_item ::= NK_STAR */ +{ yylhsminor.yy20 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy20 = yylhsminor.yy20; + break; + case 587: /* select_item ::= common_expression column_alias */ + case 597: /* partition_item ::= expr_or_subquery column_alias */ yytestcase(yyruleno==597); +{ yylhsminor.yy20 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy20), &yymsp[0].minor.yy621); } + yymsp[-1].minor.yy20 = yylhsminor.yy20; + break; + case 588: /* select_item ::= common_expression AS column_alias */ + case 598: /* partition_item ::= expr_or_subquery AS column_alias */ yytestcase(yyruleno==598); +{ yylhsminor.yy20 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy20), &yymsp[0].minor.yy621); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; + break; + case 593: /* partition_by_clause_opt ::= PARTITION BY partition_list */ + case 623: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==623); + case 643: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==643); +{ yymsp[-2].minor.yy1008 = yymsp[0].minor.yy1008; } + break; + case 600: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP */ +{ yymsp[-5].minor.yy20 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy20), releaseRawExprNode(pCxt, yymsp[-1].minor.yy20)); } + break; + case 601: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ +{ yymsp[-3].minor.yy20 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy20)); } + break; + case 602: /* twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ +{ yymsp[-5].minor.yy20 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy20), NULL, yymsp[-1].minor.yy20, yymsp[0].minor.yy20); } + break; + case 603: /* twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ +{ yymsp[-7].minor.yy20 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy20), releaseRawExprNode(pCxt, yymsp[-3].minor.yy20), yymsp[-1].minor.yy20, yymsp[0].minor.yy20); } + break; + case 604: /* twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ +{ yymsp[-6].minor.yy20 = createEventWindowNode(pCxt, yymsp[-3].minor.yy20, yymsp[0].minor.yy20); } + break; + case 605: /* twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_RP */ +{ yymsp[-3].minor.yy20 = createCountWindowNode(pCxt, &yymsp[-1].minor.yy0, &yymsp[-1].minor.yy0); } + break; + case 606: /* twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ +{ yymsp[-5].minor.yy20 = createCountWindowNode(pCxt, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0); } + break; + case 613: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ +{ yymsp[-3].minor.yy20 = createFillNode(pCxt, yymsp[-1].minor.yy690, NULL); } + break; + case 614: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ +{ yymsp[-5].minor.yy20 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy1008)); } + break; + case 615: /* fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ +{ yymsp[-5].minor.yy20 = createFillNode(pCxt, FILL_MODE_VALUE_F, createNodeListNode(pCxt, yymsp[-1].minor.yy1008)); } + break; + case 616: /* fill_mode ::= NONE */ +{ yymsp[0].minor.yy690 = FILL_MODE_NONE; } + break; + case 617: /* fill_mode ::= PREV */ +{ yymsp[0].minor.yy690 = FILL_MODE_PREV; } + break; + case 618: /* fill_mode ::= NULL */ +{ yymsp[0].minor.yy690 = FILL_MODE_NULL; } + break; + case 619: /* fill_mode ::= NULL_F */ +{ yymsp[0].minor.yy690 = FILL_MODE_NULL_F; } + break; + case 620: /* fill_mode ::= LINEAR */ +{ yymsp[0].minor.yy690 = FILL_MODE_LINEAR; } + break; + case 621: /* fill_mode ::= NEXT */ +{ yymsp[0].minor.yy690 = FILL_MODE_NEXT; } + break; + case 624: /* group_by_list ::= expr_or_subquery */ +{ yylhsminor.yy1008 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy20))); } + yymsp[0].minor.yy1008 = yylhsminor.yy1008; + break; + case 625: /* group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ +{ yylhsminor.yy1008 = addNodeToList(pCxt, yymsp[-2].minor.yy1008, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy20))); } + yymsp[-2].minor.yy1008 = yylhsminor.yy1008; + break; + case 629: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ +{ yymsp[-5].minor.yy20 = createInterpTimeRange(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy20), releaseRawExprNode(pCxt, yymsp[-1].minor.yy20)); } + break; + case 630: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ +{ yymsp[-3].minor.yy20 = createInterpTimePoint(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy20)); } + break; + case 633: /* query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ +{ + yylhsminor.yy20 = addOrderByClause(pCxt, yymsp[-3].minor.yy20, yymsp[-2].minor.yy1008); + yylhsminor.yy20 = addSlimitClause(pCxt, yylhsminor.yy20, yymsp[-1].minor.yy20); + yylhsminor.yy20 = addLimitClause(pCxt, yylhsminor.yy20, yymsp[0].minor.yy20); + } + yymsp[-3].minor.yy20 = yylhsminor.yy20; + break; + case 636: /* union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ +{ yylhsminor.yy20 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy20, yymsp[0].minor.yy20); } + yymsp[-3].minor.yy20 = yylhsminor.yy20; + break; + case 637: /* union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ +{ yylhsminor.yy20 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy20, yymsp[0].minor.yy20); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; + break; + case 645: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ + case 649: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==649); +{ yymsp[-1].minor.yy20 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); } + break; + case 646: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + case 650: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==650); +{ yymsp[-3].minor.yy20 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } + break; + case 647: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + case 651: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==651); +{ yymsp[-3].minor.yy20 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); } + break; + case 652: /* subquery ::= NK_LP query_expression NK_RP */ +{ yylhsminor.yy20 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy20); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; + break; + case 657: /* sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ +{ yylhsminor.yy20 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy20), yymsp[-1].minor.yy398, yymsp[0].minor.yy929); } + yymsp[-2].minor.yy20 = yylhsminor.yy20; + break; + case 658: /* ordering_specification_opt ::= */ +{ yymsp[1].minor.yy398 = ORDER_ASC; } + break; + case 659: /* ordering_specification_opt ::= ASC */ +{ yymsp[0].minor.yy398 = ORDER_ASC; } + break; + case 660: /* ordering_specification_opt ::= DESC */ +{ yymsp[0].minor.yy398 = ORDER_DESC; } + break; + case 661: /* null_ordering_opt ::= */ +{ yymsp[1].minor.yy929 = NULL_ORDER_DEFAULT; } + break; + case 662: /* null_ordering_opt ::= NULLS FIRST */ +{ yymsp[-1].minor.yy929 = NULL_ORDER_FIRST; } + break; + case 663: /* null_ordering_opt ::= NULLS LAST */ +{ yymsp[-1].minor.yy929 = NULL_ORDER_LAST; } break; default: break; @@ -7015,56 +6854,12 @@ void Parse( } #endif - while(1){ /* Exit by "break" */ - assert( yypParser->yytos>=yypParser->yystack ); + do{ assert( yyact==yypParser->yytos->stateno ); yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact); if( yyact >= YY_MIN_REDUCE ){ - unsigned int yyruleno = yyact - YY_MIN_REDUCE; /* Reduce by this rule */ -#ifndef NDEBUG - assert( yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ); - if( yyTraceFILE ){ - int yysize = yyRuleInfoNRhs[yyruleno]; - if( yysize ){ - fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n", - yyTracePrompt, - yyruleno, yyRuleName[yyruleno], - yyrulenoyytos[yysize].stateno); - }else{ - fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n", - yyTracePrompt, yyruleno, yyRuleName[yyruleno], - yyrulenoyytos - yypParser->yystack)>yypParser->yyhwm ){ - yypParser->yyhwm++; - assert( yypParser->yyhwm == - (int)(yypParser->yytos - yypParser->yystack)); - } -#endif -#if YYSTACKDEPTH>0 - if( yypParser->yytos>=yypParser->yystackEnd ){ - yyStackOverflow(yypParser); - break; - } -#else - if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){ - if( yyGrowStack(yypParser) ){ - yyStackOverflow(yypParser); - break; - } - } -#endif - } - yyact = yy_reduce(yypParser,yyruleno,yymajor,yyminor ParseCTX_PARAM); + yyact = yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor, + yyminor ParseCTX_PARAM); }else if( yyact <= YY_MAX_SHIFTREDUCE ){ yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor); #ifndef YYNOERRORRECOVERY @@ -7120,13 +6915,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 @@ -7176,7 +6972,7 @@ void Parse( break; #endif } - } + }while( yypParser->yytos>yypParser->yystack ); #ifndef NDEBUG if( yyTraceFILE ){ yyStackEntry *i; diff --git a/source/os/src/osString.c b/source/os/src/osString.c index 9119c1d470..8c6c0e0d7c 100644 --- a/source/os/src/osString.c +++ b/source/os/src/osString.c @@ -485,7 +485,7 @@ bool isHex(const char* z, uint32_t n){ } bool isValidateHex(const char* z, uint32_t n){ - if(n % 2 != 0) return false; + if((n & 1) != 0) return false; for(size_t i = HEX_PREFIX_LEN; i < n; i++){ if(isxdigit(z[i]) == 0){ return false; @@ -494,13 +494,16 @@ bool isValidateHex(const char* z, uint32_t n){ return true; } -int32_t taosHex2Ascii(const char *z, uint32_t n, void** data, uint32_t* size){ - n -= HEX_PREFIX_LEN; // remove 0x +int32_t taosHex2Ascii(const char *z, uint32_t n, void **data, uint32_t *size) { + n -= HEX_PREFIX_LEN; // remove 0x z += HEX_PREFIX_LEN; *size = n / HEX_PREFIX_LEN; - if(*size == 0) return 0; - uint8_t* tmp = (uint8_t*)taosMemoryCalloc(*size, 1); - if(tmp == NULL) return -1; + if (*size == 0) { + if (!(*data = taosStrdup(""))) return -1; + return 0; + } + uint8_t *tmp = (uint8_t *)taosMemoryCalloc(*size, 1); + if (tmp == NULL) return -1; int8_t num = 0; uint8_t *byte = tmp + *size - 1; diff --git a/source/util/src/terror.c b/source/util/src/terror.c index 1f3aaa3835..877e1f776a 100644 --- a/source/util/src/terror.c +++ b/source/util/src/terror.c @@ -613,7 +613,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_PAR_GET_META_ERROR, "Fail to get table i TAOS_DEFINE_ERROR(TSDB_CODE_PAR_NOT_UNIQUE_TABLE_ALIAS, "Not unique table/alias") TAOS_DEFINE_ERROR(TSDB_CODE_PAR_SYSTABLE_NOT_ALLOWED_FUNC, "System table not allowed") TAOS_DEFINE_ERROR(TSDB_CODE_PAR_SYSTABLE_NOT_ALLOWED, "System table not allowed") -TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_VARBINARY, "Invalidate varbinary value") +TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_VARBINARY, "Invalid varbinary value") TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_IP_RANGE, "Invalid IPV4 address ranges") TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INTERNAL_ERROR, "Parser internal error") TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_STREAM_QUERY, "Invalid stream query") diff --git a/tests/parallel_test/cases.task b/tests/parallel_test/cases.task index 481e111715..8c22d028e4 100644 --- a/tests/parallel_test/cases.task +++ b/tests/parallel_test/cases.task @@ -327,6 +327,7 @@ ,,y,system-test,./pytest.sh python3 ./test.py -f 1-insert/db_tb_name_check.py ,,y,system-test,./pytest.sh python3 ./test.py -f 1-insert/InsertFuturets.py ,,y,system-test,./pytest.sh python3 ./test.py -f 1-insert/insert_wide_column.py +,,y,system-test,./pytest.sh python3 ./test.py -f 1-insert/insert_column_value.py ,,y,system-test,./pytest.sh python3 ./test.py -f 1-insert/rowlength64k_benchmark.py ,,y,system-test,./pytest.sh python3 ./test.py -f 1-insert/rowlength64k.py ,,y,system-test,./pytest.sh python3 ./test.py -f 1-insert/rowlength64k.py -R diff --git a/tests/script/tsim/parser/columnValue_bigint.sim b/tests/script/tsim/parser/columnValue_bigint.sim index 056855eea2..8e21743d1a 100644 --- a/tests/script/tsim/parser/columnValue_bigint.sim +++ b/tests/script/tsim/parser/columnValue_bigint.sim @@ -28,10 +28,26 @@ if $data05 != NULL then return -1 endi -sql_error create table st_bigint_2 using mt_bigint tags ('NULL') -sql_error create table st_bigint_3 using mt_bigint tags ('NULL') -sql_error create table st_bigint_4 using mt_bigint tags ("NULL") -sql_error create table st_bigint_5 using mt_bigint tags ("NULL") +sql create table st_bigint_2 using mt_bigint tags ('NULL') +sql show tags from st_bigint_2 +if $data05 != NULL then + return -1 +endi +sql create table st_bigint_3 using mt_bigint tags ('NULL') +sql show tags from st_bigint_3 +if $data05 != NULL then + return -1 +endi +sql create table st_bigint_4 using mt_bigint tags ("NULL") +sql show tags from st_bigint_4 +if $data05 != NULL then + return -1 +endi +sql create table st_bigint_5 using mt_bigint tags ("NULL") +sql show tags from st_bigint_5 +if $data05 != NULL then + return -1 +endi sql create table st_bigint_6 using mt_bigint tags (-9223372036854775807) sql show tags from st_bigint_6 @@ -97,6 +113,39 @@ if $data01 != NULL then return -1 endi +sql insert into st_bigint_2 values (now, NULL) +sql select * from st_bigint_2 +if $rows != 1 then + return -1 +endi +if $data01 != NULL then + return -1 +endi +sql insert into st_bigint_3 values (now, NULL) +sql select * from st_bigint_3 +if $rows != 1 then + return -1 +endi +if $data01 != NULL then + return -1 +endi +sql insert into st_bigint_4 values (now, NULL) +sql select * from st_bigint_4 +if $rows != 1 then + return -1 +endi +if $data01 != NULL then + return -1 +endi +sql insert into st_bigint_5 values (now, NULL) +sql select * from st_bigint_5 +if $rows != 1 then + return -1 +endi +if $data01 != NULL then + return -1 +endi + sql insert into st_bigint_6 values (now, 9223372036854775807) sql select * from st_bigint_6 if $rows != 1 then @@ -348,7 +397,7 @@ sql_error create table st_bigint_e0 using mt_bigint tags ("123abc") sql_error create table st_bigint_e0 using mt_bigint tags (abc) sql_error create table st_bigint_e0 using mt_bigint tags ("abc") sql_error create table st_bigint_e0 using mt_bigint tags (" ") -sql create table st_bigint_e0_error using mt_bigint tags ('') +sql_error create table st_bigint_e0_error using mt_bigint tags ('') sql create table st_bigint_e0 using mt_bigint tags (123) sql create table st_bigint_e1 using mt_bigint tags (123) @@ -401,7 +450,7 @@ sql_error insert into st_bigint_e20 using mt_bigint tags ("123abc") values (now, sql_error insert into st_bigint_e22 using mt_bigint tags (abc) values (now, -033) sql_error insert into st_bigint_e23 using mt_bigint tags ("abc") values (now, -033) sql_error insert into st_bigint_e24 using mt_bigint tags (" ") values (now, -033) -sql insert into st_bigint_e25 using mt_bigint tags ('') values (now, -033) +sql_error insert into st_bigint_e25 using mt_bigint tags ('') values (now, -033) sql insert into st_bigint_e13 using mt_bigint tags (033) values (now, 00062) sql insert into st_bigint_e14 using mt_bigint tags (033) values (now, 00062) @@ -417,15 +466,15 @@ sql insert into st_bigint_e23 using mt_bigint tags (033) values (now, 00062) sql insert into st_bigint_e24 using mt_bigint tags (033) values (now, 00062) sql insert into st_bigint_e25 using mt_bigint tags (033) values (now, 00062) -#sql alter table st_bigint_e13 set tag tagname=9223372036854775808 -#sql_error alter table st_bigint_e14 set tag tagname=-9223372036854775808 -#sql alter table st_bigint_e15 set tag tagname=92233720368547758080 -#sql_error alter table st_bigint_e16 set tag tagname=-92233720368547758080 -#sql_error alter table st_bigint_e19 set tag tagname=123abc -#sql_error alter table st_bigint_e20 set tag tagname="123abc" -#sql_error alter table st_bigint_e22 set tag tagname=abc -#sql_error alter table st_bigint_e23 set tag tagname="abc" -#sql_error alter table st_bigint_e24 set tag tagname=" " -#sql_error alter table st_bigint_e25 set tag tagname='' +sql_error alter table st_bigint_e13 set tag tagname=9223372036854775808 +sql alter table st_bigint_e14 set tag tagname=-9223372036854775808 +sql_error alter table st_bigint_e15 set tag tagname=92233720368547758080 +sql_error alter table st_bigint_e16 set tag tagname=-92233720368547758080 +sql_error alter table st_bigint_e19 set tag tagname=123abc +sql_error alter table st_bigint_e20 set tag tagname="123abc" +sql_error alter table st_bigint_e22 set tag tagname=abc +sql_error alter table st_bigint_e23 set tag tagname="abc" +sql_error alter table st_bigint_e24 set tag tagname=" " +sql_error alter table st_bigint_e25 set tag tagname='' system sh/exec.sh -n dnode1 -s stop -x SIGINT diff --git a/tests/script/tsim/parser/columnValue_bool.sim b/tests/script/tsim/parser/columnValue_bool.sim index 2553e6805a..dcbb69280d 100644 --- a/tests/script/tsim/parser/columnValue_bool.sim +++ b/tests/script/tsim/parser/columnValue_bool.sim @@ -31,26 +31,26 @@ if $data05 != NULL then endi sql create table st_bool_2 using mt_bool tags ('NULL') sql show tags from st_bool_2 -if $data05 != false then - print ==3== expect: false, actually: $data05 +if $data05 != NULL then + print ==3== expect: NULL, actually: $data05 return -1 endi sql create table st_bool_3 using mt_bool tags ('NULL') sql show tags from st_bool_3 -if $data05 != false then - print ==4== expect: false, actually: $data05 +if $data05 != NULL then + print ==4== expect: NULL, actually: $data05 return -1 endi sql create table st_bool_4 using mt_bool tags ("NULL") sql show tags from st_bool_4 -if $data05 != false then - print ==5== expect: false, actually: $data05 +if $data05 != NULL then + print ==5== expect: NULL, actually: $data05 return -1 endi sql create table st_bool_5 using mt_bool tags ("NULL") sql show tags from st_bool_5 -if $data05 != false then - print ==6== expect: false, actually: $data05 +if $data05 != NULL then + print ==6== expect: NULL, actually: $data05 return -1 endi sql create table st_bool_6 using mt_bool tags ("true") @@ -581,12 +581,12 @@ endi # case 04: illegal input sql_error create table st_bool_e0 using mt_bool tags (123abc) -sql create table st_bool_e1 using mt_bool tags ("123abc") -sql create table st_bool_e2 using mt_bool tags ("123") +sql_error create table st_bool_e1 using mt_bool tags ("123abc") +sql_error create table st_bool_e2 using mt_bool tags ("123") sql_error create table st_bool_e3 using mt_bool tags (abc) -sql create table st_bool_e4 using mt_bool tags ("abc") -sql create table st_bool_e5 using mt_bool tags (" ") -sql create table st_bool_e6 using mt_bool tags ('') +sql_error create table st_bool_e4 using mt_bool tags ("abc") +sql_error create table st_bool_e5 using mt_bool tags (" ") +sql_error create table st_bool_e6 using mt_bool tags ('') sql create table st_bool_f0 using mt_bool tags (true) sql create table st_bool_f1 using mt_bool tags (true) @@ -629,11 +629,11 @@ sql insert into st_bool_i5 using mt_bool tags (1) values (now, 1) sql insert into st_bool_i6 using mt_bool tags (1) values (now, 1) sql_error alter table st_bool_i0 set tag tagname=123abc -sql alter table st_bool_i1 set tag tagname="123abc" -sql alter table st_bool_i2 set tag tagname="123" +sql_error alter table st_bool_i1 set tag tagname="123abc" +sql_error alter table st_bool_i2 set tag tagname="123" sql_error alter table st_bool_i3 set tag tagname=abc -sql alter table st_bool_i4 set tag tagname="abc" -sql alter table st_bool_i5 set tag tagname=" " -sql alter table st_bool_i6 set tag tagname='' +sql_error alter table st_bool_i4 set tag tagname="abc" +sql_error alter table st_bool_i5 set tag tagname=" " +sql_error alter table st_bool_i6 set tag tagname='' system sh/exec.sh -n dnode1 -s stop -x SIGINT diff --git a/tests/script/tsim/parser/columnValue_double.sim b/tests/script/tsim/parser/columnValue_double.sim index bfcf338fac..002274c95f 100644 --- a/tests/script/tsim/parser/columnValue_double.sim +++ b/tests/script/tsim/parser/columnValue_double.sim @@ -28,22 +28,22 @@ if $data05 != NULL then endi sql create table st_double_2 using mt_double tags ('NULL') sql show tags from st_double_2 -if $data05 != 0.000000000 then +if $data05 != NULL then return -1 endi sql create table st_double_3 using mt_double tags ('NULL') sql show tags from st_double_3 -if $data05 != 0.000000000 then +if $data05 != NULL then return -1 endi sql create table st_double_4 using mt_double tags ("NULL") sql show tags from st_double_4 -if $data05 != 0.000000000 then +if $data05 != NULL then return -1 endi sql create table st_double_5 using mt_double tags ("NULL") sql show tags from st_double_5 -if $data05 != 0.000000000 then +if $data05 != NULL then return -1 endi sql create table st_double_6 using mt_double tags (-123.321) @@ -445,11 +445,11 @@ sql_error create table st_double_e0 using mt_double tags (-31.7976931348623157e+ #sql_error create table st_double_e0 using mt_double tags (12.80) truncate integer part #sql_error create table st_double_e0 using mt_double tags (-11.80) sql_error create table st_double_e0 using mt_double tags (123abc) -sql create table st_double_e0_1 using mt_double tags ("123abc") +sql_error create table st_double_e0_1 using mt_double tags ("123abc") sql_error create table st_double_e0 using mt_double tags (abc) -sql create table st_double_e0_2 using mt_double tags ("abc") -sql create table st_double_e0_3 using mt_double tags (" ") -sql create table st_double_e0_4 using mt_double tags ('') +sql_error create table st_double_e0_2 using mt_double tags ("abc") +sql_error create table st_double_e0_3 using mt_double tags (" ") +sql_error create table st_double_e0_4 using mt_double tags ('') sql create table st_double_e0 using mt_double tags (123) sql create table st_double_e1 using mt_double tags (123) @@ -502,7 +502,8 @@ sql_error insert into st_double_e20 using mt_double tags ("123abc") values (now, sql_error insert into st_double_e22 using mt_double tags (abc) values (now, -033) sql_error insert into st_double_e23 using mt_double tags ("abc") values (now, -033) sql_error insert into st_double_e24 using mt_double tags (" ") values (now, -033) -sql insert into st_double_e25 using mt_double tags ('') values (now, -033) +sql_error insert into st_double_e25 using mt_double tags ('') values (now, -033) +sql insert into st_double_e20 using mt_double tags ("123") values (now, -033) sql insert into st_double_e13 using mt_double tags (033) values (now, 00062) sql insert into st_double_e14 using mt_double tags (033) values (now, 00062) @@ -523,10 +524,11 @@ sql_error alter table st_double_e14 set tag tagname=-1.8976931348623157e+308 sql_error alter table st_double_e15 set tag tagname=131.7976931348623157e+308 sql_error alter table st_double_e16 set tag tagname=-131.7976931348623157e+308 sql_error alter table st_double_e19 set tag tagname=123abc -sql alter table st_double_e20 set tag tagname="123abc" +sql_error alter table st_double_e20 set tag tagname="123abc" sql_error alter table st_double_e22 set tag tagname=abc -sql alter table st_double_e23 set tag tagname="abc" -sql alter table st_double_e24 set tag tagname=" " -sql alter table st_double_e25 set tag tagname='' +sql_error alter table st_double_e23 set tag tagname="abc" +sql_error alter table st_double_e24 set tag tagname=" " +sql_error alter table st_double_e25 set tag tagname='' +sql alter table st_double_e25 set tag tagname='123' system sh/exec.sh -n dnode1 -s stop -x SIGINT diff --git a/tests/script/tsim/parser/columnValue_float.sim b/tests/script/tsim/parser/columnValue_float.sim index 4dcda33224..cf27dc6d19 100644 --- a/tests/script/tsim/parser/columnValue_float.sim +++ b/tests/script/tsim/parser/columnValue_float.sim @@ -29,22 +29,22 @@ if $data05 != NULL then endi sql create table st_float_2 using mt_float tags ('NULL') sql show tags from st_float_2 -if $data05 != 0.00000 then +if $data05 != NULL then return -1 endi sql create table st_float_3 using mt_float tags ('NULL') sql show tags from st_float_3 -if $data05 != 0.00000 then +if $data05 != NULL then return -1 endi sql create table st_float_4 using mt_float tags ("NULL") sql show tags from st_float_4 -if $data05 != 0.00000 then +if $data05 != NULL then return -1 endi sql create table st_float_5 using mt_float tags ("NULL") sql show tags from st_float_5 -if $data05 != 0.00000 then +if $data05 != NULL then return -1 endi sql create table st_float_6 using mt_float tags (-123.321) @@ -477,11 +477,11 @@ sql_error create table st_float_e0 using mt_float tags (-333.40282347e+38) #sql_error create table st_float_e0 using mt_float tags (12.80) truncate integer part #sql_error create table st_float_e0 using mt_float tags (-11.80) sql_error create table st_float_e0 using mt_float tags (123abc) -sql create table st_float_e0_1 using mt_float tags ("123abc") +sql_error create table st_float_e0_1 using mt_float tags ("123abc") sql_error create table st_float_e0 using mt_float tags (abc) -sql create table st_float_e0_2 using mt_float tags ("abc") -sql create table st_float_e0_3 using mt_float tags (" ") -sql create table st_float_e0_4 using mt_float tags ('') +sql_error create table st_float_e0_2 using mt_float tags ("abc") +sql_error create table st_float_e0_3 using mt_float tags (" ") +sql_error create table st_float_e0_4 using mt_float tags ('') sql create table st_float_e0 using mt_float tags (123) sql create table st_float_e1 using mt_float tags (123) @@ -534,7 +534,7 @@ sql_error insert into st_float_e20 using mt_float tags ("123abc") values (now, - sql_error insert into st_float_e22 using mt_float tags (abc) values (now, -033) sql_error insert into st_float_e23 using mt_float tags ("abc") values (now, -033) sql_error insert into st_float_e24 using mt_float tags (" ") values (now, -033) -sql insert into st_float_e25_3 using mt_float tags ('') values (now, -033) +sql_error insert into st_float_e25_3 using mt_float tags ('') values (now, -033) sql insert into st_float_e13 using mt_float tags (033) values (now, 00062) sql insert into st_float_e14 using mt_float tags (033) values (now, 00062) @@ -555,10 +555,10 @@ sql_error alter table st_float_e14 set tag tagname=-3.50282347e+38 sql_error alter table st_float_e15 set tag tagname=13.40282347e+38 sql_error alter table st_float_e16 set tag tagname=-13.40282347e+38 sql_error alter table st_float_e19 set tag tagname=123abc -sql alter table st_float_e20 set tag tagname="123abc" +sql_error alter table st_float_e20 set tag tagname="123abc" sql_error alter table st_float_e22 set tag tagname=abc -sql alter table st_float_e23 set tag tagname="abc" -sql alter table st_float_e24 set tag tagname=" " -sql alter table st_float_e25 set tag tagname='' +sql_error alter table st_float_e23 set tag tagname="abc" +sql_error alter table st_float_e24 set tag tagname=" " +sql_error alter table st_float_e25 set tag tagname='' system sh/exec.sh -n dnode1 -s stop -x SIGINT diff --git a/tests/script/tsim/parser/columnValue_int.sim b/tests/script/tsim/parser/columnValue_int.sim index e68ae6f13f..51b62052f7 100644 --- a/tests/script/tsim/parser/columnValue_int.sim +++ b/tests/script/tsim/parser/columnValue_int.sim @@ -28,10 +28,26 @@ if $data05 != NULL then return -1 endi -sql_error create table st_int_2 using mt_int tags ('NULL') -sql_error create table st_int_3 using mt_int tags ('NULL') -sql_error create table st_int_4 using mt_int tags ("NULL") -sql_error create table st_int_5 using mt_int tags ("NULL") +sql create table st_int_2 using mt_int tags ('NULL') +sql show tags from st_int_2 +if $data05 != NULL then + return -1 +endi +sql create table st_int_3 using mt_int tags ('NULL') +sql show tags from st_int_3 +if $data05 != NULL then + return -1 +endi +sql create table st_int_4 using mt_int tags ("NULL") +sql show tags from st_int_4 +if $data05 != NULL then + return -1 +endi +sql create table st_int_5 using mt_int tags ("NULL") +sql show tags from st_int_5 +if $data05 != NULL then + return -1 +endi sql create table st_int_6 using mt_int tags (-2147483647) sql show tags from st_int_6 @@ -346,7 +362,7 @@ sql_error create table st_int_e0 using mt_int tags ("123abc") sql_error create table st_int_e0 using mt_int tags (abc) sql_error create table st_int_e0 using mt_int tags ("abc") sql_error create table st_int_e0 using mt_int tags (" ") -sql create table st_int_e0_err2 using mt_int tags ('') +sql_error create table st_int_e0_err2 using mt_int tags ('') sql create table st_int_e0 using mt_int tags (123) sql create table st_int_e1 using mt_int tags (123) @@ -399,7 +415,10 @@ sql_error insert into st_int_e20 using mt_int tags ("123abc") values (now, -033) sql_error insert into st_int_e22 using mt_int tags (abc) values (now, -033) sql_error insert into st_int_e23 using mt_int tags ("abc") values (now, -033) sql_error insert into st_int_e24 using mt_int tags (" ") values (now, -033) -sql insert into st_int_e25_1 using mt_int tags ('') values (now, -033) +sql_error insert into st_int_e25_1 using mt_int tags ('') values (now, -033) +sql insert into st_int_e26_1 using mt_int tags ('123') values (now, -033) +sql insert into st_int_e27_1 using mt_int tags ('12.80') values (now, -033) +sql insert into st_int_e28_1 using mt_int tags ('-11.80') values (now, -033) sql insert into st_int_e13 using mt_int tags (033) values (now, 00062) sql insert into st_int_e14 using mt_int tags (033) values (now, 00062) @@ -424,6 +443,9 @@ sql_error alter table st_int_e20 set tag tagname="123abc" sql_error alter table st_int_e22 set tag tagname=abc sql_error alter table st_int_e23 set tag tagname="abc" sql_error alter table st_int_e24 set tag tagname=" " -sql alter table st_int_e25 set tag tagname='' +sql_error alter table st_int_e25 set tag tagname='' +sql alter table st_int_e26_1 set tag tagname='123' +sql alter table st_int_e27_1 set tag tagname='12.80' +sql alter table st_int_e28_1 set tag tagname='-11.80' system sh/exec.sh -n dnode1 -s stop -x SIGINT diff --git a/tests/script/tsim/parser/columnValue_smallint.sim b/tests/script/tsim/parser/columnValue_smallint.sim index f9be6ebd52..8b9be73ca0 100644 --- a/tests/script/tsim/parser/columnValue_smallint.sim +++ b/tests/script/tsim/parser/columnValue_smallint.sim @@ -31,10 +31,27 @@ if $data05 != NULL then return -1 endi -sql_error create table st_smallint_2 using mt_smallint tags ('NULL') -sql_error create table st_smallint_3 using mt_smallint tags ('NULL') -sql_error create table st_smallint_4 using mt_smallint tags ("NULL") -sql_error create table st_smallint_5 using mt_smallint tags ("NULL") + +sql create table st_smallint_2 using mt_smallint tags ('NULL') +sql show tags from st_smallint_2 +if $data05 != NULL then + return -1 +endi +sql create table st_smallint_3 using mt_smallint tags ('NULL') +sql show tags from st_smallint_3 +if $data05 != NULL then + return -1 +endi +sql create table st_smallint_4 using mt_smallint tags ("NULL") +sql show tags from st_smallint_4 +if $data05 != NULL then + return -1 +endi +sql create table st_smallint_5 using mt_smallint tags ("NULL") +sql show tags from st_smallint_5 +if $data05 != NULL then + return -1 +endi sql create table st_smallint_6 using mt_smallint tags (-32767) sql show tags from st_smallint_6 @@ -349,7 +366,8 @@ sql_error create table st_smallint_e0 using mt_smallint tags ("123abc") sql_error create table st_smallint_e0 using mt_smallint tags (abc) sql_error create table st_smallint_e0 using mt_smallint tags ("abc") sql_error create table st_smallint_e0 using mt_smallint tags (" ") -sql create table st_smallint_e0_1 using mt_smallint tags ('') +sql_error create table st_smallint_e0_1 using mt_smallint tags ('') +sql create table st_smallint_e0_2 using mt_smallint tags ('123') sql create table st_smallint_e0 using mt_smallint tags (123) sql create table st_smallint_e1 using mt_smallint tags (123) @@ -402,7 +420,8 @@ sql_error insert into st_smallint_e20 using mt_smallint tags ("123abc") values ( sql_error insert into st_smallint_e22 using mt_smallint tags (abc) values (now, -033) sql_error insert into st_smallint_e23 using mt_smallint tags ("abc") values (now, -033) sql_error insert into st_smallint_e24 using mt_smallint tags (" ") values (now, -033) -sql insert into st_smallint_e25 using mt_smallint tags ('') values (now, -033) +sql_error insert into st_smallint_e25 using mt_smallint tags ('') values (now, -033) +sql insert into st_smallint_e26 using mt_smallint tags ('123') values (now, -033) sql insert into st_smallint_e13 using mt_smallint tags (033) values (now, 00062) sql insert into st_smallint_e14 using mt_smallint tags (033) values (now, 00062) @@ -427,6 +446,7 @@ sql_error alter table st_smallint_e20 set tag tagname="123abc" sql_error alter table st_smallint_e22 set tag tagname=abc sql_error alter table st_smallint_e23 set tag tagname="abc" sql_error alter table st_smallint_e24 set tag tagname=" " -sql alter table st_smallint_e25 set tag tagname='' +sql_error alter table st_smallint_e25 set tag tagname='' +sql alter table st_smallint_e26 set tag tagname='123' system sh/exec.sh -n dnode1 -s stop -x SIGINT diff --git a/tests/script/tsim/parser/columnValue_tinyint.sim b/tests/script/tsim/parser/columnValue_tinyint.sim index 7d0f10a30d..5076280872 100644 --- a/tests/script/tsim/parser/columnValue_tinyint.sim +++ b/tests/script/tsim/parser/columnValue_tinyint.sim @@ -29,10 +29,26 @@ if $data05 != NULL then return -1 endi -sql_error create table st_tinyint_2 using mt_tinyint tags ('NULL') -sql_error create table st_tinyint_3 using mt_tinyint tags ('NULL') -sql_error create table st_tinyint_4 using mt_tinyint tags ("NULL") -sql_error create table st_tinyint_5 using mt_tinyint tags ("NULL") +sql create table st_tinyint_2 using mt_tinyint tags ('NULL') +sql show tags from st_tinyint_2 +if $data05 != NULL then + return -1 +endi +sql create table st_tinyint_3 using mt_tinyint tags ('NULL') +sql show tags from st_tinyint_3 +if $data05 != NULL then + return -1 +endi +sql create table st_tinyint_4 using mt_tinyint tags ("NULL") +sql show tags from st_tinyint_4 +if $data05 != NULL then + return -1 +endi +sql create table st_tinyint_5 using mt_tinyint tags ("NULL") +sql show tags from st_tinyint_5 +if $data05 != NULL then + return -1 +endi sql create table st_tinyint_6 using mt_tinyint tags (-127) sql show tags from st_tinyint_6 @@ -97,6 +113,40 @@ endi if $data01 != NULL then return -1 endi + +sql insert into st_tinyint_2 values (now, NULL) +sql select * from st_tinyint_2 +if $rows != 1 then + return -1 +endi +if $data01 != NULL then + return -1 +endi +sql insert into st_tinyint_3 values (now, NULL) +sql select * from st_tinyint_3 +if $rows != 1 then + return -1 +endi +if $data01 != NULL then + return -1 +endi +sql insert into st_tinyint_4 values (now, NULL) +sql select * from st_tinyint_4 +if $rows != 1 then + return -1 +endi +if $data01 != NULL then + return -1 +endi +sql insert into st_tinyint_5 values (now, NULL) +sql select * from st_tinyint_5 +if $rows != 1 then + return -1 +endi +if $data01 != NULL then + return -1 +endi + sql insert into st_tinyint_6 values (now, 127) sql select * from st_tinyint_6 if $rows != 1 then @@ -347,7 +397,7 @@ sql_error create table st_tinyint_e0 using mt_tinyint tags ("123abc") sql_error create table st_tinyint_e0 using mt_tinyint tags (abc) sql_error create table st_tinyint_e0 using mt_tinyint tags ("abc") sql_error create table st_tinyint_e0 using mt_tinyint tags (" ") -sql create table st_tinyint_e0_2 using mt_tinyint tags ('') +sql_error create table st_tinyint_e0_2 using mt_tinyint tags ('') sql create table st_tinyint_e0 using mt_tinyint tags (123) sql create table st_tinyint_e1 using mt_tinyint tags (123) @@ -400,7 +450,7 @@ sql_error insert into st_tinyint_e20 using mt_tinyint tags ("123abc") values (no sql_error insert into st_tinyint_e22 using mt_tinyint tags (abc) values (now, -033) sql_error insert into st_tinyint_e23 using mt_tinyint tags ("abc") values (now, -033) sql_error insert into st_tinyint_e24 using mt_tinyint tags (" ") values (now, -033) -sql insert into st_tinyint_e25 using mt_tinyint tags ('') values (now, -033) +sql_error insert into st_tinyint_e25 using mt_tinyint tags ('') values (now, -033) sql insert into st_tinyint_e13 using mt_tinyint tags (033) values (now, 00062) sql insert into st_tinyint_e14 using mt_tinyint tags (033) values (now, 00062) @@ -425,6 +475,6 @@ sql_error alter table st_tinyint_e20 set tag tagname="123abc" sql_error alter table st_tinyint_e22 set tag tagname=abc sql_error alter table st_tinyint_e23 set tag tagname="abc" sql_error alter table st_tinyint_e24 set tag tagname=" " -sql alter table st_tinyint_e25 set tag tagname='' +sql_error alter table st_tinyint_e25 set tag tagname='' system sh/exec.sh -n dnode1 -s stop -x SIGINT diff --git a/tests/script/tsim/parser/create_mt.sim b/tests/script/tsim/parser/create_mt.sim index dd2a7834c4..57647b3c7e 100644 --- a/tests/script/tsim/parser/create_mt.sim +++ b/tests/script/tsim/parser/create_mt.sim @@ -187,7 +187,7 @@ sql_error create table $tb using $mt tags (abc) sql_error create table $tb using $mt tags ('abc') sql drop table if exists $tb sql reset query cache -sql_error create table $tb using $mt tags (1e1) +sql create table $tb using $mt tags (1e1) sql_error create table $tb using $mt tags ('1e1') sql_error create table $tb using $mt tags (2147483649) diff --git a/tests/script/tsim/parser/null_char.sim b/tests/script/tsim/parser/null_char.sim index 9d476b5227..14e493d7a8 100644 --- a/tests/script/tsim/parser/null_char.sim +++ b/tests/script/tsim/parser/null_char.sim @@ -139,8 +139,8 @@ if $data03 != 0 then endi ### bool: -sql create table stx using mt2 tags ('NULL', '123aBc', 104, '123') -sql create table sty using mt2 tags ('NULL', '123aBc', 104, 'xtz') +sql_error create table stx using mt2 tags ('NULL', '123aBc', 104, '123') +sql_error create table sty using mt2 tags ('NULL', '123aBc', 104, 'xtz') sql create table st4 using mt2 tags ('NULL', '123aBc', 104, 'NULL') sql insert into st4 (ts, col1) values(now, 1) sql select tag1,tag2,tag3,tag5 from st4 @@ -156,7 +156,7 @@ endi if $data02 != 104 then return -1 endi -if $data03 != 0 then +if $data03 != NULL then print ==6== expect: NULL, actually: $data03 return -1 endi @@ -306,8 +306,8 @@ if $data02 != NULL then print ==10== expect: NULL, actually: $data02 return -1 endi -sql_error alter table st41 set tag tag_int = 'NULL' -sql alter table st41 set tag tag_int = '' +sql alter table st41 set tag tag_int = 'NULL' +sql_error alter table st41 set tag tag_int = '' sql_error alter table st41 set tag tag_int = abc379 ################### bool @@ -333,8 +333,8 @@ if $data03 != 1 then endi sql alter table st41 set tag tag_bool = 'NULL' sql select tag_binary, tag_nchar, tag_int, tag_bool, tag_float, tag_double from st41 -if $data03 != 0 then - print ==14== expect: 0, actually: $data03 +if $data03 != NULL then + print ==14== expect: NULL, actually: $data03 return -1 endi sql alter table st41 set tag tag_bool = NULL @@ -343,8 +343,8 @@ if $data03 != NULL then return -1 endi -sql alter table st41 set tag tag_bool = '123' -sql alter table st41 set tag tag_bool = '' +sql_error alter table st41 set tag tag_bool = '123' +sql_error alter table st41 set tag tag_bool = '' sql_error alter table st41 set tag tag_bool = abc379 ################### float @@ -396,10 +396,10 @@ if $data04 != -54.12346 then print ==19== expect: -54.12346, actually : $data04 return -1 endi -sql alter table st41 set tag tag_float = '' +sql_error alter table st41 set tag tag_float = '' -sql alter table st41 set tag tag_float = 'abc' -sql alter table st41 set tag tag_float = '123abc' +sql_error alter table st41 set tag tag_float = 'abc' +sql_error alter table st41 set tag tag_float = '123abc' sql_error alter table st41 set tag tag_float = abc ################### double @@ -428,14 +428,15 @@ if $data05 != NULL then endi sql alter table st41 set tag tag_double = 'NULL' sql select tag_binary, tag_nchar, tag_int, tag_bool, tag_float, tag_double from st41 -if $data05 != 0.000000000 then - print ==20== expect: 0.000000000, actually : $data05 +if $data05 != NULL then + print ==20== expect: NULL, actually : $data05 return -1 endi -sql alter table st41 set tag tag_double = '' -sql alter table st41 set tag tag_double = 'abc' -sql alter table st41 set tag tag_double = '123abc' +sql_error alter table st41 set tag tag_double = '' +sql alter table st41 set tag tag_double = '123' +sql_error alter table st41 set tag tag_double = 'abc' +sql_error alter table st41 set tag tag_double = '123abc' sql_error alter table st41 set tag tag_double = abc ################### bigint smallint tinyint @@ -459,8 +460,8 @@ if $data00 != -9223372036854775807 then endi sql alter table st51 set tag tag_bigint = -9223372036854775808 -sql_error alter table st51 set tag tag_bigint = 'NULL' -sql alter table st51 set tag tag_bigint = '' +sql alter table st51 set tag tag_bigint = 'NULL' +sql_error alter table st51 set tag tag_bigint = '' sql_error alter table st51 set tag tag_bigint = abc379 #### @@ -480,8 +481,8 @@ if $data01 != -32767 then endi sql alter table st51 set tag tag_smallint = -32768 -sql_error alter table st51 set tag tag_smallint = 'NULL' -sql alter table st51 set tag tag_smallint = '' +sql alter table st51 set tag tag_smallint = 'NULL' +sql_error alter table st51 set tag tag_smallint = '' sql_error alter table st51 set tag tag_smallint = abc379 #### @@ -499,8 +500,8 @@ if $data02 != -127 then endi sql alter table st51 set tag tag_tinyint = '-128' sql_error alter table st51 set tag tag_tinyint = 128 -sql_error alter table st51 set tag tag_tinyint = 'NULL' -sql alter table st51 set tag tag_tinyint = '' +sql alter table st51 set tag tag_tinyint = 'NULL' +sql_error alter table st51 set tag tag_tinyint = '' sql_error alter table st51 set tag tag_tinyint = abc379 # test end diff --git a/tests/script/tsim/tag/add.sim b/tests/script/tsim/tag/add.sim index 2b528c0255..e07771fdde 100644 --- a/tests/script/tsim/tag/add.sim +++ b/tests/script/tsim/tag/add.sim @@ -391,7 +391,7 @@ sql alter table $mt add tag tgcol6 bool sql reset query cache sql alter table $tb set tag tgcol4=4 sql alter table $tb set tag tgcol5='5' -sql alter table $tb set tag tgcol6='1' +sql_error alter table $tb set tag tgcol6='1' sql reset query cache sql select * from $mt where tgcol5 = '5' @@ -409,7 +409,7 @@ endi if $data03 != 5 then return -1 endi -if $data04 != 0 then +if $data04 != NULL then return -1 endi diff --git a/tests/system-test/1-insert/insert_column_value.py b/tests/system-test/1-insert/insert_column_value.py new file mode 100644 index 0000000000..ec1877e523 --- /dev/null +++ b/tests/system-test/1-insert/insert_column_value.py @@ -0,0 +1,159 @@ +import datetime +from util.log import * +from util.sql import * +from util.cases import * +from util.common import * +from util.dnodes import * +from util.sqlset import * + +DBNAME = "db" + +class TDTestCase: + def init(self, conn, logSql, replicaVar=1): + self.replicaVar = int(replicaVar) + tdLog.debug(f"start to excute {__file__}") + tdSql.init(conn.cursor()) + tdSql.execute(f'drop database if exists db') + tdSql.execute(f'create database if not exists db vgroups 1') + + def __create_tb(self, dbname="db"): + CREATE_STB_LIST = [ f"create table {dbname}.stb_vc (ts timestamp, c0 binary(50), c1 binary(50)) tags(t0 binary(50), t1 binary(50));", + f"create table {dbname}.stb_nc (ts timestamp, c0 nchar(50), c1 nchar(50)) tags(t0 nchar(50), t1 nchar(50));", + f"create table {dbname}.stb_ts (ts timestamp, c0 timestamp, c1 timestamp) tags(t0 timestamp, t1 timestamp);", + f"create table {dbname}.stb_bo (ts timestamp, c0 bool, c1 bool) tags(t0 bool, t1 bool);", + f"create table {dbname}.stb_vb (ts timestamp, c0 varbinary(50), c1 varbinary(50)) tags(t0 varbinary(50), t1 varbinary(50));", + f"create table {dbname}.stb_in (ts timestamp, c0 int, c1 int) tags(t0 int, t1 int);", + f"create table {dbname}.stb_fl (ts timestamp, c0 float, c1 float) tags(t0 float, t1 float);", + f"create table {dbname}.stb_db (ts timestamp, c0 float, c1 float) tags(t0 float, t1 float);", + f"create table {dbname}.stb_ge (ts timestamp, c0 geometry(512), c1 geometry(512)) tags(t0 geometry(512), t1 geometry(512));", + f"create table {dbname}.stb_js (ts timestamp, c0 int) tags(t0 json);" ] + for _stb in CREATE_STB_LIST: + tdSql.execute(_stb) + tdSql.query(f'show {dbname}.stables') + tdSql.checkRows(len(CREATE_STB_LIST)) + + def __insert_query_common(self, dbname="db", stbname="", ctbname="", oklist=[], kolist=[], okv=None): + for _l in kolist: + for _e in _l: + tdSql.error(f'create table {dbname}.{ctbname} using {dbname}.{stbname} tags(%s, {okv})' %(_e)) + tdSql.error(f'create table {dbname}.{ctbname} using {dbname}.{stbname} tags({okv}, %s)' %(_e)) + tdSql.error(f'create table {dbname}.{ctbname} using {dbname}.{stbname} tags(%s, %s)' %(_e, _e)) + tdSql.error(f'insert into {dbname}.{ctbname} using {dbname}.{stbname} tags({okv}, %s) values(now, {okv}, {okv})' %(_e)) + tdSql.error(f'insert into {dbname}.{ctbname} using {dbname}.{stbname} tags(%s, {okv}) values(now, {okv}, {okv})' %(_e)) + tdSql.error(f'insert into {dbname}.{ctbname} using {dbname}.{stbname} tags({okv}, {okv}) values(now, %s, {okv})' %(_e)) + tdSql.error(f'insert into {dbname}.{ctbname} using {dbname}.{stbname} tags({okv}, {okv}) values(now, {okv}, %s)' %(_e)) + tdSql.error(f'insert into {dbname}.{ctbname} using {dbname}.{stbname} tags({okv}, {okv}) values(now, %s, %s)' %(_e, _e)) + tdSql.execute(f'insert into {dbname}.{ctbname} using {dbname}.{stbname} tags({okv}, {okv}) values(now, {okv}, {okv})') + tdSql.query(f'select * from {dbname}.{stbname}') + tdSql.checkRows(1) + tdSql.execute(f'drop table {dbname}.{ctbname}') + for _l in oklist: + for _e in _l: + tdSql.execute(f'create table {dbname}.{ctbname} using {dbname}.{stbname} tags(%s, {okv})' %(_e)) + tdSql.execute(f'insert into {dbname}.{ctbname} values(now + 0s, %s, {okv})' %(_e)) + tdSql.execute(f'insert into {dbname}.{ctbname} values(now + 1s, {okv}, %s)' %(_e)) + tdSql.execute(f'insert into {dbname}.{ctbname} values(now + 2s, %s, %s)' %(_e, _e)) + tdSql.query(f'select * from {dbname}.{stbname}') + tdSql.checkRows(3) + tdSql.execute(f'drop table {dbname}.{ctbname}') + tdSql.execute(f'create table {dbname}.{ctbname} using {dbname}.{stbname} tags(%s, %s)' %(_e, _e)) + tdSql.execute(f'insert into {dbname}.{ctbname} values(now, %s, %s)' %(_e, _e)) + tdSql.query(f'select * from {dbname}.{stbname}') + tdSql.checkRows(1) + tdSql.execute(f'drop table {dbname}.{ctbname}') + tdSql.execute(f'insert into {dbname}.{ctbname} using {dbname}.{stbname} tags(%s, {okv}) values(now, %s, {okv})' %(_e, _e)) + tdSql.query(f'select * from {dbname}.{stbname}') + tdSql.checkRows(1) + tdSql.execute(f'drop table {dbname}.{ctbname}') + tdSql.execute(f'insert into {dbname}.{ctbname} using {dbname}.{stbname} tags({okv}, %s) values(now, {okv}, %s)' %(_e, _e)) + tdSql.query(f'select * from {dbname}.{stbname}') + tdSql.checkRows(1) + tdSql.execute(f'drop table {dbname}.{ctbname}') + tdSql.execute(f'insert into {dbname}.{ctbname} using {dbname}.{stbname} tags(%s, %s) values(now, %s, %s)' %(_e, _e, _e, _e)) + tdSql.query(f'select * from {dbname}.{stbname}') + tdSql.checkRows(1) + tdSql.execute(f'drop table {dbname}.{ctbname}') + + def __insert_query_exec(self): + STR_EMPTY = ['\'\'', "\"\""] + STR_INTEGER = ["\"123\"", '\'+12\'', '\'+0\'', '\'-0\'', '\'-128\''] + STR_FLOAT = ['\'123.1\'', "\"-23.001\"", "\"+0.001\"" ] + STR_FLOAT_E = ['\'1e1\'', "\"-0.1E+1\"", "\"1e-2\""] + STR_MISC = ['\' \'', "\" \"", "\"123ab\"", '\'123d\'', '\'-12s\'', '\'\x012\'', '\'x12\'', '\'x\'', '\'NULL \''] + STR_OPTR = ['\'1*10\'', '\'1+2\'', '\'-2-0\'','\'1%2\'', '\'2/0\'', '\'1&31\''] + STR_TSK = ['\'now\'', '\'today\''] + STR_TSK_MISC = ['\'now+1s\'', '\' now\'', '\'today \'', '\'today+1m\'', '\'today-1w\''] + STR_TSKP = ['\'now()\'', '\'today()\''] + STR_TSKP_MISC = ['\'now()+1s\'', '\' now()\'', '\'now( )\'', '\'today() \'', '\'today())\'', '\'today()+1m\'', '\'today()-1w\''] + STR_BOOL = ['\'true\'', '\'false\'', '\'TRUE\'', '\'FALSE\'', '\'tRuE\'', '\'falsE\''] + STR_TS = ["\"2024-02-01 00:00:01.001-08:00\"", "\'2024-02-01T00:00:01.001+09:00\'", "\"2024-02-01\"", "\'2024-02-02 00:00:01\'", "\'2024-02-02 00:00:01.009\'"] + STR_VARBIN = ['\'\\x\'', '\'\\x12ab\''] + STR_JSON = ['\'{\"k1\":\"v1\"}\'', '\'[]\'', '\'{}\''] + STR_GEO = ['\'POINT(1.0 1.0)\'', '\'LINESTRING(1.00 +2.0, 2.1 -3.2, 5.00 5.01)\'', '\'POLYGON((1.0 1.0, -2.0 +2.0, 1.0 1.0))\'' ] + STR_NULL = ['\'NuLl\'', '\'null\'', '\'NULL\''] + + RAW_INTEGER = ['123', '+0123', '-0128', '+0', '-0', '0'] + RAW_FLOAT = ['123.012', '-128.001', '-0.0', '0.0', '+0.0'] + RAW_FLOAT_E = ['1e-100', "-1E-10", '+0.1E+2'] + RAW_MISC = ['123abc', "123c", '-123d', '+', '-', ' *', ' /', '% ', '&', "|", "^", "&&", "||", "!", " =", 'now+1 s', 'now-1','now-1y','now+2 d', + 'today+1 s', 'today-1','today-1y','today+2 d', 'now()+1 s', 'now()-1','now()-1y','now()+2 d', 'today()+1 s', 'today()-1','today()-1y','today()+2 d'] + RAW_OPTR = ['1*10', '1+2', '-2-0','1%2', '2/0', '1&31'] + RAW_TSK = [' now ', 'today '] + RAW_TSK_OPTR = [' now +1s', 'today + 2d'] + RAW_TSKP = ['now( ) ', ' toDay() '] + RAW_TSKP_OPTR = [' noW ( ) + 1s', 'nOw( ) + 2D', 'NOW () + 000s', ' today()+1M', 'today( ) - 1w ', 'TodaY ( ) - 1U '] + RAW_BOOL = ['true', 'false', ' TRUE ', 'FALSE ', ' tRuE', ' falsE '] + RAW_NULL = ['NuLl', 'null', 'NULL', ' NULL '] + + OK_VC = [STR_EMPTY, STR_INTEGER, STR_FLOAT, STR_FLOAT_E, STR_MISC, STR_TSK, STR_TSK_MISC, STR_TSKP, STR_TSKP_MISC, STR_BOOL, STR_TS, STR_VARBIN, + STR_JSON, STR_GEO, STR_NULL, RAW_INTEGER, RAW_FLOAT, RAW_FLOAT_E, RAW_TSK, RAW_BOOL, RAW_NULL] + KO_VC = [RAW_MISC, RAW_OPTR, RAW_TSK_OPTR, RAW_TSKP, RAW_TSKP_OPTR] + OK_NC = [] + KO_NC = [] + OK_TS = [STR_TSK, STR_TSKP, STR_NULL, RAW_INTEGER, RAW_TSK, RAW_TSK_OPTR, RAW_TSKP, RAW_TSKP_OPTR, RAW_NULL] + KO_TS = [STR_EMPTY, STR_INTEGER, STR_FLOAT, STR_FLOAT_E, STR_MISC, STR_OPTR, STR_TSK_MISC, STR_BOOL, STR_VARBIN, + STR_JSON,STR_GEO, STR_FLOAT, RAW_FLOAT_E, RAW_MISC, RAW_OPTR, RAW_BOOL] + OK_BO = [] + KO_BO = [] + OK_VB = [] + KO_VB = [] + OK_IN = [] + KO_IN = [] + OK_FL = [] + KO_FL = [] + OK_DB = [] + KO_DB = [] + OK_GE = [] + KO_GE = [] + OK_JS = [] + KO_JS = [] + + PARAM_LIST = [ + ["db", "stb_vc", "ctb_vc", OK_VC, KO_VC, "\'vc\'"], + ["db", "stb_nc", "ctb_nc", OK_NC, KO_NC, "\'nc\'"], + ["db", "stb_ts", "ctb_ts", OK_TS, KO_TS, "now"], + ["db", "stb_bo", "ctb_bo", OK_BO, KO_BO, "true"], + ["db", "stb_vb", "ctb_vb", OK_VB, KO_VB, "\'\\x\'"], + ["db", "stb_in", "ctb_in", OK_IN, KO_IN, "1"], + ["db", "stb_fl", "ctb_fl", OK_FL, KO_FL, "1.0"], + ["db", "stb_db", "ctb_db", OK_DB, KO_DB, "1.0"], + ["db", "stb_ge", "ctb_ge", OK_GE, KO_GE, "\'POINT(1.0 1.0)\'"], + ["db", "stb_js", "ctb_js", OK_JS, KO_JS, "\'{\'k1\':\'v1\',\k2\':\'v2\'}\'"], + ] + + for _pl in PARAM_LIST: + self.__insert_query_common(_pl[0], _pl[1], _pl[2], _pl[3], _pl[4], _pl[5]) + + + def run(self): + tdLog.printNoPrefix("==========step1:create table") + self.__create_tb() + self.__insert_query_exec() + + + def stop(self): + tdSql.close() + tdLog.success(f"{__file__} successfully executed") + +tdCases.addLinux(__file__, TDTestCase()) +tdCases.addWindows(__file__, TDTestCase()) diff --git a/tests/system-test/2-query/count_partition.py b/tests/system-test/2-query/count_partition.py index e970b00cec..3077f5bb13 100644 --- a/tests/system-test/2-query/count_partition.py +++ b/tests/system-test/2-query/count_partition.py @@ -22,7 +22,7 @@ class TDTestCase: for i in range(tb_nums): tbname = f"{dbname}.sub_{stb_name}_{i}" ts = self.ts + i*10000 - tdSql.execute(f"create table {tbname} using {dbname}.{stb_name} tags ({ts} , {i} , {i}*10 ,{i}*1.0,{i}*1.0 , 1 , 2, 'true', 'binary_{i}' ,'nchar_{i}',{i},{i},10,20 )") + tdSql.execute(f"create table {tbname} using {dbname}.{stb_name} tags ({ts} , {i} , %d , %f , %f , 1 , 2, 'true', 'binary_{i}' ,'nchar_{i}',{i},{i},10,20 )"%(i*10,i*1.0,i*1.0)) for row in range(row_nums): ts = self.ts + row*1000 diff --git a/tests/system-test/2-query/max_partition.py b/tests/system-test/2-query/max_partition.py index fbd3488aab..7e43597948 100644 --- a/tests/system-test/2-query/max_partition.py +++ b/tests/system-test/2-query/max_partition.py @@ -21,7 +21,7 @@ class TDTestCase: for i in range(tb_nums): tbname = f"{dbname}.sub_{stb_name}_{i}" ts = self.ts + i*1000*120 - tdSql.execute(f"create table {tbname} using {dbname}.{stb_name} tags ({ts} , {i} , {i}*10 ,{i}*1.0,{i}*1.0 , 1 , 2, 'true', 'binary_{i}' ,'nchar_{i}',{i},{i},10,20 )") + tdSql.execute(f"create table {tbname} using {dbname}.{stb_name} tags ({ts} , {i} , %d , %f , %f , 1 , 2, 'true', 'binary_{i}' ,'nchar_{i}',{i},{i},10,20 )"%(i*10,i*1.0,i*1.0)) for row in range(row_nums): ts = ts + row*1000 diff --git a/tests/system-test/2-query/tagFilter.py b/tests/system-test/2-query/tagFilter.py index 24bd6c236b..a8106a7051 100644 --- a/tests/system-test/2-query/tagFilter.py +++ b/tests/system-test/2-query/tagFilter.py @@ -1,3 +1,4 @@ +import datetime from util.log import * from util.sql import * from util.cases import * @@ -53,55 +54,200 @@ class TDTestCase: tdSql.checkRows(0) def __ts4421(self, dbname="db", stbname='stb4421', ctbname='ctb4421'): - TAG_TYPE = ['varchar', 'nchar'] - TAG_LEN = [2, 8, 200] - TAG_VAL = [0, -200, 123456789] - TAG_RESULT = [True,False,False,True,True,False,True,True,True,True,False,False,True,True,False,True,True,True] + TAG_BIND = [True, False] + TAG_TYPE = ['varchar', 'nchar'] + TAG_LEN = [2, 8, 200] + TAG_VAL_INT = [0, -200, 123456789] + TAG_VAL_STR = ["noW()", "now", "'now'", "todAy()", "today", "\"today\"" ] + TAG_VAL_BOOL_INT = [ -1, 1, 0, -0] + TAG_VAL_BOOL_STR = ["TrUe", "\"true\"","fALse", "'FALSE'"] + TAG_VAL_TIMESTAMP = ["now()", "NoW", "'now'", "\"now()\"", "toDay()", "toDaY", "'today'", "\"today()\"", "\"2200-01-01 08:00:00\"", "'2200-01-02'","\"2200-01-02T00:00:00.000Z\"", "'2200-01-02T00:00:00.000'", "2200-01-01 08:00:00", "\"2200-01-02'", "2200-01-02T00:00:00.000Z"] + TAG_RESULT_INT = [True,False,False,True,True,False,True,True,True,True,False,False,True,True,False,True,True,True] + TAG_RESULT_STR = [False,False,False,False,False,False,False,True,True,False,True,True,False,True,True,False,True,True,False,False,False,False,False,False,False,True,True,False,True,True,False,True,True,False,True,True] + TAG_RESULT_BOOL = ["True","True","False","False"] + TAG_RESULT_TIMESTAMP = [True, True, True, True, True, True, True, True, True, True, True, True, False, False, False] + # check int for vartype(one tag) nTagCtb = 0 for tagType in TAG_TYPE: for tagLen in TAG_LEN: - tdSql.execute(f'create stable {dbname}.{stbname}(ts timestamp, f1 int) tags(t1 %s(%d))'%(tagType, tagLen)) - for tagVal in TAG_VAL: - if TAG_RESULT[nTagCtb] == False: - tdSql.error(f'create table {dbname}.{ctbname} using {dbname}.{stbname} tags(%d)'%(tagVal)) - tdSql.error(f'insert into {dbname}.{ctbname} using {dbname}.{stbname} tags(%d) values(now,1)'%(tagVal)) - tdSql.error(f'create table {dbname}.{ctbname} using {dbname}.{stbname} tags("%d")'%(tagVal)) - tdSql.error(f'insert into {dbname}.{ctbname} using {dbname}.{stbname} tags("%d") values(now,1)'%(tagVal)) - tdSql.error(f"create table {dbname}.{ctbname} using {dbname}.{stbname} tags('%d')"%(tagVal)) - tdSql.error(f"insert into {dbname}.{ctbname} using {dbname}.{stbname} tags('%d') values(now,1)"%(tagVal)) - else: - # integer as tag value - tdSql.execute(f'create table {dbname}.{ctbname} using {dbname}.stb4421 tags(%d)'%(tagVal)) - tdSql.execute(f'insert into {dbname}.{ctbname} values(now,1)') - tdSql.query(f'select * from {dbname}.{ctbname} where t1="%s"'%(tagVal)) - tdSql.checkRows(1) - tdSql.execute(f'drop table {dbname}.{ctbname}') - tdSql.execute(f'insert into {dbname}.{ctbname} using {dbname}.{stbname} tags(%d) values(now,1)'%(tagVal)) - tdSql.query(f'select * from {dbname}.{ctbname} where t1="%s"'%(tagVal)) - tdSql.checkRows(1) - tdSql.execute(f'drop table {dbname}.{ctbname}') - # string as tag value - tdSql.execute(f'create table {dbname}.{ctbname} using {dbname}.stb4421 tags("%d")'%(tagVal)) - tdSql.execute(f'insert into {dbname}.{ctbname} values(now,1)') - tdSql.query(f'select * from {dbname}.{ctbname} where t1="%s"'%(tagVal)) - tdSql.checkRows(1) - tdSql.execute(f'drop table {dbname}.{ctbname}') - tdSql.execute(f'insert into {dbname}.{ctbname} using {dbname}.{stbname} tags("%d") values(now,1)'%(tagVal)) - tdSql.query(f'select * from {dbname}.{ctbname} where t1="%s"'%(tagVal)) - tdSql.checkRows(1) - tdSql.execute(f'drop table {dbname}.{ctbname}') - tdSql.execute(f"create table {dbname}.{ctbname} using {dbname}.stb4421 tags('%d')"%(tagVal)) - tdSql.execute(f"insert into {dbname}.{ctbname} values(now,1)") - tdSql.query(f"select * from {dbname}.{ctbname} where t1='%s'"%(tagVal)) - tdSql.checkRows(1) - tdSql.execute(f"drop table {dbname}.{ctbname}") - tdSql.execute(f"insert into {dbname}.{ctbname} using {dbname}.{stbname} tags('%d') values(now,1)"%(tagVal)) - tdSql.query(f"select * from {dbname}.{ctbname} where t1='%s'"%(tagVal)) - tdSql.checkRows(1) - tdSql.execute(f"drop table {dbname}.{ctbname}") + tdSql.execute(f'create stable {dbname}.{stbname}(ts timestamp, f1 int) tags(t1 %s(%d))'%(tagType,tagLen)) + for tagVal in TAG_VAL_INT: + for tagBind in TAG_BIND: + if tagBind == True: + bindStr = "(t1)" + else: + bindStr = "" + tdLog.info(f'nTagCtb={nTagCtb}, tagType={tagType}, tagLen = {tagLen}, tagVal = {tagVal}, tagBind={tagBind}') + if TAG_RESULT_INT[nTagCtb] == False: + tdSql.error(f'create table {dbname}.{ctbname} using {dbname}.{stbname} %s tags(%d)'%(bindStr,tagVal)) + tdSql.error(f'insert into {dbname}.{ctbname} using {dbname}.{stbname} %s tags(%d) values(now,1)'%(bindStr,tagVal)) + tdSql.error(f'create table {dbname}.{ctbname} using {dbname}.{stbname} %s tags("%d")'%(bindStr,tagVal)) + tdSql.error(f'insert into {dbname}.{ctbname} using {dbname}.{stbname} %s tags("%d") values(now,1)'%(bindStr,tagVal)) + tdSql.error(f"create table {dbname}.{ctbname} using {dbname}.{stbname} %s tags('%d')"%(bindStr,tagVal)) + tdSql.error(f"insert into {dbname}.{ctbname} using {dbname}.{stbname} %s tags('%d') values(now,1)"%(bindStr,tagVal)) + else: + # integer as tag value + tdSql.execute(f'create table {dbname}.{ctbname} using {dbname}.{stbname} %s tags(%d)'%(bindStr,tagVal)) + tdSql.execute(f'insert into {dbname}.{ctbname} values(now,1)') + tdSql.execute(f'insert into {dbname}.{ctbname}t using {dbname}.{stbname} %s tags(%d) values(now,1)'%(bindStr,tagVal)) + tdSql.query(f'select * from {dbname}.{stbname} where t1="%d"'%(tagVal)) + tdSql.checkRows(2) + tdSql.execute(f'drop table {dbname}.{ctbname}') + tdSql.execute(f'drop table {dbname}.{ctbname}t') + # string as tag value + tdSql.execute(f'create table {dbname}.{ctbname} using {dbname}.{stbname} %s tags("%d")'%(bindStr,tagVal)) + tdSql.execute(f'insert into {dbname}.{ctbname} values(now,1)') + tdSql.execute(f'insert into {dbname}.{ctbname}t using {dbname}.{stbname} %s tags("%d") values(now,1)'%(bindStr,tagVal)) + tdSql.query(f'select * from {dbname}.{stbname} where t1="%d"'%(tagVal)) + tdSql.checkRows(2) + tdSql.execute(f'drop table {dbname}.{ctbname}') + tdSql.execute(f'drop table {dbname}.{ctbname}t') + tdSql.execute(f"create table {dbname}.{ctbname} using {dbname}.{stbname} %s tags('%d')"%(bindStr,tagVal)) + tdSql.execute(f"insert into {dbname}.{ctbname} values(now,1)") + tdSql.execute(f"insert into {dbname}.{ctbname}t using {dbname}.{stbname} %s tags('%d') values(now,1)"%(bindStr,tagVal)) + tdSql.query(f"select * from {dbname}.{stbname} where t1='%d'"%(tagVal)) + tdSql.checkRows(2) + tdSql.execute(f'drop table {dbname}.{ctbname}') + tdSql.execute(f'drop table {dbname}.{ctbname}t') nTagCtb += 1 tdSql.execute(f'drop table {dbname}.{stbname}') + + # check int for vartype(two tags/bind tags) + nTagCtb = 0 + for tagType in TAG_TYPE: + for tagLen in TAG_LEN: + tdSql.execute(f'create stable {dbname}.{stbname}(ts timestamp, f1 int) tags(t1 %s(%d),t2 %s(%d) )'%(tagType,tagLen,tagType,tagLen)) + for tagVal in TAG_VAL_INT: + for tagBind in TAG_BIND: + if tagBind == True: + bindStr = "(t1,t2)" + else: + bindStr = "" + if TAG_RESULT_INT[nTagCtb] == False: + tdSql.error(f'create table {dbname}.{ctbname} using {dbname}.{stbname} %s tags(%d,%d)'%(bindStr,tagVal,tagVal)) + tdSql.error(f'insert into {dbname}.{ctbname} using {dbname}.{stbname} %s tags(%d,%d) values(now,1)'%(bindStr,tagVal,tagVal)) + tdSql.error(f'create table {dbname}.{ctbname} using {dbname}.{stbname} %s tags("%d","%d")'%(bindStr,tagVal,tagVal)) + tdSql.error(f'insert into {dbname}.{ctbname} using {dbname}.{stbname} %s tags("%d","%d") values(now,1)'%(bindStr,tagVal,tagVal)) + tdSql.error(f"create table {dbname}.{ctbname} using {dbname}.{stbname} %s tags('%d','%d')"%(bindStr,tagVal,tagVal)) + tdSql.error(f"insert into {dbname}.{ctbname} using {dbname}.{stbname} %s tags('%d','%d') values(now,1)"%(bindStr,tagVal,tagVal)) + else: + # integer as tag value + tdSql.execute(f'create table {dbname}.{ctbname} using {dbname}.{stbname} %s tags(%d,%d)'%(bindStr,tagVal,tagVal)) + tdSql.execute(f'insert into {dbname}.{ctbname} values(now,1)') + tdSql.execute(f'insert into {dbname}.{ctbname}t using {dbname}.{stbname} %s tags(%d,%d) values(now,1)'%(bindStr,tagVal,tagVal)) + tdSql.query(f"select * from {dbname}.{stbname} where t1='%d' and t2='%d'"%(tagVal,tagVal)) + tdSql.checkRows(2) + tdSql.execute(f'drop table {dbname}.{ctbname}') + tdSql.execute(f'drop table {dbname}.{ctbname}t') + # string as tag value + tdSql.execute(f'create table {dbname}.{ctbname} using {dbname}.{stbname} %s tags("%d","%d")'%(bindStr,tagVal,tagVal)) + tdSql.execute(f'insert into {dbname}.{ctbname} values(now,1)') + tdSql.execute(f'insert into {dbname}.{ctbname}t using {dbname}.{stbname} %s tags("%d","%d") values(now,1)'%(bindStr,tagVal,tagVal)) + tdSql.query(f'select * from {dbname}.{stbname} where t1="%d" and t2="%d"'%(tagVal,tagVal)) + tdSql.checkRows(2) + tdSql.execute(f'drop table {dbname}.{ctbname}') + tdSql.execute(f'drop table {dbname}.{ctbname}t') + tdSql.execute(f"create table {dbname}.{ctbname} using {dbname}.{stbname} %s tags('%d','%d')"%(bindStr,tagVal,tagVal)) + tdSql.execute(f"insert into {dbname}.{ctbname} values(now,1)") + tdSql.execute(f"insert into {dbname}.{ctbname}t using {dbname}.{stbname} %s tags('%d','%d') values(now,1)"%(bindStr,tagVal,tagVal)) + tdSql.query(f"select * from {dbname}.{stbname} where t1='%d' and t2='%d'"%(tagVal,tagVal)) + tdSql.checkRows(2) + tdSql.execute(f'drop table {dbname}.{ctbname}') + tdSql.execute(f'drop table {dbname}.{ctbname}t') + nTagCtb += 1 + tdSql.execute(f'drop table {dbname}.{stbname}') + + # check now/today for vartype + nTagCtb = 0 + for tagType in TAG_TYPE: + for tagLen in TAG_LEN: + tdSql.execute(f'create stable {dbname}.{stbname}(ts timestamp, f1 int) tags(t1 %s(%d))'%(tagType,tagLen)) + for tagVal in TAG_VAL_STR: + for tagBind in TAG_BIND: + if tagBind == True: + bindStr = "(t1)" + else: + bindStr = "" + if TAG_RESULT_STR[nTagCtb] == False: + tdSql.error(f'create table {dbname}.{ctbname} using {dbname}.{stbname} %s tags(%s)'%(bindStr,tagVal)) + tdSql.error(f'insert into {dbname}.{ctbname} using {dbname}.{stbname} %s tags(%s) values(now,1)'%(bindStr,tagVal)) + else: + tdSql.execute(f'create table {dbname}.{ctbname} using {dbname}.{stbname} %s tags(%s)'%(bindStr,tagVal)) + tdSql.execute(f'insert into {dbname}.{ctbname} values(now,1)') + tdSql.execute(f'insert into {dbname}.{ctbname}t using {dbname}.{stbname} %s tags(%s) values(now,1)'%(bindStr,tagVal)) + if tagVal.startswith("'") or tagVal.startswith("\""): + tdSql.query(f'select * from {dbname}.{stbname} where t1=%s'%(tagVal)) + else: + tdSql.query(f'select * from {dbname}.{stbname} where t1=\"%s\"'%(tagVal)) + tdSql.checkRows(2) + tdSql.execute(f'drop table {dbname}.{ctbname}') + tdSql.execute(f'drop table {dbname}.{ctbname}t') + nTagCtb += 1 + tdSql.execute(f'drop table {dbname}.{stbname}') + + # check int for bool + nTagCtb = 0 + tdSql.execute(f'create stable {dbname}.{stbname}(ts timestamp, f1 int) tags(t1 bool)') + for tagVal in TAG_VAL_BOOL_INT: + for tagBind in TAG_BIND: + if tagBind == True: + bindStr = "(t1)" + else: + bindStr = "" + tdSql.execute(f'create table {dbname}.{ctbname} using {dbname}.{stbname} %s tags(%d)'%(bindStr,tagVal)) + tdSql.execute(f'insert into {dbname}.{ctbname} values(now,1)') + tdSql.execute(f'insert into {dbname}.{ctbname}t using {dbname}.{stbname} %s tags(%d) values(now,1)'%(bindStr,tagVal)) + tdSql.query(f'select * from {dbname}.{stbname} where t1=%s'%(TAG_RESULT_BOOL[nTagCtb])) + tdSql.checkRows(2) + tdSql.execute(f'drop table {dbname}.{ctbname}') + tdSql.execute(f'drop table {dbname}.{ctbname}t') + nTagCtb += 1 + tdSql.execute(f'drop table {dbname}.{stbname}') + + # check str for bool + nTagCtb = 0 + tdSql.execute(f'create stable {dbname}.{stbname}(ts timestamp, f1 int) tags(t1 bool)') + for tagVal in TAG_VAL_BOOL_STR: + for tagBind in TAG_BIND: + if tagBind == True: + bindStr = "(t1)" + else: + bindStr = "" + tdSql.execute(f'create table {dbname}.{ctbname} using {dbname}.{stbname} %s tags(%s)'%(bindStr,tagVal)) + tdSql.execute(f'insert into {dbname}.{ctbname} values(now,1)') + tdSql.execute(f'insert into {dbname}.{ctbname}t using {dbname}.{stbname} %s tags(%s) values(now,1)'%(bindStr,tagVal)) + tdSql.query(f'select * from {dbname}.{stbname} where t1=%s'%(TAG_RESULT_BOOL[nTagCtb])) + tdSql.checkRows(2) + tdSql.execute(f'drop table {dbname}.{ctbname}') + tdSql.execute(f'drop table {dbname}.{ctbname}t') + nTagCtb += 1 + tdSql.execute(f'drop table {dbname}.{stbname}') + + # check misc for timestamp + nTagCtb = 0 + tdSql.execute(f'create stable {dbname}.{stbname}(ts timestamp, f1 int) tags(t1 timestamp)') + checkTS = datetime.datetime.today() - datetime.timedelta(days=1) + for tagVal in TAG_VAL_TIMESTAMP: + for tagBind in TAG_BIND: + if tagBind == True: + bindStr = "(t1)" + else: + bindStr = "" + if TAG_RESULT_TIMESTAMP[nTagCtb] == False: + tdSql.error(f'create table {dbname}.{ctbname} using {dbname}.{stbname} %s tags(%s)'%(bindStr,tagVal)) + tdSql.error(f'insert into {dbname}.{ctbname}t using {dbname}.{stbname} %s tags(%s) values(now,1)'%(bindStr,tagVal)) + else: + tdSql.execute(f'create table {dbname}.{ctbname} using {dbname}.{stbname} %s tags(%s)'%(bindStr,tagVal)) + tdSql.execute(f'insert into {dbname}.{ctbname} values(now,1)') + tdSql.execute(f'insert into {dbname}.{ctbname}t using {dbname}.{stbname} %s tags(%s) values(now,1)'%(bindStr,tagVal)) + tdSql.query(f'select * from {dbname}.{stbname} where t1>"{checkTS}"') + tdSql.checkRows(2) + tdSql.execute(f'drop table {dbname}.{ctbname}') + tdSql.execute(f'drop table {dbname}.{ctbname}t') + nTagCtb += 1 + tdSql.execute(f'drop table {dbname}.{stbname}') + def run(self): tdLog.printNoPrefix("==========step1:create table") @@ -118,4 +264,4 @@ class TDTestCase: tdLog.success(f"{__file__} successfully executed") tdCases.addLinux(__file__, TDTestCase()) -tdCases.addWindows(__file__, TDTestCase()) +tdCases.addWindows(__file__, TDTestCase()) \ No newline at end of file diff --git a/tests/system-test/2-query/tsbsQuery.py b/tests/system-test/2-query/tsbsQuery.py index 5a49f653ec..60e710e4f1 100644 --- a/tests/system-test/2-query/tsbsQuery.py +++ b/tests/system-test/2-query/tsbsQuery.py @@ -33,7 +33,7 @@ class TDTestCase: for i in range(ctbNum): tagValue = 'beijing' if (i % 10 == 0): - sql += f" {dbName}.%s%d using %s (name,fleet,driver,device_version,load_capacity,fuel_capacity,nominal_fuel_consumption) tags('truck_%d', 'South%d','Trish%d','v2.%d', 1500+%d*20, 150+%d*2, 5+%d)"%(ctbPrefix,i,stbName,i,i,i,i,(1500+i*20),(150+i*2),(5+i)) + sql += f" {dbName}.%s%d using %s (name,fleet,driver,device_version,load_capacity,fuel_capacity,nominal_fuel_consumption) tags('truck_%d', 'South%d','Trish%d','v2.%d', %d, %d, %d)"%(ctbPrefix,i,stbName,i,i,i,i,1500+(1500+i*20)*20,150+(150+i*2)*2,5+(5+i)) else: model = 'H-%d'%i sql += f" {dbName}.%s%d using %s tags('truck_%d', 'South%d','Trish%d','%s','v2.%d', %d, %d,%d)"%(ctbPrefix,i,stbName,i,i,i,model,i,(1500+i*20),(150+i*2),(5+i)) diff --git a/tests/system-test/runAllOne.sh b/tests/system-test/runAllOne.sh index 6d4c80c388..099ae1bbd3 100644 --- a/tests/system-test/runAllOne.sh +++ b/tests/system-test/runAllOne.sh @@ -22,6 +22,7 @@ python3 ./test.py -f 1-insert/update_data_muti_rows.py -P python3 ./test.py -f 1-insert/db_tb_name_check.py -P python3 ./test.py -f 1-insert/InsertFuturets.py -P python3 ./test.py -f 1-insert/insert_wide_column.py -P +python3 ./test.py -f 1-insert/insert_column_value.py python3 ./test.py -f 2-query/nestedQuery.py -P python3 ./test.py -f 2-query/nestedQuery_str.py -P python3 ./test.py -f 2-query/nestedQuery_math.py -P diff --git a/tests/system-test/win-test-file b/tests/system-test/win-test-file index 1ab0fee7bf..96f9452827 100644 --- a/tests/system-test/win-test-file +++ b/tests/system-test/win-test-file @@ -233,6 +233,7 @@ python3 ./test.py -f 1-insert/update_data_muti_rows.py python3 ./test.py -f 1-insert/db_tb_name_check.py python3 ./test.py -f 1-insert/InsertFuturets.py python3 ./test.py -f 1-insert/insert_wide_column.py +python3 ./test.py -f 1-insert/insert_column_value.py python3 ./test.py -f 1-insert/rowlength64k_benchmark.py python3 ./test.py -f 1-insert/rowlength64k.py python3 ./test.py -f 1-insert/rowlength64k.py -R