From c6f21c4969867038b718201b0bd06d551d4c4558 Mon Sep 17 00:00:00 2001 From: tomchon Date: Mon, 30 May 2022 13:27:53 +0800 Subject: [PATCH 01/28] test:modify testcase of python connector using Statement API --- .../1-insert/performanceInsert.json | 79 +++++++++++++++++++ .../1-insert/performanceQuery.json | 42 ++++++++++ .../1-insert/test_stmt_insert_query.py | 11 ++- tests/system-test/fulltest.sh | 1 + 4 files changed, 127 insertions(+), 6 deletions(-) create mode 100644 tests/system-test/1-insert/performanceInsert.json create mode 100644 tests/system-test/1-insert/performanceQuery.json diff --git a/tests/system-test/1-insert/performanceInsert.json b/tests/system-test/1-insert/performanceInsert.json new file mode 100644 index 0000000000..de410c30f2 --- /dev/null +++ b/tests/system-test/1-insert/performanceInsert.json @@ -0,0 +1,79 @@ +{ + "filetype": "insert", + "cfgdir": "/etc/taos/", + "host": "test216", + "port": 6030, + "user": "root", + "password": "taosdata", + "thread_count": 8, + "thread_count_create_tbl": 8, + "result_file": "./insert_res.txt", + "confirm_parameter_prompt": "no", + "insert_interval": 0, + "interlace_rows": 1000, + "num_of_records_per_req": 100000, + "databases": [ + { + "dbinfo": { + "name": "db", + "drop": "yes", + "vgroups": 24 + }, + "super_tables": [ + { + "name": "stb", + "child_table_exists": "no", + "childtable_count": 100000, + "childtable_prefix": "stb_", + "auto_create_table": "no", + "batch_create_tbl_num": 50000, + "data_source": "rand", + "insert_mode": "taosc", + "insert_rows": 5, + "interlace_rows": 100000, + "insert_interval": 0, + "max_sql_len": 10000000, + "disorder_ratio": 0, + "disorder_range": 1000, + "timestamp_step": 10, + "start_timestamp": "2022-05-01 00:00:00.000", + "sample_format": "csv", + "use_sample_ts": "no", + "tags_file": "", + "columns": [ + { + "type": "INT" + }, + { + "type": "TINYINT", + "count": 1 + }, + {"type": "DOUBLE"}, + + { + "type": "BINARY", + "len": 40, + "count": 1 + }, + { + "type": "nchar", + "len": 20, + "count": 1 + } + ], + "tags": [ + { + "type": "TINYINT", + "count": 1 + }, + { + "type": "BINARY", + "len": 16, + "count": 1 + } + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/tests/system-test/1-insert/performanceQuery.json b/tests/system-test/1-insert/performanceQuery.json new file mode 100644 index 0000000000..fe2991bd0f --- /dev/null +++ b/tests/system-test/1-insert/performanceQuery.json @@ -0,0 +1,42 @@ +{ + "filetype": "query", + "cfgdir": "/etc/taos", + "host": "test216", + "port": 6030, + "user": "root", + "password": "taosdata", + "confirm_parameter_prompt": "no", + "databases": "db", + "query_times": 100, + "query_mode": "taosc", + "specified_table_query": { + "query_interval": 0, + "threads": 8, + "sqls": [ + { + "sql": "select count(*) from stb_0 ", + "result": "./query_res0.txt" + }, + { + "sql": "select last_row(*) from stb_1 ", + "result": "./query_res1.txt" + }, + { + "sql": "select last(*) from stb_2 ", + "result": "./query_res2.txt" + }, + { + "sql": "select first(*) from stb_3 ", + "result": "./query_res3.txt" + }, + { + "sql": "select avg(c0),min(c2),max(c1) from stb_4", + "result": "./query_res4.txt" + }, + { + "sql": "select avg(c0),min(c2),max(c1) from stb_5 where ts <= '2022-05-01 20:00:00.500' and ts >= '2022-05-01 00:00:00.000' ", + "result": "./query_res5.txt" + } + ] + } +} \ No newline at end of file diff --git a/tests/system-test/1-insert/test_stmt_insert_query.py b/tests/system-test/1-insert/test_stmt_insert_query.py index c6faedd35e..90f168eecf 100644 --- a/tests/system-test/1-insert/test_stmt_insert_query.py +++ b/tests/system-test/1-insert/test_stmt_insert_query.py @@ -132,11 +132,11 @@ class TDTestCase: querystmt.bind_param(queryparam) querystmt.execute() result=querystmt.use_result() - rows=result.fetch_all() - print( querystmt.use_result()) + # rows=result.fetch_all() + # print( querystmt.use_result()) # result = conn.query("select * from log") - # rows=result.fetch_all() + rows=result.fetch_all() # rows=result.fetch_all() print(rows) assert rows[1][0] == "ts" @@ -247,10 +247,9 @@ class TDTestCase: config = buildPath+ "../sim/dnode1/cfg/" host="localhost" connectstmt=self.newcon(host,config) - print(connectstmt) self.test_stmt_insert_multi(connectstmt) - connectstmt=self.newcon(host,config) - self.test_stmt_set_tbname_tag(connectstmt) + # connectstmt=self.newcon(host,config) + # self.test_stmt_set_tbname_tag(connectstmt) return diff --git a/tests/system-test/fulltest.sh b/tests/system-test/fulltest.sh index 6331086fb3..466a1bcfc6 100644 --- a/tests/system-test/fulltest.sh +++ b/tests/system-test/fulltest.sh @@ -15,6 +15,7 @@ python3 ./test.py -f 0-others/user_control.py python3 ./test.py -f 0-others/fsync.py python3 ./test.py -f 1-insert/opentsdb_telnet_line_taosc_insert.py +python3 ./test.py -f 1-insert/test_stmt_insert_query.py python3 ./test.py -f 2-query/between.py python3 ./test.py -f 2-query/distinct.py From 53def5b77b0b4698dd0903fdb94aa169bd16de23 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Mon, 30 May 2022 20:38:46 +0800 Subject: [PATCH 02/28] refactor: make trans support multi steps --- include/util/tdef.h | 1 + source/dnode/mnode/impl/inc/mndDef.h | 20 +- source/dnode/mnode/impl/inc/mndTrans.h | 34 +- source/dnode/mnode/impl/src/mndSubscribe.c | 2 +- source/dnode/mnode/impl/src/mndTrans.c | 584 ++++++++++----------- tests/test/c/sdbDump.c | 4 +- 6 files changed, 296 insertions(+), 349 deletions(-) diff --git a/include/util/tdef.h b/include/util/tdef.h index ad7206f7bb..709e2b8a7f 100644 --- a/include/util/tdef.h +++ b/include/util/tdef.h @@ -254,6 +254,7 @@ typedef enum ELogicConditionType { #define TSDB_TRANS_STAGE_LEN 12 #define TSDB_TRANS_TYPE_LEN 16 #define TSDB_TRANS_ERROR_LEN 64 +#define TSDB_TRANS_DESC_LEN 128 #define TSDB_STEP_NAME_LEN 32 #define TSDB_STEP_DESC_LEN 128 diff --git a/source/dnode/mnode/impl/inc/mndDef.h b/source/dnode/mnode/impl/inc/mndDef.h index 4d5aab4590..fd0f54c66b 100644 --- a/source/dnode/mnode/impl/inc/mndDef.h +++ b/source/dnode/mnode/impl/inc/mndDef.h @@ -60,14 +60,12 @@ typedef enum { typedef enum { TRN_STAGE_PREPARE = 0, - TRN_STAGE_REDO_LOG = 1, - TRN_STAGE_REDO_ACTION = 2, - TRN_STAGE_ROLLBACK = 3, - TRN_STAGE_UNDO_ACTION = 4, - TRN_STAGE_UNDO_LOG = 5, - TRN_STAGE_COMMIT = 6, - TRN_STAGE_COMMIT_LOG = 7, - TRN_STAGE_FINISHED = 8 + TRN_STAGE_REDO_ACTION = 1, + TRN_STAGE_ROLLBACK = 2, + TRN_STAGE_UNDO_ACTION = 3, + TRN_STAGE_COMMIT = 4, + TRN_STAGE_COMMIT_ACTION = 5, + TRN_STAGE_FINISHED = 6 } ETrnStage; typedef enum { @@ -168,16 +166,16 @@ typedef struct { SRpcHandleInfo rpcInfo; void* rpcRsp; int32_t rpcRspLen; - SArray* redoLogs; - SArray* undoLogs; - SArray* commitLogs; + int32_t redoActionPos; SArray* redoActions; SArray* undoActions; + SArray* commitActions; int64_t createdTime; int64_t lastExecTime; int64_t dbUid; char dbname[TSDB_DB_FNAME_LEN]; char lastError[TSDB_TRANS_ERROR_LEN]; + char desc[TSDB_TRANS_DESC_LEN]; int32_t startFunc; int32_t stopFunc; int32_t paramLen; diff --git a/source/dnode/mnode/impl/inc/mndTrans.h b/source/dnode/mnode/impl/inc/mndTrans.h index ce302a88e3..d9408467ad 100644 --- a/source/dnode/mnode/impl/inc/mndTrans.h +++ b/source/dnode/mnode/impl/inc/mndTrans.h @@ -26,31 +26,23 @@ typedef enum { TRANS_START_FUNC_TEST = 1, TRANS_STOP_FUNC_TEST = 2, TRANS_START_FUNC_MQ_REB = 3, - TRANS_STOP_FUNC_TEST_MQ_REB = 4, + TRANS_STOP_FUNC_MQ_REB = 4, } ETrnFunc; typedef struct { - SEpSet epSet; - tmsg_t msgType; - int8_t msgSent; - int8_t msgReceived; - int32_t errCode; - int32_t acceptableCode; - int32_t contLen; - void *pCont; -} STransAction; - -typedef struct { + int32_t id; + tmsg_t msgType; + int8_t msgSent; + int8_t msgReceived; + int8_t isRaw; + int8_t rawWritten; SSdbRaw *pRaw; -} STransLog; - -typedef struct { - ETrnStep stepType; - STransAction redoAction; - STransAction undoAction; - STransLog redoLog; - STransLog undoLog; -} STransStep; + SEpSet epSet; + int32_t errCode; + int32_t acceptableCode; + int32_t contLen; + void *pCont; +} STransAction; typedef void (*TransCbFp)(SMnode *pMnode, void *param, int32_t paramLen); diff --git a/source/dnode/mnode/impl/src/mndSubscribe.c b/source/dnode/mnode/impl/src/mndSubscribe.c index e58630ddbf..7e72aa2425 100644 --- a/source/dnode/mnode/impl/src/mndSubscribe.c +++ b/source/dnode/mnode/impl/src/mndSubscribe.c @@ -493,7 +493,7 @@ static int32_t mndPersistRebResult(SMnode *pMnode, SRpcMsg *pMsg, const SMqRebOu // 4. TODO commit log: modification log // 5. set cb - mndTransSetCb(pTrans, TRANS_START_FUNC_MQ_REB, TRANS_STOP_FUNC_TEST_MQ_REB, NULL, 0); + mndTransSetCb(pTrans, TRANS_START_FUNC_MQ_REB, TRANS_STOP_FUNC_MQ_REB, NULL, 0); // 6. execution if (mndTransPrepare(pMnode, pTrans) != 0) goto REB_FAIL; diff --git a/source/dnode/mnode/impl/src/mndTrans.c b/source/dnode/mnode/impl/src/mndTrans.c index 9d392c64fb..239e1bf4b1 100644 --- a/source/dnode/mnode/impl/src/mndTrans.c +++ b/source/dnode/mnode/impl/src/mndTrans.c @@ -43,13 +43,13 @@ static int32_t mndTransExecuteRedoLogs(SMnode *pMnode, STrans *pTrans); static int32_t mndTransExecuteUndoLogs(SMnode *pMnode, STrans *pTrans); static int32_t mndTransExecuteRedoActions(SMnode *pMnode, STrans *pTrans); static int32_t mndTransExecuteUndoActions(SMnode *pMnode, STrans *pTrans); -static int32_t mndTransExecuteCommitLogs(SMnode *pMnode, STrans *pTrans); +static int32_t mndTransExecuteCommitActions(SMnode *pMnode, STrans *pTrans); static bool mndTransPerformPrepareStage(SMnode *pMnode, STrans *pTrans); static bool mndTransPerformRedoLogStage(SMnode *pMnode, STrans *pTrans); static bool mndTransPerformRedoActionStage(SMnode *pMnode, STrans *pTrans); static bool mndTransPerformUndoLogStage(SMnode *pMnode, STrans *pTrans); static bool mndTransPerformUndoActionStage(SMnode *pMnode, STrans *pTrans); -static bool mndTransPerformCommitLogStage(SMnode *pMnode, STrans *pTrans); +static bool mndTransPerformCommitActionStage(SMnode *pMnode, STrans *pTrans); static bool mndTransPerformCommitStage(SMnode *pMnode, STrans *pTrans); static bool mndTransPerformRollbackStage(SMnode *pMnode, STrans *pTrans); static bool mndTransPerfromFinishedStage(SMnode *pMnode, STrans *pTrans); @@ -83,40 +83,30 @@ int32_t mndInitTrans(SMnode *pMnode) { void mndCleanupTrans(SMnode *pMnode) {} +static int32_t mndTransGetActionsSize(SArray *pArray) { + int32_t actionNum = taosArrayGetSize(pArray); + int32_t rawDataLen = 0; + + for (int32_t i = 0; i < actionNum; ++i) { + STransAction *pAction = taosArrayGet(pArray, i); + if (pAction->isRaw) { + rawDataLen += (sdbGetRawTotalSize(pAction->pRaw) + sizeof(int32_t)); + } else { + rawDataLen += (sizeof(STransAction) + pAction->contLen); + } + rawDataLen += sizeof(pAction->isRaw); + } + + return rawDataLen; +} + static SSdbRaw *mndTransActionEncode(STrans *pTrans) { terrno = TSDB_CODE_OUT_OF_MEMORY; int32_t rawDataLen = sizeof(STrans) + TRANS_RESERVE_SIZE; - int32_t redoLogNum = taosArrayGetSize(pTrans->redoLogs); - int32_t undoLogNum = taosArrayGetSize(pTrans->undoLogs); - int32_t commitLogNum = taosArrayGetSize(pTrans->commitLogs); - int32_t redoActionNum = taosArrayGetSize(pTrans->redoActions); - int32_t undoActionNum = taosArrayGetSize(pTrans->undoActions); - - for (int32_t i = 0; i < redoLogNum; ++i) { - SSdbRaw *pTmp = taosArrayGetP(pTrans->redoLogs, i); - rawDataLen += (sdbGetRawTotalSize(pTmp) + sizeof(int32_t)); - } - - for (int32_t i = 0; i < undoLogNum; ++i) { - SSdbRaw *pTmp = taosArrayGetP(pTrans->undoLogs, i); - rawDataLen += (sdbGetRawTotalSize(pTmp) + sizeof(int32_t)); - } - - for (int32_t i = 0; i < commitLogNum; ++i) { - SSdbRaw *pTmp = taosArrayGetP(pTrans->commitLogs, i); - rawDataLen += (sdbGetRawTotalSize(pTmp) + sizeof(int32_t)); - } - - for (int32_t i = 0; i < redoActionNum; ++i) { - STransAction *pAction = taosArrayGet(pTrans->redoActions, i); - rawDataLen += (sizeof(STransAction) + pAction->contLen); - } - - for (int32_t i = 0; i < undoActionNum; ++i) { - STransAction *pAction = taosArrayGet(pTrans->undoActions, i); - rawDataLen += (sizeof(STransAction) + pAction->contLen); - } + rawDataLen += mndTransGetActionsSize(pTrans->redoActions); + rawDataLen += mndTransGetActionsSize(pTrans->undoActions); + rawDataLen += mndTransGetActionsSize(pTrans->commitActions); SSdbRaw *pRaw = sdbAllocRaw(SDB_TRANS, TRANS_VER_NUMBER, rawDataLen); if (pRaw == NULL) { @@ -126,67 +116,67 @@ static SSdbRaw *mndTransActionEncode(STrans *pTrans) { int32_t dataPos = 0; SDB_SET_INT32(pRaw, dataPos, pTrans->id, _OVER) - - ETrnStage stage = pTrans->stage; - if (stage == TRN_STAGE_REDO_LOG || stage == TRN_STAGE_REDO_ACTION) { - stage = TRN_STAGE_PREPARE; - } else if (stage == TRN_STAGE_UNDO_ACTION || stage == TRN_STAGE_UNDO_LOG) { - stage = TRN_STAGE_ROLLBACK; - } else if (stage == TRN_STAGE_COMMIT_LOG || stage == TRN_STAGE_FINISHED) { - stage = TRN_STAGE_COMMIT; - } else { - } - - SDB_SET_INT16(pRaw, dataPos, stage, _OVER) + SDB_SET_INT16(pRaw, dataPos, pTrans->stage, _OVER) SDB_SET_INT16(pRaw, dataPos, pTrans->policy, _OVER) SDB_SET_INT16(pRaw, dataPos, pTrans->type, _OVER) SDB_SET_INT16(pRaw, dataPos, pTrans->parallel, _OVER) SDB_SET_INT64(pRaw, dataPos, pTrans->createdTime, _OVER) SDB_SET_INT64(pRaw, dataPos, pTrans->dbUid, _OVER) SDB_SET_BINARY(pRaw, dataPos, pTrans->dbname, TSDB_DB_FNAME_LEN, _OVER) - SDB_SET_INT32(pRaw, dataPos, redoLogNum, _OVER) - SDB_SET_INT32(pRaw, dataPos, undoLogNum, _OVER) - SDB_SET_INT32(pRaw, dataPos, commitLogNum, _OVER) + + int32_t redoActionNum = taosArrayGetSize(pTrans->redoActions); + int32_t undoActionNum = taosArrayGetSize(pTrans->undoActions); + int32_t commitActionNum = taosArrayGetSize(pTrans->commitActions); SDB_SET_INT32(pRaw, dataPos, redoActionNum, _OVER) SDB_SET_INT32(pRaw, dataPos, undoActionNum, _OVER) - - for (int32_t i = 0; i < redoLogNum; ++i) { - SSdbRaw *pTmp = taosArrayGetP(pTrans->redoLogs, i); - int32_t len = sdbGetRawTotalSize(pTmp); - SDB_SET_INT32(pRaw, dataPos, len, _OVER) - SDB_SET_BINARY(pRaw, dataPos, (void *)pTmp, len, _OVER) - } - - for (int32_t i = 0; i < undoLogNum; ++i) { - SSdbRaw *pTmp = taosArrayGetP(pTrans->undoLogs, i); - int32_t len = sdbGetRawTotalSize(pTmp); - SDB_SET_INT32(pRaw, dataPos, len, _OVER) - SDB_SET_BINARY(pRaw, dataPos, (void *)pTmp, len, _OVER) - } - - for (int32_t i = 0; i < commitLogNum; ++i) { - SSdbRaw *pTmp = taosArrayGetP(pTrans->commitLogs, i); - int32_t len = sdbGetRawTotalSize(pTmp); - SDB_SET_INT32(pRaw, dataPos, len, _OVER) - SDB_SET_BINARY(pRaw, dataPos, (void *)pTmp, len, _OVER) - } + SDB_SET_INT32(pRaw, dataPos, commitActionNum, _OVER) for (int32_t i = 0; i < redoActionNum; ++i) { STransAction *pAction = taosArrayGet(pTrans->redoActions, i); - SDB_SET_BINARY(pRaw, dataPos, (void *)&pAction->epSet, sizeof(SEpSet), _OVER) - SDB_SET_INT16(pRaw, dataPos, pAction->msgType, _OVER) - SDB_SET_INT32(pRaw, dataPos, pAction->acceptableCode, _OVER) - SDB_SET_INT32(pRaw, dataPos, pAction->contLen, _OVER) - SDB_SET_BINARY(pRaw, dataPos, pAction->pCont, pAction->contLen, _OVER) + SDB_SET_INT8(pRaw, dataPos, pAction->isRaw, _OVER) + if (pAction->isRaw) { + int32_t len = sdbGetRawTotalSize(pAction->pRaw); + SDB_SET_INT32(pRaw, dataPos, len, _OVER) + SDB_SET_BINARY(pRaw, dataPos, (void *)pAction->pRaw, len, _OVER) + } else { + SDB_SET_BINARY(pRaw, dataPos, (void *)&pAction->epSet, sizeof(SEpSet), _OVER) + SDB_SET_INT16(pRaw, dataPos, pAction->msgType, _OVER) + SDB_SET_INT32(pRaw, dataPos, pAction->acceptableCode, _OVER) + SDB_SET_INT32(pRaw, dataPos, pAction->contLen, _OVER) + SDB_SET_BINARY(pRaw, dataPos, pAction->pCont, pAction->contLen, _OVER) + } } for (int32_t i = 0; i < undoActionNum; ++i) { STransAction *pAction = taosArrayGet(pTrans->undoActions, i); - SDB_SET_BINARY(pRaw, dataPos, (void *)&pAction->epSet, sizeof(SEpSet), _OVER) - SDB_SET_INT16(pRaw, dataPos, pAction->msgType, _OVER) - SDB_SET_INT32(pRaw, dataPos, pAction->acceptableCode, _OVER) - SDB_SET_INT32(pRaw, dataPos, pAction->contLen, _OVER) - SDB_SET_BINARY(pRaw, dataPos, (void *)pAction->pCont, pAction->contLen, _OVER) + SDB_SET_INT8(pRaw, dataPos, pAction->isRaw, _OVER) + if (pAction->isRaw) { + int32_t len = sdbGetRawTotalSize(pAction->pRaw); + SDB_SET_INT32(pRaw, dataPos, len, _OVER) + SDB_SET_BINARY(pRaw, dataPos, (void *)pAction->pRaw, len, _OVER) + } else { + SDB_SET_BINARY(pRaw, dataPos, (void *)&pAction->epSet, sizeof(SEpSet), _OVER) + SDB_SET_INT16(pRaw, dataPos, pAction->msgType, _OVER) + SDB_SET_INT32(pRaw, dataPos, pAction->acceptableCode, _OVER) + SDB_SET_INT32(pRaw, dataPos, pAction->contLen, _OVER) + SDB_SET_BINARY(pRaw, dataPos, pAction->pCont, pAction->contLen, _OVER) + } + } + + for (int32_t i = 0; i < commitActionNum; ++i) { + STransAction *pAction = taosArrayGet(pTrans->commitActions, i); + SDB_SET_INT8(pRaw, dataPos, pAction->isRaw, _OVER) + if (pAction->isRaw) { + int32_t len = sdbGetRawTotalSize(pAction->pRaw); + SDB_SET_INT32(pRaw, dataPos, len, _OVER) + SDB_SET_BINARY(pRaw, dataPos, (void *)pAction->pRaw, len, _OVER) + } else { + SDB_SET_BINARY(pRaw, dataPos, (void *)&pAction->epSet, sizeof(SEpSet), _OVER) + SDB_SET_INT16(pRaw, dataPos, pAction->msgType, _OVER) + SDB_SET_INT32(pRaw, dataPos, pAction->acceptableCode, _OVER) + SDB_SET_INT32(pRaw, dataPos, pAction->contLen, _OVER) + SDB_SET_BINARY(pRaw, dataPos, pAction->pCont, pAction->contLen, _OVER) + } } SDB_SET_INT32(pRaw, dataPos, pTrans->startFunc, _OVER) @@ -220,11 +210,9 @@ static SSdbRow *mndTransActionDecode(SSdbRaw *pRaw) { char *pData = NULL; int32_t dataLen = 0; int8_t sver = 0; - int32_t redoLogNum = 0; - int32_t undoLogNum = 0; - int32_t commitLogNum = 0; int32_t redoActionNum = 0; int32_t undoActionNum = 0; + int32_t commitActionNum = 0; int32_t dataPos = 0; STransAction action = {0}; @@ -258,76 +246,85 @@ static SSdbRow *mndTransActionDecode(SSdbRaw *pRaw) { SDB_GET_INT64(pRaw, dataPos, &pTrans->createdTime, _OVER) SDB_GET_INT64(pRaw, dataPos, &pTrans->dbUid, _OVER) SDB_GET_BINARY(pRaw, dataPos, pTrans->dbname, TSDB_DB_FNAME_LEN, _OVER) - SDB_GET_INT32(pRaw, dataPos, &redoLogNum, _OVER) - SDB_GET_INT32(pRaw, dataPos, &undoLogNum, _OVER) - SDB_GET_INT32(pRaw, dataPos, &commitLogNum, _OVER) SDB_GET_INT32(pRaw, dataPos, &redoActionNum, _OVER) SDB_GET_INT32(pRaw, dataPos, &undoActionNum, _OVER) + SDB_GET_INT32(pRaw, dataPos, &commitActionNum, _OVER) - pTrans->redoLogs = taosArrayInit(redoLogNum, sizeof(void *)); - pTrans->undoLogs = taosArrayInit(undoLogNum, sizeof(void *)); - pTrans->commitLogs = taosArrayInit(commitLogNum, sizeof(void *)); pTrans->redoActions = taosArrayInit(redoActionNum, sizeof(STransAction)); pTrans->undoActions = taosArrayInit(undoActionNum, sizeof(STransAction)); + pTrans->commitActions = taosArrayInit(commitActionNum, sizeof(STransAction)); - if (pTrans->redoLogs == NULL) goto _OVER; - if (pTrans->undoLogs == NULL) goto _OVER; - if (pTrans->commitLogs == NULL) goto _OVER; if (pTrans->redoActions == NULL) goto _OVER; if (pTrans->undoActions == NULL) goto _OVER; - - for (int32_t i = 0; i < redoLogNum; ++i) { - SDB_GET_INT32(pRaw, dataPos, &dataLen, _OVER) - pData = taosMemoryMalloc(dataLen); - if (pData == NULL) goto _OVER; - mTrace("raw:%p, is created", pData); - SDB_GET_BINARY(pRaw, dataPos, pData, dataLen, _OVER); - if (taosArrayPush(pTrans->redoLogs, &pData) == NULL) goto _OVER; - pData = NULL; - } - - for (int32_t i = 0; i < undoLogNum; ++i) { - SDB_GET_INT32(pRaw, dataPos, &dataLen, _OVER) - pData = taosMemoryMalloc(dataLen); - if (pData == NULL) goto _OVER; - mTrace("raw:%p, is created", pData); - SDB_GET_BINARY(pRaw, dataPos, pData, dataLen, _OVER); - if (taosArrayPush(pTrans->undoLogs, &pData) == NULL) goto _OVER; - pData = NULL; - } - - for (int32_t i = 0; i < commitLogNum; ++i) { - SDB_GET_INT32(pRaw, dataPos, &dataLen, _OVER) - pData = taosMemoryMalloc(dataLen); - if (pData == NULL) goto _OVER; - mTrace("raw:%p, is created", pData); - SDB_GET_BINARY(pRaw, dataPos, pData, dataLen, _OVER); - if (taosArrayPush(pTrans->commitLogs, &pData) == NULL) goto _OVER; - pData = NULL; - } + if (pTrans->commitActions == NULL) goto _OVER; for (int32_t i = 0; i < redoActionNum; ++i) { - SDB_GET_BINARY(pRaw, dataPos, (void *)&action.epSet, sizeof(SEpSet), _OVER); - SDB_GET_INT16(pRaw, dataPos, &action.msgType, _OVER) - SDB_GET_INT32(pRaw, dataPos, &action.acceptableCode, _OVER) - SDB_GET_INT32(pRaw, dataPos, &action.contLen, _OVER) - action.pCont = taosMemoryMalloc(action.contLen); - if (action.pCont == NULL) goto _OVER; - SDB_GET_BINARY(pRaw, dataPos, action.pCont, action.contLen, _OVER); - if (taosArrayPush(pTrans->redoActions, &action) == NULL) goto _OVER; - action.pCont = NULL; + SDB_GET_INT8(pRaw, dataPos, &action.isRaw, _OVER) + if (action.isRaw) { + SDB_GET_INT32(pRaw, dataPos, &dataLen, _OVER) + pData = taosMemoryMalloc(dataLen); + if (pData == NULL) goto _OVER; + mTrace("raw:%p, is created", pData); + SDB_GET_BINARY(pRaw, dataPos, pData, dataLen, _OVER); + if (taosArrayPush(pTrans->redoActions, &pData) == NULL) goto _OVER; + pData = NULL; + } else { + SDB_GET_BINARY(pRaw, dataPos, (void *)&action.epSet, sizeof(SEpSet), _OVER); + SDB_GET_INT16(pRaw, dataPos, &action.msgType, _OVER) + SDB_GET_INT32(pRaw, dataPos, &action.acceptableCode, _OVER) + SDB_GET_INT32(pRaw, dataPos, &action.contLen, _OVER) + action.pCont = taosMemoryMalloc(action.contLen); + if (action.pCont == NULL) goto _OVER; + SDB_GET_BINARY(pRaw, dataPos, action.pCont, action.contLen, _OVER); + if (taosArrayPush(pTrans->redoActions, &action) == NULL) goto _OVER; + action.pCont = NULL; + } } for (int32_t i = 0; i < undoActionNum; ++i) { - SDB_GET_BINARY(pRaw, dataPos, (void *)&action.epSet, sizeof(SEpSet), _OVER); - SDB_GET_INT16(pRaw, dataPos, &action.msgType, _OVER) - SDB_GET_INT32(pRaw, dataPos, &action.acceptableCode, _OVER) - SDB_GET_INT32(pRaw, dataPos, &action.contLen, _OVER) - action.pCont = taosMemoryMalloc(action.contLen); - if (action.pCont == NULL) goto _OVER; - SDB_GET_BINARY(pRaw, dataPos, action.pCont, action.contLen, _OVER); - if (taosArrayPush(pTrans->undoActions, &action) == NULL) goto _OVER; - action.pCont = NULL; + SDB_GET_INT8(pRaw, dataPos, &action.isRaw, _OVER) + if (action.isRaw) { + SDB_GET_INT32(pRaw, dataPos, &dataLen, _OVER) + pData = taosMemoryMalloc(dataLen); + if (pData == NULL) goto _OVER; + mTrace("raw:%p, is created", pData); + SDB_GET_BINARY(pRaw, dataPos, pData, dataLen, _OVER); + if (taosArrayPush(pTrans->undoActions, &pData) == NULL) goto _OVER; + pData = NULL; + } else { + SDB_GET_BINARY(pRaw, dataPos, (void *)&action.epSet, sizeof(SEpSet), _OVER); + SDB_GET_INT16(pRaw, dataPos, &action.msgType, _OVER) + SDB_GET_INT32(pRaw, dataPos, &action.acceptableCode, _OVER) + SDB_GET_INT32(pRaw, dataPos, &action.contLen, _OVER) + action.pCont = taosMemoryMalloc(action.contLen); + if (action.pCont == NULL) goto _OVER; + SDB_GET_BINARY(pRaw, dataPos, action.pCont, action.contLen, _OVER); + if (taosArrayPush(pTrans->undoActions, &action) == NULL) goto _OVER; + action.pCont = NULL; + } + } + + for (int32_t i = 0; i < commitActionNum; ++i) { + SDB_GET_INT8(pRaw, dataPos, &action.isRaw, _OVER) + if (action.isRaw) { + SDB_GET_INT32(pRaw, dataPos, &dataLen, _OVER) + pData = taosMemoryMalloc(dataLen); + if (pData == NULL) goto _OVER; + mTrace("raw:%p, is created", pData); + SDB_GET_BINARY(pRaw, dataPos, pData, dataLen, _OVER); + if (taosArrayPush(pTrans->commitActions, &pData) == NULL) goto _OVER; + pData = NULL; + } else { + SDB_GET_BINARY(pRaw, dataPos, (void *)&action.epSet, sizeof(SEpSet), _OVER); + SDB_GET_INT16(pRaw, dataPos, &action.msgType, _OVER) + SDB_GET_INT32(pRaw, dataPos, &action.acceptableCode, _OVER) + SDB_GET_INT32(pRaw, dataPos, &action.contLen, _OVER) + action.pCont = taosMemoryMalloc(action.contLen); + if (action.pCont == NULL) goto _OVER; + SDB_GET_BINARY(pRaw, dataPos, action.pCont, action.contLen, _OVER); + if (taosArrayPush(pTrans->commitActions, &action) == NULL) goto _OVER; + action.pCont = NULL; + } } SDB_GET_INT32(pRaw, dataPos, &pTrans->startFunc, _OVER) @@ -360,20 +357,16 @@ static const char *mndTransStr(ETrnStage stage) { switch (stage) { case TRN_STAGE_PREPARE: return "prepare"; - case TRN_STAGE_REDO_LOG: - return "redoLog"; case TRN_STAGE_REDO_ACTION: return "redoAction"; - case TRN_STAGE_COMMIT: - return "commit"; - case TRN_STAGE_COMMIT_LOG: - return "commitLog"; - case TRN_STAGE_UNDO_ACTION: - return "undoAction"; - case TRN_STAGE_UNDO_LOG: - return "undoLog"; case TRN_STAGE_ROLLBACK: return "rollback"; + case TRN_STAGE_UNDO_ACTION: + return "undoAction"; + case TRN_STAGE_COMMIT: + return "commit"; + case TRN_STAGE_COMMIT_ACTION: + return "commitAction"; case TRN_STAGE_FINISHED: return "finished"; default: @@ -472,7 +465,7 @@ static TransCbFp mndTransGetCbFp(ETrnFunc ftype) { return mndTransTestStopFunc; case TRANS_START_FUNC_MQ_REB: return mndRebCntInc; - case TRANS_STOP_FUNC_TEST_MQ_REB: + case TRANS_STOP_FUNC_MQ_REB: return mndRebCntDec; default: return NULL; @@ -493,11 +486,9 @@ static int32_t mndTransActionInsert(SSdb *pSdb, STrans *pTrans) { } static void mndTransDropData(STrans *pTrans) { - mndTransDropLogs(pTrans->redoLogs); - mndTransDropLogs(pTrans->undoLogs); - mndTransDropLogs(pTrans->commitLogs); mndTransDropActions(pTrans->redoActions); mndTransDropActions(pTrans->undoActions); + mndTransDropActions(pTrans->commitActions); if (pTrans->rpcRsp != NULL) { taosMemoryFree(pTrans->rpcRsp); pTrans->rpcRsp = NULL; @@ -526,8 +517,8 @@ static int32_t mndTransActionDelete(SSdb *pSdb, STrans *pTrans, bool callFunc) { static int32_t mndTransActionUpdate(SSdb *pSdb, STrans *pOld, STrans *pNew) { if (pNew->stage == TRN_STAGE_COMMIT) { - pNew->stage = TRN_STAGE_COMMIT_LOG; - mTrace("trans:%d, stage from %s to %s", pNew->id, mndTransStr(TRN_STAGE_COMMIT), mndTransStr(TRN_STAGE_COMMIT_LOG)); + pNew->stage = TRN_STAGE_COMMIT_ACTION; + mTrace("trans:%d, stage from %s to %s", pNew->id, mndTransStr(TRN_STAGE_COMMIT), mndTransStr(TRN_STAGE_COMMIT_ACTION)); } if (pNew->stage == TRN_STAGE_ROLLBACK) { @@ -568,14 +559,11 @@ STrans *mndTransCreate(SMnode *pMnode, ETrnPolicy policy, ETrnType type, const S pTrans->type = type; pTrans->createdTime = taosGetTimestampMs(); if (pReq != NULL) pTrans->rpcInfo = pReq->info; - pTrans->redoLogs = taosArrayInit(TRANS_ARRAY_SIZE, sizeof(void *)); - pTrans->undoLogs = taosArrayInit(TRANS_ARRAY_SIZE, sizeof(void *)); - pTrans->commitLogs = taosArrayInit(TRANS_ARRAY_SIZE, sizeof(void *)); pTrans->redoActions = taosArrayInit(TRANS_ARRAY_SIZE, sizeof(STransAction)); pTrans->undoActions = taosArrayInit(TRANS_ARRAY_SIZE, sizeof(STransAction)); + pTrans->commitActions = taosArrayInit(TRANS_ARRAY_SIZE, sizeof(STransAction)); - if (pTrans->redoLogs == NULL || pTrans->undoLogs == NULL || pTrans->commitLogs == NULL || - pTrans->redoActions == NULL || pTrans->undoActions == NULL) { + if (pTrans->redoActions == NULL || pTrans->undoActions == NULL || pTrans->commitActions == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; mError("failed to create transaction since %s", terrstr()); return NULL; @@ -585,21 +573,15 @@ STrans *mndTransCreate(SMnode *pMnode, ETrnPolicy policy, ETrnType type, const S return pTrans; } -static void mndTransDropLogs(SArray *pArray) { - int32_t size = taosArrayGetSize(pArray); - for (int32_t i = 0; i < size; ++i) { - SSdbRaw *pRaw = taosArrayGetP(pArray, i); - sdbFreeRaw(pRaw); - } - - taosArrayDestroy(pArray); -} - static void mndTransDropActions(SArray *pArray) { int32_t size = taosArrayGetSize(pArray); for (int32_t i = 0; i < size; ++i) { STransAction *pAction = taosArrayGet(pArray, i); - taosMemoryFreeClear(pAction->pCont); + if (pAction->isRaw) { + sdbFreeRaw(pAction->pRaw); + } else { + taosMemoryFreeClear(pAction->pCont); + } } taosArrayDestroy(pArray); @@ -613,27 +595,6 @@ void mndTransDrop(STrans *pTrans) { } } -static int32_t mndTransAppendLog(SArray *pArray, SSdbRaw *pRaw) { - if (pArray == NULL || pRaw == NULL) { - terrno = TSDB_CODE_INVALID_PARA; - return -1; - } - - void *ptr = taosArrayPush(pArray, &pRaw); - if (ptr == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return -1; - } - - return 0; -} - -int32_t mndTransAppendRedolog(STrans *pTrans, SSdbRaw *pRaw) { return mndTransAppendLog(pTrans->redoLogs, pRaw); } - -int32_t mndTransAppendUndolog(STrans *pTrans, SSdbRaw *pRaw) { return mndTransAppendLog(pTrans->undoLogs, pRaw); } - -int32_t mndTransAppendCommitlog(STrans *pTrans, SSdbRaw *pRaw) { return mndTransAppendLog(pTrans->commitLogs, pRaw); } - static int32_t mndTransAppendAction(SArray *pArray, STransAction *pAction) { void *ptr = taosArrayPush(pArray, pAction); if (ptr == NULL) { @@ -644,6 +605,21 @@ static int32_t mndTransAppendAction(SArray *pArray, STransAction *pAction) { return 0; } +int32_t mndTransAppendRedolog(STrans *pTrans, SSdbRaw *pRaw) { + STransAction action = {.isRaw = true, .pRaw = pRaw}; + return mndTransAppendAction(pTrans->redoActions, &action); +} + +int32_t mndTransAppendUndolog(STrans *pTrans, SSdbRaw *pRaw) { + STransAction action = {.isRaw = true, .pRaw = pRaw}; + return mndTransAppendAction(pTrans->undoActions, &action); +} + +int32_t mndTransAppendCommitlog(STrans *pTrans, SSdbRaw *pRaw) { + STransAction action = {.isRaw = true, .pRaw = pRaw}; + return mndTransAppendAction(pTrans->commitActions, &action); +} + int32_t mndTransAppendRedoAction(STrans *pTrans, STransAction *pAction) { return mndTransAppendAction(pTrans->redoActions, pAction); } @@ -768,7 +744,7 @@ int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans) { return -1; } - if (taosArrayGetSize(pTrans->commitLogs) <= 0) { + if (taosArrayGetSize(pTrans->commitActions) <= 0) { terrno = TSDB_CODE_MND_TRANS_CLOG_IS_NULL; mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr()); return -1; @@ -799,8 +775,6 @@ int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans) { } static int32_t mndTransCommit(SMnode *pMnode, STrans *pTrans) { - if (taosArrayGetSize(pTrans->commitLogs) == 0 && taosArrayGetSize(pTrans->redoActions) == 0) return 0; - mDebug("trans:%d, commit transaction", pTrans->id); if (mndTransSync(pMnode, pTrans) != 0) { mError("trans:%d, failed to commit since %s", pTrans->id, terrstr()); @@ -829,8 +803,7 @@ static void mndTransSendRpcRsp(SMnode *pMnode, STrans *pTrans) { } if (pTrans->policy == TRN_POLICY_ROLLBACK) { - if (pTrans->stage == TRN_STAGE_UNDO_LOG || pTrans->stage == TRN_STAGE_UNDO_ACTION || - pTrans->stage == TRN_STAGE_ROLLBACK) { + if (pTrans->stage == pTrans->stage == TRN_STAGE_UNDO_ACTION || pTrans->stage == TRN_STAGE_ROLLBACK) { if (code == 0) code = TSDB_CODE_MND_TRANS_UNKNOW_ERROR; sendRsp = true; } @@ -930,30 +903,6 @@ static int32_t mndTransExecuteLogs(SMnode *pMnode, SArray *pArray) { return code; } -static int32_t mndTransExecuteRedoLogs(SMnode *pMnode, STrans *pTrans) { - int32_t code = mndTransExecuteLogs(pMnode, pTrans->redoLogs); - if (code != 0) { - mError("failed to execute redoLogs since %s", terrstr()); - } - return code; -} - -static int32_t mndTransExecuteUndoLogs(SMnode *pMnode, STrans *pTrans) { - int32_t code = mndTransExecuteLogs(pMnode, pTrans->undoLogs); - if (code != 0) { - mError("failed to execute undoLogs since %s, return success", terrstr()); - } - - return 0; // return success in any case -} - -static int32_t mndTransExecuteCommitLogs(SMnode *pMnode, STrans *pTrans) { - int32_t code = mndTransExecuteLogs(pMnode, pTrans->commitLogs); - if (code != 0) { - mError("failed to execute commitLogs since %s", terrstr()); - } - return code; -} static void mndTransResetActions(SMnode *pMnode, STrans *pTrans, SArray *pArray) { int32_t numOfActions = taosArrayGetSize(pArray); @@ -962,6 +911,7 @@ static void mndTransResetActions(SMnode *pMnode, STrans *pTrans, SArray *pArray) STransAction *pAction = taosArrayGet(pArray, action); if (pAction == NULL) continue; if (pAction->msgSent && pAction->msgReceived && pAction->errCode == 0) continue; + if (pAction->rawWritten && pAction->errCode == 0) continue; pAction->msgSent = 0; pAction->msgReceived = 0; @@ -970,56 +920,71 @@ static void mndTransResetActions(SMnode *pMnode, STrans *pTrans, SArray *pArray) } } +static int32_t mndTransWriteSingleLog(SMnode *pMnode, STrans *pTrans, STransAction *pAction) { + int32_t code = sdbWriteWithoutFree(pMnode->pSdb, pAction->pRaw); + if (code == 0) { + mDebug("trans:%d, action:%d write to sdb", pTrans->id, pAction->id); + } else { + mError("trans:%d, action:%d failed to write sdb since %s", pTrans->id, pAction->id, terrstr()); + } + + return code; +} + +static int32_t mndTransSendSingleMsg(SMnode *pMnode, STrans *pTrans, STransAction *pAction) { + if (pAction->msgSent) return 0; + if (!pMnode->deploy && !mndIsMaster(pMnode)) return -1; + + int64_t signature = pTrans->id; + signature = (signature << 32); + signature += pAction->id; + + SRpcMsg rpcMsg = {.msgType = pAction->msgType, .contLen = pAction->contLen, .info.ahandle = (void *)signature}; + rpcMsg.pCont = rpcMallocCont(pAction->contLen); + if (rpcMsg.pCont == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + return -1; + } + memcpy(rpcMsg.pCont, pAction->pCont, pAction->contLen); + + int32_t code = tmsgSendReq(&pAction->epSet, &rpcMsg); + if (code == 0) { + pAction->msgSent = 1; + pAction->msgReceived = 0; + pAction->errCode = 0; + mDebug("trans:%d, action:%d is sent to %s:%u", pTrans->id, pAction->id, + pAction->epSet.eps[pAction->epSet.inUse].fqdn, pAction->epSet.eps[pAction->epSet.inUse].port); + } else { + pAction->msgSent = 0; + pAction->msgReceived = 0; + pAction->errCode = (terrno != 0) ? terrno : code; + mError("trans:%d, action:%d not send since %s", pTrans->id, pAction->id, terrstr()); + } + + return code; +} + +static int32_t mndTransExecSingleAction(SMnode *pMnode, STrans *pTrans, STransAction *pAction) { + if (pAction->isRaw) { + return mndTransWriteSingleLog(pMnode, pTrans, pAction); + } else { + return mndTransSendSingleMsg(pMnode, pTrans, pAction); + } +} + static int32_t mndTransSendActionMsg(SMnode *pMnode, STrans *pTrans, SArray *pArray) { int32_t numOfActions = taosArrayGetSize(pArray); + int32_t code = 0; for (int32_t action = 0; action < numOfActions; ++action) { STransAction *pAction = taosArrayGet(pArray, action); - if (pAction == NULL) continue; - - if (pAction->msgSent) { - if (pAction->msgReceived) { - continue; - } else { - if (pTrans->parallel == TRN_EXEC_ONE_BY_ONE) { - break; - } else { - continue; - } - } - } - - int64_t signature = pTrans->id; - signature = (signature << 32); - signature += action; - - SRpcMsg rpcMsg = {.msgType = pAction->msgType, .contLen = pAction->contLen, .info.ahandle = (void *)signature}; - rpcMsg.pCont = rpcMallocCont(pAction->contLen); - if (rpcMsg.pCont == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return -1; - } - memcpy(rpcMsg.pCont, pAction->pCont, pAction->contLen); - - if (tmsgSendReq(&pAction->epSet, &rpcMsg) == 0) { - mDebug("trans:%d, action:%d is sent to %s:%u", pTrans->id, action, pAction->epSet.eps[pAction->epSet.inUse].fqdn, - pAction->epSet.eps[pAction->epSet.inUse].port); - pAction->msgSent = 1; - pAction->msgReceived = 0; - pAction->errCode = 0; - if (pTrans->parallel == TRN_EXEC_ONE_BY_ONE) { - break; - } - } else { - pAction->msgSent = 0; - pAction->msgReceived = 0; - pAction->errCode = terrno; - mError("trans:%d, action:%d not send since %s", pTrans->id, action, terrstr()); - return -1; + code = mndTransExecSingleAction(pMnode, pTrans, pAction); + if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) { + break; } } - return 0; + return code; } static int32_t mndTransExecuteActions(SMnode *pMnode, STrans *pTrans, SArray *pArray) { @@ -1075,35 +1040,52 @@ static int32_t mndTransExecuteUndoActions(SMnode *pMnode, STrans *pTrans) { return code; } +static int32_t mndTransExecuteCommitActions(SMnode *pMnode, STrans *pTrans) { + int32_t code = mndTransExecuteLogs(pMnode, pTrans->commitActions); + if (code != 0) { + mError("failed to execute commitActions since %s", terrstr()); + } + return code; +} + static bool mndTransPerformPrepareStage(SMnode *pMnode, STrans *pTrans) { bool continueExec = true; - pTrans->stage = TRN_STAGE_REDO_LOG; - mDebug("trans:%d, stage from prepare to redoLog", pTrans->id); + pTrans->stage = TRN_STAGE_REDO_ACTION; + mDebug("trans:%d, stage from prepare to redoAction", pTrans->id); return continueExec; } -static bool mndTransPerformRedoLogStage(SMnode *pMnode, STrans *pTrans) { - bool continueExec = true; - int32_t code = mndTransExecuteRedoLogs(pMnode, pTrans); +static bool mndTransExecuteRedoActionsOneByOne(SMnode *pMnode, STrans *pTrans) { + bool continueExec = true; + if (pTrans->redoActionPos >= taosArrayGetSize(pTrans->redoActions)) return continueExec; + STransAction *pAction = taosArrayGet(pTrans->redoActions, pTrans->redoActionPos); + int32_t code = mndTransExecSingleAction(pMnode, pTrans, pAction); if (code == 0) { - pTrans->code = 0; - pTrans->stage = TRN_STAGE_REDO_ACTION; - mDebug("trans:%d, stage from redoLog to redoAction", pTrans->id); + pTrans->redoActionPos++; + mDebug("trans:%d, redo action:%d is executed and need sync to other mnodes", pTrans->id, pAction->id); + + // todo sync these infos + } else if (code == TSDB_CODE_ACTION_IN_PROGRESS) { + mDebug("trans:%d, redo action:%d is in progress and wait it finish", pTrans->id, pAction->id); + continueExec = false; } else { - pTrans->code = terrno; - pTrans->stage = TRN_STAGE_UNDO_LOG; - mError("trans:%d, stage from redoLog to undoLog since %s", pTrans->id, terrstr()); + mError("trans:%d, redo action:%d failed to execute since %s", pTrans->id, pAction->id, terrstr()); + continueExec = false; } return continueExec; } static bool mndTransPerformRedoActionStage(SMnode *pMnode, STrans *pTrans) { - if (!pMnode->deploy && !mndIsMaster(pMnode)) return false; - bool continueExec = true; - int32_t code = mndTransExecuteRedoActions(pMnode, pTrans); + int32_t code = 0; + + if (pTrans->parallel == TRN_EXEC_ONE_BY_ONE) { + code = mndTransExecuteRedoActionsOneByOne(pMnode, pTrans); + } else { + code = mndTransExecuteRedoActions(pMnode, pTrans); + } if (code == 0) { pTrans->code = 0; @@ -1135,8 +1117,8 @@ static bool mndTransPerformCommitStage(SMnode *pMnode, STrans *pTrans) { if (code == 0) { pTrans->code = 0; - pTrans->stage = TRN_STAGE_COMMIT_LOG; - mDebug("trans:%d, stage from commit to commitLog", pTrans->id); + pTrans->stage = TRN_STAGE_COMMIT_ACTION; + mDebug("trans:%d, stage from commit to commitAction", pTrans->id); continueExec = true; } else { pTrans->code = terrno; @@ -1155,35 +1137,19 @@ static bool mndTransPerformCommitStage(SMnode *pMnode, STrans *pTrans) { return continueExec; } -static bool mndTransPerformCommitLogStage(SMnode *pMnode, STrans *pTrans) { +static bool mndTransPerformCommitActionStage(SMnode *pMnode, STrans *pTrans) { bool continueExec = true; - int32_t code = mndTransExecuteCommitLogs(pMnode, pTrans); + int32_t code = mndTransExecuteCommitActions(pMnode, pTrans); if (code == 0) { pTrans->code = 0; pTrans->stage = TRN_STAGE_FINISHED; - mDebug("trans:%d, stage from commitLog to finished", pTrans->id); + mDebug("trans:%d, stage from commitAction to finished", pTrans->id); continueExec = true; } else { pTrans->code = terrno; pTrans->failedTimes++; - mError("trans:%d, stage keep on commitLog since %s, failedTimes:%d", pTrans->id, terrstr(), pTrans->failedTimes); - continueExec = false; - } - - return continueExec; -} - -static bool mndTransPerformUndoLogStage(SMnode *pMnode, STrans *pTrans) { - bool continueExec = true; - int32_t code = mndTransExecuteUndoLogs(pMnode, pTrans); - - if (code == 0) { - pTrans->stage = TRN_STAGE_ROLLBACK; - mDebug("trans:%d, stage from undoLog to rollback", pTrans->id); - continueExec = true; - } else { - mError("trans:%d, stage keep on undoLog since %s", pTrans->id, terrstr()); + mError("trans:%d, stage keep on commitAction since %s, failedTimes:%d", pTrans->id, terrstr(), pTrans->failedTimes); continueExec = false; } @@ -1191,14 +1157,12 @@ static bool mndTransPerformUndoLogStage(SMnode *pMnode, STrans *pTrans) { } static bool mndTransPerformUndoActionStage(SMnode *pMnode, STrans *pTrans) { - if (!pMnode->deploy && !mndIsMaster(pMnode)) return false; - bool continueExec = true; int32_t code = mndTransExecuteUndoActions(pMnode, pTrans); if (code == 0) { - pTrans->stage = TRN_STAGE_UNDO_LOG; - mDebug("trans:%d, stage from undoAction to undoLog", pTrans->id); + pTrans->stage = TRN_STAGE_ROLLBACK; + mDebug("trans:%d, stage from undoAction to rollback", pTrans->id); continueExec = true; } else if (code == TSDB_CODE_ACTION_IN_PROGRESS) { mDebug("trans:%d, stage keep on undoAction since %s", pTrans->id, tstrerror(code)); @@ -1257,24 +1221,18 @@ static void mndTransExecute(SMnode *pMnode, STrans *pTrans) { case TRN_STAGE_PREPARE: continueExec = mndTransPerformPrepareStage(pMnode, pTrans); break; - case TRN_STAGE_REDO_LOG: - continueExec = mndTransPerformRedoLogStage(pMnode, pTrans); - break; case TRN_STAGE_REDO_ACTION: continueExec = mndTransPerformRedoActionStage(pMnode, pTrans); break; - case TRN_STAGE_UNDO_LOG: - continueExec = mndTransPerformUndoLogStage(pMnode, pTrans); + case TRN_STAGE_COMMIT: + continueExec = mndTransPerformCommitStage(pMnode, pTrans); + break; + case TRN_STAGE_COMMIT_ACTION: + continueExec = mndTransPerformCommitActionStage(pMnode, pTrans); break; case TRN_STAGE_UNDO_ACTION: continueExec = mndTransPerformUndoActionStage(pMnode, pTrans); break; - case TRN_STAGE_COMMIT_LOG: - continueExec = mndTransPerformCommitLogStage(pMnode, pTrans); - break; - case TRN_STAGE_COMMIT: - continueExec = mndTransPerformCommitStage(pMnode, pTrans); - break; case TRN_STAGE_ROLLBACK: continueExec = mndTransPerformRollbackStage(pMnode, pTrans); break; diff --git a/tests/test/c/sdbDump.c b/tests/test/c/sdbDump.c index 8be2822c0a..7343b4f829 100644 --- a/tests/test/c/sdbDump.c +++ b/tests/test/c/sdbDump.c @@ -283,9 +283,7 @@ void dumpTrans(SSdb *pSdb, SJson *json) { tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime)); tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid)); tjsonAddStringToObject(item, "dbname", pObj->dbname); - tjsonAddIntegerToObject(item, "redoLogNum", taosArrayGetSize(pObj->redoLogs)); - tjsonAddIntegerToObject(item, "undoLogNum", taosArrayGetSize(pObj->undoLogs)); - tjsonAddIntegerToObject(item, "commitLogNum", taosArrayGetSize(pObj->commitLogs)); + tjsonAddIntegerToObject(item, "commitLogNum", taosArrayGetSize(pObj->commitActions)); tjsonAddIntegerToObject(item, "redoActionNum", taosArrayGetSize(pObj->redoActions)); tjsonAddIntegerToObject(item, "undoActionNum", taosArrayGetSize(pObj->undoActions)); From 86f8bf6cb10832bd311737f6dff6398f49b51354 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Tue, 31 May 2022 14:38:15 +0800 Subject: [PATCH 03/28] refactor: make trans support multi steps --- source/dnode/mgmt/node_mgmt/src/dmTransport.c | 2 +- source/dnode/mnode/impl/inc/mndTrans.h | 15 +- source/dnode/mnode/impl/src/mndAcct.c | 8 +- source/dnode/mnode/impl/src/mndCluster.c | 4 +- source/dnode/mnode/impl/src/mndDb.c | 2 +- source/dnode/mnode/impl/src/mndDnode.c | 10 +- source/dnode/mnode/impl/src/mndMain.c | 2 +- source/dnode/mnode/impl/src/mndMnode.c | 2 +- source/dnode/mnode/impl/src/mndStb.c | 2 +- source/dnode/mnode/impl/src/mndSync.c | 4 +- source/dnode/mnode/impl/src/mndTrans.c | 216 +++++++++++------- source/dnode/mnode/impl/src/mndUser.c | 2 +- source/dnode/mnode/impl/src/mndVgroup.c | 4 +- source/dnode/mnode/sdb/inc/sdb.h | 1 + source/dnode/mnode/sdb/src/sdb.c | 1 + source/dnode/mnode/sdb/src/sdbFile.c | 54 +++-- source/libs/qworker/src/qworker.c | 6 +- 17 files changed, 196 insertions(+), 139 deletions(-) diff --git a/source/dnode/mgmt/node_mgmt/src/dmTransport.c b/source/dnode/mgmt/node_mgmt/src/dmTransport.c index 987fc54416..e5893fd947 100644 --- a/source/dnode/mgmt/node_mgmt/src/dmTransport.c +++ b/source/dnode/mgmt/node_mgmt/src/dmTransport.c @@ -130,7 +130,7 @@ static void dmProcessRpcMsg(SDnode *pDnode, SRpcMsg *pRpc, SEpSet *pEpSet) { _OVER: if (code != 0) { - dError("msg:%p, failed to process since %s", pMsg, terrstr()); + dTrace("msg:%p, failed to process since %s, type:%s", pMsg, terrstr(), TMSG_INFO(pRpc->msgType)); if (terrno != 0) code = terrno; if (IsReq(pRpc)) { diff --git a/source/dnode/mnode/impl/inc/mndTrans.h b/source/dnode/mnode/impl/inc/mndTrans.h index d9408467ad..a7e1f7cd02 100644 --- a/source/dnode/mnode/impl/inc/mndTrans.h +++ b/source/dnode/mnode/impl/inc/mndTrans.h @@ -31,17 +31,18 @@ typedef enum { typedef struct { int32_t id; - tmsg_t msgType; - int8_t msgSent; - int8_t msgReceived; - int8_t isRaw; - int8_t rawWritten; - SSdbRaw *pRaw; - SEpSet epSet; int32_t errCode; int32_t acceptableCode; + int8_t stage; + int8_t isRaw; + int8_t rawWritten; + int8_t msgSent; + int8_t msgReceived; + tmsg_t msgType; + SEpSet epSet; int32_t contLen; void *pCont; + SSdbRaw *pRaw; } STransAction; typedef void (*TransCbFp)(SMnode *pMnode, void *param, int32_t paramLen); diff --git a/source/dnode/mnode/impl/src/mndAcct.c b/source/dnode/mnode/impl/src/mndAcct.c index a4fde4b706..f3ec3a421b 100644 --- a/source/dnode/mnode/impl/src/mndAcct.c +++ b/source/dnode/mnode/impl/src/mndAcct.c @@ -78,10 +78,8 @@ static int32_t mndCreateDefaultAcct(SMnode *pMnode) { if (pRaw == NULL) return -1; sdbSetRawStatus(pRaw, SDB_STATUS_READY); - mDebug("acct:%s, will be created while deploy sdb, raw:%p", acctObj.acct, pRaw); -#if 0 - return sdbWrite(pMnode->pSdb, pRaw); -#else + mDebug("acct:%s, will be created when deploying, raw:%p", acctObj.acct, pRaw); + STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_CREATE_ACCT, NULL); if (pTrans == NULL) { mError("acct:%s, failed to create since %s", acctObj.acct, terrstr()); @@ -94,7 +92,6 @@ static int32_t mndCreateDefaultAcct(SMnode *pMnode) { mndTransDrop(pTrans); return -1; } - sdbSetRawStatus(pRaw, SDB_STATUS_READY); if (mndTransPrepare(pMnode, pTrans) != 0) { mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr()); @@ -104,7 +101,6 @@ static int32_t mndCreateDefaultAcct(SMnode *pMnode) { mndTransDrop(pTrans); return 0; -#endif } static SSdbRaw *mndAcctActionEncode(SAcctObj *pAcct) { diff --git a/source/dnode/mnode/impl/src/mndCluster.c b/source/dnode/mnode/impl/src/mndCluster.c index a421be5c06..76c8acf407 100644 --- a/source/dnode/mnode/impl/src/mndCluster.c +++ b/source/dnode/mnode/impl/src/mndCluster.c @@ -172,13 +172,13 @@ static int32_t mndCreateDefaultCluster(SMnode *pMnode) { clusterObj.id = mndGenerateUid(clusterObj.name, TSDB_CLUSTER_ID_LEN); clusterObj.id = (clusterObj.id >= 0 ? clusterObj.id : -clusterObj.id); pMnode->clusterId = clusterObj.id; - mDebug("cluster:%" PRId64 ", name is %s", clusterObj.id, clusterObj.name); + mInfo("cluster:%" PRId64 ", name is %s", clusterObj.id, clusterObj.name); SSdbRaw *pRaw = mndClusterActionEncode(&clusterObj); if (pRaw == NULL) return -1; sdbSetRawStatus(pRaw, SDB_STATUS_READY); - mDebug("cluster:%" PRId64 ", will be created while deploy sdb, raw:%p", clusterObj.id, pRaw); + mDebug("cluster:%" PRId64 ", will be created when deploying, raw:%p", clusterObj.id, pRaw); #if 0 return sdbWrite(pMnode->pSdb, pRaw); #else diff --git a/source/dnode/mnode/impl/src/mndDb.c b/source/dnode/mnode/impl/src/mndDb.c index 95d3383ee1..e3f843f0c7 100644 --- a/source/dnode/mnode/impl/src/mndDb.c +++ b/source/dnode/mnode/impl/src/mndDb.c @@ -1314,7 +1314,7 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbVgVersion *pDbs, int32_t numOfDbs, SDbObj *pDb = mndAcquireDb(pMnode, pDbVgVersion->dbFName); if (pDb == NULL) { - mDebug("db:%s, no exist", pDbVgVersion->dbFName); + mTrace("db:%s, no exist", pDbVgVersion->dbFName); memcpy(usedbRsp.db, pDbVgVersion->dbFName, TSDB_DB_FNAME_LEN); usedbRsp.uid = pDbVgVersion->dbId; usedbRsp.vgVersion = -1; diff --git a/source/dnode/mnode/impl/src/mndDnode.c b/source/dnode/mnode/impl/src/mndDnode.c index 22f858c60b..8e06139c8c 100644 --- a/source/dnode/mnode/impl/src/mndDnode.c +++ b/source/dnode/mnode/impl/src/mndDnode.c @@ -98,7 +98,7 @@ static int32_t mndCreateDefaultDnode(SMnode *pMnode) { if (pRaw == NULL) return -1; if (sdbSetRawStatus(pRaw, SDB_STATUS_READY) != 0) return -1; - mDebug("dnode:%d, will be created while deploy sdb, raw:%p", dnodeObj.id, pRaw); + mDebug("dnode:%d, will be created when deploying, raw:%p", dnodeObj.id, pRaw); #if 0 return sdbWrite(pMnode->pSdb, pRaw); @@ -388,9 +388,10 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) { mndReleaseMnode(pMnode, pObj); } + int64_t dnodeVer = sdbGetTableVer(pMnode->pSdb, SDB_DNODE) + sdbGetTableVer(pMnode->pSdb, SDB_MNODE); int64_t curMs = taosGetTimestampMs(); bool online = mndIsDnodeOnline(pMnode, pDnode, curMs); - bool dnodeChanged = (statusReq.dnodeVer != sdbGetTableVer(pMnode->pSdb, SDB_DNODE)); + bool dnodeChanged = (statusReq.dnodeVer != dnodeVer); bool reboot = (pDnode->rebootTime != statusReq.rebootTime); bool needCheck = !online || dnodeChanged || reboot; @@ -433,7 +434,8 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) { if (!online) { mInfo("dnode:%d, from offline to online", pDnode->id); } else { - mDebug("dnode:%d, send dnode eps", pDnode->id); + mDebug("dnode:%d, send dnode epset, online:%d ver:% " PRId64 ":%" PRId64 " reboot:%d", pDnode->id, online, + statusReq.dnodeVer, dnodeVer, reboot); } pDnode->rebootTime = statusReq.rebootTime; @@ -441,7 +443,7 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) { pDnode->numOfSupportVnodes = statusReq.numOfSupportVnodes; SStatusRsp statusRsp = {0}; - statusRsp.dnodeVer = sdbGetTableVer(pMnode->pSdb, SDB_DNODE) + sdbGetTableVer(pMnode->pSdb, SDB_MNODE); + statusRsp.dnodeVer = dnodeVer; statusRsp.dnodeCfg.dnodeId = pDnode->id; statusRsp.dnodeCfg.clusterId = pMnode->clusterId; statusRsp.pDnodeEps = taosArrayInit(mndGetDnodeSize(pMnode), sizeof(SDnodeEp)); diff --git a/source/dnode/mnode/impl/src/mndMain.c b/source/dnode/mnode/impl/src/mndMain.c index 0ac36c20ed..2a2a45a45d 100644 --- a/source/dnode/mnode/impl/src/mndMain.c +++ b/source/dnode/mnode/impl/src/mndMain.c @@ -472,7 +472,7 @@ int32_t mndProcessRpcMsg(SRpcMsg *pMsg) { } else if (code == 0) { mTrace("msg:%p, successfully processed and response", pMsg); } else { - mError("msg:%p, failed to process since %s, app:%p type:%s", pMsg, terrstr(), pMsg->info.ahandle, + mDebug("msg:%p, failed to process since %s, app:%p type:%s", pMsg, terrstr(), pMsg->info.ahandle, TMSG_INFO(pMsg->msgType)); } diff --git a/source/dnode/mnode/impl/src/mndMnode.c b/source/dnode/mnode/impl/src/mndMnode.c index 23634be77b..8c5ea840af 100644 --- a/source/dnode/mnode/impl/src/mndMnode.c +++ b/source/dnode/mnode/impl/src/mndMnode.c @@ -90,7 +90,7 @@ static int32_t mndCreateDefaultMnode(SMnode *pMnode) { if (pRaw == NULL) return -1; sdbSetRawStatus(pRaw, SDB_STATUS_READY); - mDebug("mnode:%d, will be created while deploy sdb, raw:%p", mnodeObj.id, pRaw); + mDebug("mnode:%d, will be created when deploying, raw:%p", mnodeObj.id, pRaw); #if 0 return sdbWrite(pMnode->pSdb, pRaw); diff --git a/source/dnode/mnode/impl/src/mndStb.c b/source/dnode/mnode/impl/src/mndStb.c index b33c09a0f9..81c3b24d97 100644 --- a/source/dnode/mnode/impl/src/mndStb.c +++ b/source/dnode/mnode/impl/src/mndStb.c @@ -1597,7 +1597,7 @@ static int32_t mndProcessTableMetaReq(SRpcMsg *pReq) { pReq->info.rspLen = rspLen; code = 0; - mDebug("stb:%s.%s, meta is retrieved", infoReq.dbFName, infoReq.tbName); + mTrace("%s.%s, meta is retrieved", infoReq.dbFName, infoReq.tbName); _OVER: if (code != 0) { diff --git a/source/dnode/mnode/impl/src/mndSync.c b/source/dnode/mnode/impl/src/mndSync.c index 8b602d796c..245f0938b9 100644 --- a/source/dnode/mnode/impl/src/mndSync.c +++ b/source/dnode/mnode/impl/src/mndSync.c @@ -65,7 +65,7 @@ int32_t mndSyncGetSnapshot(struct SSyncFSM *pFsm, SSnapshot *pSnapshot) { void mndRestoreFinish(struct SSyncFSM *pFsm) { SMnode *pMnode = pFsm->data; if (!pMnode->deploy) { - mInfo("mnode sync restore finished"); + mInfo("mnode sync restore finished, and will handle outstanding transactions"); mndTransPullup(pMnode); mndSetRestore(pMnode, true); } else { @@ -244,7 +244,7 @@ void mndSyncStart(SMnode *pMnode) { } else { syncStart(pMgmt->sync); } - mDebug("sync:%" PRId64 " is started, standby:%d", pMgmt->sync, pMgmt->standby); + mDebug("mnode sync started, id:%" PRId64 " standby:%d", pMgmt->sync, pMgmt->standby); } void mndSyncStop(SMnode *pMnode) {} diff --git a/source/dnode/mnode/impl/src/mndTrans.c b/source/dnode/mnode/impl/src/mndTrans.c index 239e1bf4b1..c5a1e0ba5a 100644 --- a/source/dnode/mnode/impl/src/mndTrans.c +++ b/source/dnode/mnode/impl/src/mndTrans.c @@ -37,7 +37,6 @@ static int32_t mndTransAppendAction(SArray *pArray, STransAction *pAction); static void mndTransDropLogs(SArray *pArray); static void mndTransDropActions(SArray *pArray); static void mndTransDropData(STrans *pTrans); -static int32_t mndTransExecuteLogs(SMnode *pMnode, SArray *pArray); static int32_t mndTransExecuteActions(SMnode *pMnode, STrans *pTrans, SArray *pArray); static int32_t mndTransExecuteRedoLogs(SMnode *pMnode, STrans *pTrans); static int32_t mndTransExecuteUndoLogs(SMnode *pMnode, STrans *pTrans); @@ -133,15 +132,21 @@ static SSdbRaw *mndTransActionEncode(STrans *pTrans) { for (int32_t i = 0; i < redoActionNum; ++i) { STransAction *pAction = taosArrayGet(pTrans->redoActions, i); + SDB_SET_INT32(pRaw, dataPos, pAction->id, _OVER) + SDB_SET_INT32(pRaw, dataPos, pAction->errCode, _OVER) + SDB_SET_INT32(pRaw, dataPos, pAction->acceptableCode, _OVER) SDB_SET_INT8(pRaw, dataPos, pAction->isRaw, _OVER) + SDB_SET_INT8(pRaw, dataPos, pAction->stage, _OVER) if (pAction->isRaw) { int32_t len = sdbGetRawTotalSize(pAction->pRaw); + SDB_SET_INT8(pRaw, dataPos, pAction->rawWritten, _OVER) SDB_SET_INT32(pRaw, dataPos, len, _OVER) SDB_SET_BINARY(pRaw, dataPos, (void *)pAction->pRaw, len, _OVER) } else { SDB_SET_BINARY(pRaw, dataPos, (void *)&pAction->epSet, sizeof(SEpSet), _OVER) SDB_SET_INT16(pRaw, dataPos, pAction->msgType, _OVER) - SDB_SET_INT32(pRaw, dataPos, pAction->acceptableCode, _OVER) + SDB_SET_INT8(pRaw, dataPos, pAction->msgSent, _OVER) + SDB_SET_INT8(pRaw, dataPos, pAction->msgReceived, _OVER) SDB_SET_INT32(pRaw, dataPos, pAction->contLen, _OVER) SDB_SET_BINARY(pRaw, dataPos, pAction->pCont, pAction->contLen, _OVER) } @@ -149,15 +154,21 @@ static SSdbRaw *mndTransActionEncode(STrans *pTrans) { for (int32_t i = 0; i < undoActionNum; ++i) { STransAction *pAction = taosArrayGet(pTrans->undoActions, i); + SDB_SET_INT32(pRaw, dataPos, pAction->id, _OVER) + SDB_SET_INT32(pRaw, dataPos, pAction->errCode, _OVER) + SDB_SET_INT32(pRaw, dataPos, pAction->acceptableCode, _OVER) SDB_SET_INT8(pRaw, dataPos, pAction->isRaw, _OVER) + SDB_SET_INT8(pRaw, dataPos, pAction->stage, _OVER) if (pAction->isRaw) { int32_t len = sdbGetRawTotalSize(pAction->pRaw); + SDB_SET_INT8(pRaw, dataPos, pAction->rawWritten, _OVER) SDB_SET_INT32(pRaw, dataPos, len, _OVER) SDB_SET_BINARY(pRaw, dataPos, (void *)pAction->pRaw, len, _OVER) } else { SDB_SET_BINARY(pRaw, dataPos, (void *)&pAction->epSet, sizeof(SEpSet), _OVER) SDB_SET_INT16(pRaw, dataPos, pAction->msgType, _OVER) - SDB_SET_INT32(pRaw, dataPos, pAction->acceptableCode, _OVER) + SDB_SET_INT8(pRaw, dataPos, pAction->msgSent, _OVER) + SDB_SET_INT8(pRaw, dataPos, pAction->msgReceived, _OVER) SDB_SET_INT32(pRaw, dataPos, pAction->contLen, _OVER) SDB_SET_BINARY(pRaw, dataPos, pAction->pCont, pAction->contLen, _OVER) } @@ -165,15 +176,21 @@ static SSdbRaw *mndTransActionEncode(STrans *pTrans) { for (int32_t i = 0; i < commitActionNum; ++i) { STransAction *pAction = taosArrayGet(pTrans->commitActions, i); + SDB_SET_INT32(pRaw, dataPos, pAction->id, _OVER) + SDB_SET_INT32(pRaw, dataPos, pAction->errCode, _OVER) + SDB_SET_INT32(pRaw, dataPos, pAction->acceptableCode, _OVER) SDB_SET_INT8(pRaw, dataPos, pAction->isRaw, _OVER) + SDB_SET_INT8(pRaw, dataPos, pAction->stage, _OVER) if (pAction->isRaw) { int32_t len = sdbGetRawTotalSize(pAction->pRaw); + SDB_SET_INT8(pRaw, dataPos, pAction->rawWritten, _OVER) SDB_SET_INT32(pRaw, dataPos, len, _OVER) SDB_SET_BINARY(pRaw, dataPos, (void *)pAction->pRaw, len, _OVER) } else { SDB_SET_BINARY(pRaw, dataPos, (void *)&pAction->epSet, sizeof(SEpSet), _OVER) SDB_SET_INT16(pRaw, dataPos, pAction->msgType, _OVER) - SDB_SET_INT32(pRaw, dataPos, pAction->acceptableCode, _OVER) + SDB_SET_INT8(pRaw, dataPos, pAction->msgSent, _OVER) + SDB_SET_INT8(pRaw, dataPos, pAction->msgReceived, _OVER) SDB_SET_INT32(pRaw, dataPos, pAction->contLen, _OVER) SDB_SET_BINARY(pRaw, dataPos, pAction->pCont, pAction->contLen, _OVER) } @@ -259,19 +276,25 @@ static SSdbRow *mndTransActionDecode(SSdbRaw *pRaw) { if (pTrans->commitActions == NULL) goto _OVER; for (int32_t i = 0; i < redoActionNum; ++i) { + SDB_GET_INT32(pRaw, dataPos, &action.id, _OVER) + SDB_GET_INT32(pRaw, dataPos, &action.errCode, _OVER) + SDB_GET_INT32(pRaw, dataPos, &action.acceptableCode, _OVER) SDB_GET_INT8(pRaw, dataPos, &action.isRaw, _OVER) + SDB_GET_INT8(pRaw, dataPos, &action.stage, _OVER) if (action.isRaw) { + SDB_GET_INT8(pRaw, dataPos, &action.rawWritten, _OVER) SDB_GET_INT32(pRaw, dataPos, &dataLen, _OVER) - pData = taosMemoryMalloc(dataLen); - if (pData == NULL) goto _OVER; + action.pRaw = taosMemoryMalloc(dataLen); + if (action.pRaw == NULL) goto _OVER; mTrace("raw:%p, is created", pData); - SDB_GET_BINARY(pRaw, dataPos, pData, dataLen, _OVER); - if (taosArrayPush(pTrans->redoActions, &pData) == NULL) goto _OVER; - pData = NULL; + SDB_GET_BINARY(pRaw, dataPos, (void *)action.pRaw, dataLen, _OVER); + if (taosArrayPush(pTrans->redoActions, &action) == NULL) goto _OVER; + action.pRaw = NULL; } else { SDB_GET_BINARY(pRaw, dataPos, (void *)&action.epSet, sizeof(SEpSet), _OVER); SDB_GET_INT16(pRaw, dataPos, &action.msgType, _OVER) - SDB_GET_INT32(pRaw, dataPos, &action.acceptableCode, _OVER) + SDB_GET_INT8(pRaw, dataPos, &action.msgSent, _OVER) + SDB_GET_INT8(pRaw, dataPos, &action.msgReceived, _OVER) SDB_GET_INT32(pRaw, dataPos, &action.contLen, _OVER) action.pCont = taosMemoryMalloc(action.contLen); if (action.pCont == NULL) goto _OVER; @@ -282,19 +305,25 @@ static SSdbRow *mndTransActionDecode(SSdbRaw *pRaw) { } for (int32_t i = 0; i < undoActionNum; ++i) { + SDB_GET_INT32(pRaw, dataPos, &action.id, _OVER) + SDB_GET_INT32(pRaw, dataPos, &action.errCode, _OVER) + SDB_GET_INT32(pRaw, dataPos, &action.acceptableCode, _OVER) SDB_GET_INT8(pRaw, dataPos, &action.isRaw, _OVER) + SDB_GET_INT8(pRaw, dataPos, &action.stage, _OVER) if (action.isRaw) { + SDB_GET_INT8(pRaw, dataPos, &action.rawWritten, _OVER) SDB_GET_INT32(pRaw, dataPos, &dataLen, _OVER) - pData = taosMemoryMalloc(dataLen); - if (pData == NULL) goto _OVER; + action.pRaw = taosMemoryMalloc(dataLen); + if (action.pRaw == NULL) goto _OVER; mTrace("raw:%p, is created", pData); - SDB_GET_BINARY(pRaw, dataPos, pData, dataLen, _OVER); - if (taosArrayPush(pTrans->undoActions, &pData) == NULL) goto _OVER; - pData = NULL; + SDB_GET_BINARY(pRaw, dataPos, (void *)action.pRaw, dataLen, _OVER); + if (taosArrayPush(pTrans->undoActions, &action) == NULL) goto _OVER; + action.pRaw = NULL; } else { SDB_GET_BINARY(pRaw, dataPos, (void *)&action.epSet, sizeof(SEpSet), _OVER); SDB_GET_INT16(pRaw, dataPos, &action.msgType, _OVER) - SDB_GET_INT32(pRaw, dataPos, &action.acceptableCode, _OVER) + SDB_GET_INT8(pRaw, dataPos, &action.msgSent, _OVER) + SDB_GET_INT8(pRaw, dataPos, &action.msgReceived, _OVER) SDB_GET_INT32(pRaw, dataPos, &action.contLen, _OVER) action.pCont = taosMemoryMalloc(action.contLen); if (action.pCont == NULL) goto _OVER; @@ -305,19 +334,25 @@ static SSdbRow *mndTransActionDecode(SSdbRaw *pRaw) { } for (int32_t i = 0; i < commitActionNum; ++i) { + SDB_GET_INT32(pRaw, dataPos, &action.id, _OVER) + SDB_GET_INT32(pRaw, dataPos, &action.errCode, _OVER) + SDB_GET_INT32(pRaw, dataPos, &action.acceptableCode, _OVER) SDB_GET_INT8(pRaw, dataPos, &action.isRaw, _OVER) + SDB_GET_INT8(pRaw, dataPos, &action.stage, _OVER) if (action.isRaw) { + SDB_GET_INT8(pRaw, dataPos, &action.rawWritten, _OVER) SDB_GET_INT32(pRaw, dataPos, &dataLen, _OVER) - pData = taosMemoryMalloc(dataLen); - if (pData == NULL) goto _OVER; + action.pRaw = taosMemoryMalloc(dataLen); + if (action.pRaw == NULL) goto _OVER; mTrace("raw:%p, is created", pData); - SDB_GET_BINARY(pRaw, dataPos, pData, dataLen, _OVER); - if (taosArrayPush(pTrans->commitActions, &pData) == NULL) goto _OVER; - pData = NULL; + SDB_GET_BINARY(pRaw, dataPos, (void *)action.pRaw, dataLen, _OVER); + if (taosArrayPush(pTrans->commitActions, &action) == NULL) goto _OVER; + action.pRaw = NULL; } else { SDB_GET_BINARY(pRaw, dataPos, (void *)&action.epSet, sizeof(SEpSet), _OVER); SDB_GET_INT16(pRaw, dataPos, &action.msgType, _OVER) - SDB_GET_INT32(pRaw, dataPos, &action.acceptableCode, _OVER) + SDB_GET_INT8(pRaw, dataPos, &action.msgSent, _OVER) + SDB_GET_INT8(pRaw, dataPos, &action.msgReceived, _OVER) SDB_GET_INT32(pRaw, dataPos, &action.contLen, _OVER) action.pCont = taosMemoryMalloc(action.contLen); if (action.pCont == NULL) goto _OVER; @@ -344,7 +379,6 @@ _OVER: mError("trans:%d, failed to parse from raw:%p since %s", pTrans->id, pRaw, terrstr()); mndTransDropData(pTrans); taosMemoryFreeClear(pRow); - taosMemoryFreeClear(pData); taosMemoryFreeClear(action.pCont); return NULL; } @@ -502,7 +536,7 @@ static void mndTransDropData(STrans *pTrans) { } static int32_t mndTransActionDelete(SSdb *pSdb, STrans *pTrans, bool callFunc) { - mDebug("trans:%d, perform delete action, row:%p stage:%s callfunc:%d", pTrans->id, pTrans, mndTransStr(pTrans->stage), + mTrace("trans:%d, perform delete action, row:%p stage:%s callfunc:%d", pTrans->id, pTrans, mndTransStr(pTrans->stage), callFunc); if (pTrans->stopFunc > 0 && callFunc) { TransCbFp fp = mndTransGetCbFp(pTrans->stopFunc); @@ -515,20 +549,34 @@ static int32_t mndTransActionDelete(SSdb *pSdb, STrans *pTrans, bool callFunc) { return 0; } +static void mndTransUpdateActions(SArray *pOldArray, SArray *pNewArray) { + for (int32_t i = 0; i < taosArrayGetSize(pOldArray); ++i) { + STransAction *pOldAction = taosArrayGet(pOldArray, i); + STransAction *pNewAction = taosArrayGet(pNewArray, i); + pOldAction->rawWritten = pNewAction->rawWritten; + pOldAction->msgSent = pNewAction->msgSent; + pOldAction->msgReceived = pNewAction->msgReceived; + pOldAction->errCode = pNewAction->errCode; + } +} + static int32_t mndTransActionUpdate(SSdb *pSdb, STrans *pOld, STrans *pNew) { - if (pNew->stage == TRN_STAGE_COMMIT) { - pNew->stage = TRN_STAGE_COMMIT_ACTION; - mTrace("trans:%d, stage from %s to %s", pNew->id, mndTransStr(TRN_STAGE_COMMIT), mndTransStr(TRN_STAGE_COMMIT_ACTION)); - } - - if (pNew->stage == TRN_STAGE_ROLLBACK) { - pNew->stage = TRN_STAGE_FINISHED; - mTrace("trans:%d, stage from %s to %s", pNew->id, mndTransStr(TRN_STAGE_ROLLBACK), mndTransStr(TRN_STAGE_FINISHED)); - } - mTrace("trans:%d, perform update action, old row:%p stage:%s, new row:%p stage:%s", pOld->id, pOld, mndTransStr(pOld->stage), pNew, mndTransStr(pNew->stage)); + mndTransUpdateActions(pOld->redoActions, pNew->redoActions); + mndTransUpdateActions(pOld->undoActions, pNew->undoActions); + mndTransUpdateActions(pOld->commitActions, pNew->commitActions); pOld->stage = pNew->stage; + + if (pOld->stage == TRN_STAGE_COMMIT) { + pOld->stage = TRN_STAGE_COMMIT_ACTION; + mTrace("trans:%d, stage from commit to commitAction", pNew->id); + } + + if (pOld->stage == TRN_STAGE_ROLLBACK) { + pOld->stage = TRN_STAGE_FINISHED; + mTrace("trans:%d, stage from rollback to finished", pNew->id); + } return 0; } @@ -557,8 +605,8 @@ STrans *mndTransCreate(SMnode *pMnode, ETrnPolicy policy, ETrnType type, const S pTrans->stage = TRN_STAGE_PREPARE; pTrans->policy = policy; pTrans->type = type; + pTrans->parallel = TRN_EXEC_PARALLEL; pTrans->createdTime = taosGetTimestampMs(); - if (pReq != NULL) pTrans->rpcInfo = pReq->info; pTrans->redoActions = taosArrayInit(TRANS_ARRAY_SIZE, sizeof(STransAction)); pTrans->undoActions = taosArrayInit(TRANS_ARRAY_SIZE, sizeof(STransAction)); pTrans->commitActions = taosArrayInit(TRANS_ARRAY_SIZE, sizeof(STransAction)); @@ -569,7 +617,8 @@ STrans *mndTransCreate(SMnode *pMnode, ETrnPolicy policy, ETrnType type, const S return NULL; } - mDebug("trans:%d, local object is created, data:%p", pTrans->id, pTrans); + if (pReq != NULL) pTrans->rpcInfo = pReq->info; + mTrace("trans:%d, local object is created, data:%p", pTrans->id, pTrans); return pTrans; } @@ -578,7 +627,7 @@ static void mndTransDropActions(SArray *pArray) { for (int32_t i = 0; i < size; ++i) { STransAction *pAction = taosArrayGet(pArray, i); if (pAction->isRaw) { - sdbFreeRaw(pAction->pRaw); + taosMemoryFreeClear(pAction->pRaw); } else { taosMemoryFreeClear(pAction->pCont); } @@ -590,12 +639,14 @@ static void mndTransDropActions(SArray *pArray) { void mndTransDrop(STrans *pTrans) { if (pTrans != NULL) { mndTransDropData(pTrans); - mDebug("trans:%d, local object is freed, data:%p", pTrans->id, pTrans); + mTrace("trans:%d, local object is freed, data:%p", pTrans->id, pTrans); taosMemoryFreeClear(pTrans); } } static int32_t mndTransAppendAction(SArray *pArray, STransAction *pAction) { + pAction->id = taosArrayGetSize(pArray); + void *ptr = taosArrayPush(pArray, pAction); if (ptr == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; @@ -606,25 +657,27 @@ static int32_t mndTransAppendAction(SArray *pArray, STransAction *pAction) { } int32_t mndTransAppendRedolog(STrans *pTrans, SSdbRaw *pRaw) { - STransAction action = {.isRaw = true, .pRaw = pRaw}; + STransAction action = {.stage = TRN_STAGE_REDO_ACTION, .isRaw = true, .pRaw = pRaw}; return mndTransAppendAction(pTrans->redoActions, &action); } int32_t mndTransAppendUndolog(STrans *pTrans, SSdbRaw *pRaw) { - STransAction action = {.isRaw = true, .pRaw = pRaw}; + STransAction action = {.stage = TRN_STAGE_UNDO_ACTION, .isRaw = true, .pRaw = pRaw}; return mndTransAppendAction(pTrans->undoActions, &action); } int32_t mndTransAppendCommitlog(STrans *pTrans, SSdbRaw *pRaw) { - STransAction action = {.isRaw = true, .pRaw = pRaw}; + STransAction action = {.stage = TRN_STAGE_COMMIT_ACTION, .isRaw = true, .pRaw = pRaw}; return mndTransAppendAction(pTrans->commitActions, &action); } int32_t mndTransAppendRedoAction(STrans *pTrans, STransAction *pAction) { + pAction->stage = TRN_STAGE_REDO_ACTION; return mndTransAppendAction(pTrans->redoActions, pAction); } int32_t mndTransAppendUndoAction(STrans *pTrans, STransAction *pAction) { + pAction->stage = TRN_STAGE_UNDO_ACTION; return mndTransAppendAction(pTrans->undoActions, pAction); } @@ -821,7 +874,8 @@ static void mndTransSendRpcRsp(SMnode *pMnode, STrans *pTrans) { } taosMemoryFree(pTrans->rpcRsp); - mDebug("trans:%d, send rsp, code:0x%x stage:%d app:%p", pTrans->id, code, pTrans->stage, pTrans->rpcInfo.ahandle); + mDebug("trans:%d, send rsp, code:0x%x stage:%s app:%p", pTrans->id, code, mndTransStr(pTrans->stage), + pTrans->rpcInfo.ahandle); SRpcMsg rspMsg = { .code = code, .pCont = rpcCont, @@ -877,55 +931,46 @@ void mndTransProcessRsp(SRpcMsg *pRsp) { } } - mDebug("trans:%d, action:%d response is received, code:0x%x, accept:0x%04x", transId, action, pRsp->code, - pAction->acceptableCode); + mDebug("trans:%d, %s:%d response is received, code:0x%x, accept:0x%x", transId, mndTransStr(pAction->stage), action, + pRsp->code, pAction->acceptableCode); mndTransExecute(pMnode, pTrans); _OVER: mndReleaseTrans(pMnode, pTrans); } -static int32_t mndTransExecuteLogs(SMnode *pMnode, SArray *pArray) { - SSdb *pSdb = pMnode->pSdb; - int32_t arraySize = taosArrayGetSize(pArray); - - if (arraySize == 0) return 0; - - int32_t code = 0; - for (int32_t i = 0; i < arraySize; ++i) { - SSdbRaw *pRaw = taosArrayGetP(pArray, i); - if (sdbWriteWithoutFree(pSdb, pRaw) != 0) { - code = ((terrno != 0) ? terrno : -1); - } - } - - terrno = code; - return code; -} - - static void mndTransResetActions(SMnode *pMnode, STrans *pTrans, SArray *pArray) { int32_t numOfActions = taosArrayGetSize(pArray); for (int32_t action = 0; action < numOfActions; ++action) { STransAction *pAction = taosArrayGet(pArray, action); if (pAction == NULL) continue; - if (pAction->msgSent && pAction->msgReceived && pAction->errCode == 0) continue; - if (pAction->rawWritten && pAction->errCode == 0) continue; + if (pAction->msgSent && pAction->msgReceived && + (pAction->errCode == 0 || pAction->errCode == pAction->acceptableCode)) + continue; + if (pAction->rawWritten && (pAction->errCode == 0 || pAction->errCode == pAction->acceptableCode)) continue; + pAction->rawWritten = 0; pAction->msgSent = 0; pAction->msgReceived = 0; pAction->errCode = 0; - mDebug("trans:%d, action:%d execute status is reset", pTrans->id, action); + mDebug("trans:%d, %s:%d execute status is reset", pTrans->id, mndTransStr(pAction->stage), action); } } static int32_t mndTransWriteSingleLog(SMnode *pMnode, STrans *pTrans, STransAction *pAction) { + if (pAction->rawWritten) return 0; + int32_t code = sdbWriteWithoutFree(pMnode->pSdb, pAction->pRaw); - if (code == 0) { - mDebug("trans:%d, action:%d write to sdb", pTrans->id, pAction->id); + if (code == 0 || terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) { + pAction->rawWritten = true; + pAction->errCode = 0; + code = 0; + mDebug("trans:%d, %s:%d write to sdb", pTrans->id, mndTransStr(pAction->stage), pAction->id); } else { - mError("trans:%d, action:%d failed to write sdb since %s", pTrans->id, pAction->id, terrstr()); + pAction->errCode = (terrno != 0) ? terrno : code; + mError("trans:%d, %s:%d failed to write sdb since %s", pTrans->id, mndTransStr(pAction->stage), pAction->id, + terrstr()); } return code; @@ -952,13 +997,13 @@ static int32_t mndTransSendSingleMsg(SMnode *pMnode, STrans *pTrans, STransActio pAction->msgSent = 1; pAction->msgReceived = 0; pAction->errCode = 0; - mDebug("trans:%d, action:%d is sent to %s:%u", pTrans->id, pAction->id, + mDebug("trans:%d, %s:%d is sent to %s:%u", pTrans->id, mndTransStr(pAction->stage), pAction->id, pAction->epSet.eps[pAction->epSet.inUse].fqdn, pAction->epSet.eps[pAction->epSet.inUse].port); } else { pAction->msgSent = 0; pAction->msgReceived = 0; pAction->errCode = (terrno != 0) ? terrno : code; - mError("trans:%d, action:%d not send since %s", pTrans->id, pAction->id, terrstr()); + mError("trans:%d, %s:%d not send since %s", pTrans->id, mndTransStr(pAction->stage), pAction->id, terrstr()); } return code; @@ -995,20 +1040,20 @@ static int32_t mndTransExecuteActions(SMnode *pMnode, STrans *pTrans, SArray *pA return -1; } - int32_t numOfReceived = 0; + int32_t numOfExecuted = 0; int32_t errCode = 0; for (int32_t action = 0; action < numOfActions; ++action) { STransAction *pAction = taosArrayGet(pArray, action); if (pAction == NULL) continue; - if (pAction->msgSent && pAction->msgReceived) { - numOfReceived++; + if ((pAction->msgSent && pAction->msgReceived) || pAction->rawWritten) { + numOfExecuted++; if (pAction->errCode != 0 && pAction->errCode != pAction->acceptableCode) { errCode = pAction->errCode; } } } - if (numOfReceived == numOfActions) { + if (numOfExecuted == numOfActions) { if (errCode == 0) { mDebug("trans:%d, all %d actions execute successfully", pTrans->id, numOfActions); return 0; @@ -1019,7 +1064,7 @@ static int32_t mndTransExecuteActions(SMnode *pMnode, STrans *pTrans, SArray *pA return errCode; } } else { - mDebug("trans:%d, %d of %d actions executed", pTrans->id, numOfReceived, numOfActions); + mDebug("trans:%d, %d of %d actions executed", pTrans->id, numOfExecuted, numOfActions); return TSDB_CODE_ACTION_IN_PROGRESS; } } @@ -1041,7 +1086,7 @@ static int32_t mndTransExecuteUndoActions(SMnode *pMnode, STrans *pTrans) { } static int32_t mndTransExecuteCommitActions(SMnode *pMnode, STrans *pTrans) { - int32_t code = mndTransExecuteLogs(pMnode, pTrans->commitActions); + int32_t code = mndTransExecuteActions(pMnode, pTrans, pTrans->commitActions); if (code != 0) { mError("failed to execute commitActions since %s", terrstr()); } @@ -1063,14 +1108,16 @@ static bool mndTransExecuteRedoActionsOneByOne(SMnode *pMnode, STrans *pTrans) { int32_t code = mndTransExecSingleAction(pMnode, pTrans, pAction); if (code == 0) { pTrans->redoActionPos++; - mDebug("trans:%d, redo action:%d is executed and need sync to other mnodes", pTrans->id, pAction->id); + mDebug("trans:%d, %s:%d is executed and need sync to other mnodes", pTrans->id, mndTransStr(pAction->stage), + pAction->id); // todo sync these infos } else if (code == TSDB_CODE_ACTION_IN_PROGRESS) { - mDebug("trans:%d, redo action:%d is in progress and wait it finish", pTrans->id, pAction->id); + mDebug("trans:%d, %s:%d is in progress and wait it finish", pTrans->id, mndTransStr(pAction->stage), pAction->id); continueExec = false; } else { - mError("trans:%d, redo action:%d failed to execute since %s", pTrans->id, pAction->id, terrstr()); + mError("trans:%d, %s:%d failed to execute since %s", pTrans->id, mndTransStr(pAction->stage), pAction->id, + terrstr()); continueExec = false; } @@ -1207,8 +1254,7 @@ static bool mndTransPerfromFinishedStage(SMnode *pMnode, STrans *pTrans) { mError("trans:%d, failed to write sdb since %s", pTrans->id, terrstr()); } - mDebug("trans:%d, finished, code:0x%x, failedTimes:%d", pTrans->id, pTrans->code, pTrans->failedTimes); - + mDebug("trans:%d, execute finished, code:0x%x, failedTimes:%d", pTrans->id, pTrans->code, pTrans->failedTimes); return continueExec; } @@ -1271,15 +1317,15 @@ int32_t mndKillTrans(SMnode *pMnode, STrans *pTrans) { if (pAction == NULL) continue; if (pAction->msgReceived == 0) { - mInfo("trans:%d, action:%d set processed for kill msg received", pTrans->id, i); + mInfo("trans:%d, %s:%d set processed for kill msg received", pTrans->id, mndTransStr(pAction->stage), i); pAction->msgSent = 1; pAction->msgReceived = 1; pAction->errCode = 0; } if (pAction->errCode != 0) { - mInfo("trans:%d, action:%d set processed for kill msg received, errCode from %s to success", pTrans->id, i, - tstrerror(pAction->errCode)); + mInfo("trans:%d, %s:%d set processed for kill msg received, errCode from %s to success", pTrans->id, + mndTransStr(pAction->stage), i, tstrerror(pAction->errCode)); pAction->msgSent = 1; pAction->msgReceived = 1; pAction->errCode = 0; diff --git a/source/dnode/mnode/impl/src/mndUser.c b/source/dnode/mnode/impl/src/mndUser.c index cc6364c457..83d00c86e3 100644 --- a/source/dnode/mnode/impl/src/mndUser.c +++ b/source/dnode/mnode/impl/src/mndUser.c @@ -77,7 +77,7 @@ static int32_t mndCreateDefaultUser(SMnode *pMnode, char *acct, char *user, char if (pRaw == NULL) return -1; sdbSetRawStatus(pRaw, SDB_STATUS_READY); - mDebug("user:%s, will be created while deploy sdb, raw:%p", userObj.user, pRaw); + mDebug("user:%s, will be created when deploying, raw:%p", userObj.user, pRaw); #if 0 return sdbWrite(pMnode->pSdb, pRaw); diff --git a/source/dnode/mnode/impl/src/mndVgroup.c b/source/dnode/mnode/impl/src/mndVgroup.c index e05b38a7c0..161fc5379c 100644 --- a/source/dnode/mnode/impl/src/mndVgroup.c +++ b/source/dnode/mnode/impl/src/mndVgroup.c @@ -501,7 +501,7 @@ int32_t mndAllocVgroup(SMnode *pMnode, SDbObj *pDb, SVgObj **ppVgroups) { *ppVgroups = pVgroups; code = 0; - mInfo("db:%s, %d vgroups is alloced, replica:%d", pDb->name, pDb->cfg.numOfVgroups, pDb->cfg.replications); + mInfo("db:%s, total %d vgroups is alloced, replica:%d", pDb->name, pDb->cfg.numOfVgroups, pDb->cfg.replications); _OVER: if (code != 0) taosMemoryFree(pVgroups); @@ -539,7 +539,7 @@ int32_t mndAddVnodeToVgroup(SMnode *pMnode, SVgObj *pVgroup, SArray *pArray) { pVgid->role = TAOS_SYNC_STATE_FOLLOWER; pDnode->numOfVnodes++; - mInfo("db:%s, vgId:%d, vn:%d dnode:%d is added", pVgroup->dbName, pVgroup->vgId, maxPos, pVgid->dnodeId); + mInfo("db:%s, vgId:%d, vnode_index:%d dnode:%d is added", pVgroup->dbName, pVgroup->vgId, maxPos, pVgid->dnodeId); maxPos++; if (maxPos == 3) return 0; } diff --git a/source/dnode/mnode/sdb/inc/sdb.h b/source/dnode/mnode/sdb/inc/sdb.h index c66b47a24b..1fd0260d0d 100644 --- a/source/dnode/mnode/sdb/inc/sdb.h +++ b/source/dnode/mnode/sdb/inc/sdb.h @@ -168,6 +168,7 @@ typedef struct SSdb { char *currDir; char *tmpDir; int64_t lastCommitVer; + int64_t lastCommitTerm; int64_t curVer; int64_t curTerm; int64_t tableVer[SDB_MAX]; diff --git a/source/dnode/mnode/sdb/src/sdb.c b/source/dnode/mnode/sdb/src/sdb.c index 485b729deb..0526ea5c2d 100644 --- a/source/dnode/mnode/sdb/src/sdb.c +++ b/source/dnode/mnode/sdb/src/sdb.c @@ -55,6 +55,7 @@ SSdb *sdbInit(SSdbOpt *pOption) { pSdb->curVer = -1; pSdb->curTerm = -1; pSdb->lastCommitVer = -1; + pSdb->lastCommitTerm = -1; pSdb->pMnode = pOption->pMnode; taosThreadMutexInit(&pSdb->filelock, NULL); mDebug("sdb init successfully"); diff --git a/source/dnode/mnode/sdb/src/sdbFile.c b/source/dnode/mnode/sdb/src/sdbFile.c index 834e7a00c8..83135491a9 100644 --- a/source/dnode/mnode/sdb/src/sdbFile.c +++ b/source/dnode/mnode/sdb/src/sdbFile.c @@ -70,6 +70,7 @@ static void sdbResetData(SSdb *pSdb) { pSdb->curVer = -1; pSdb->curTerm = -1; pSdb->lastCommitVer = -1; + pSdb->lastCommitTerm = -1; mDebug("sdb reset successfully"); } @@ -211,12 +212,12 @@ static int32_t sdbReadFileImp(SSdb *pSdb) { char file[PATH_MAX] = {0}; snprintf(file, sizeof(file), "%s%ssdb.data", pSdb->currDir, TD_DIRSEP); - mDebug("start to read file:%s", file); + mDebug("start to read sdb file:%s", file); SSdbRaw *pRaw = taosMemoryMalloc(WAL_MAX_SIZE + 100); if (pRaw == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - mError("failed read file since %s", terrstr()); + mError("failed read sdb file since %s", terrstr()); return -1; } @@ -224,12 +225,12 @@ static int32_t sdbReadFileImp(SSdb *pSdb) { if (pFile == NULL) { taosMemoryFree(pRaw); terrno = TAOS_SYSTEM_ERROR(errno); - mError("failed to read file:%s since %s", file, terrstr()); + mError("failed to read sdb file:%s since %s", file, terrstr()); return 0; } if (sdbReadFileHead(pSdb, pFile) != 0) { - mError("failed to read file:%s head since %s", file, terrstr()); + mError("failed to read sdb file:%s head since %s", file, terrstr()); taosMemoryFree(pRaw); taosCloseFile(&pFile); return -1; @@ -245,13 +246,13 @@ static int32_t sdbReadFileImp(SSdb *pSdb) { if (ret < 0) { code = TAOS_SYSTEM_ERROR(errno); - mError("failed to read file:%s since %s", file, tstrerror(code)); + mError("failed to read sdb file:%s since %s", file, tstrerror(code)); break; } if (ret != readLen) { code = TSDB_CODE_FILE_CORRUPTED; - mError("failed to read file:%s since %s", file, tstrerror(code)); + mError("failed to read sdb file:%s since %s", file, tstrerror(code)); break; } @@ -259,34 +260,36 @@ static int32_t sdbReadFileImp(SSdb *pSdb) { ret = taosReadFile(pFile, pRaw->pData, readLen); if (ret < 0) { code = TAOS_SYSTEM_ERROR(errno); - mError("failed to read file:%s since %s", file, tstrerror(code)); + mError("failed to read sdb file:%s since %s", file, tstrerror(code)); break; } if (ret != readLen) { code = TSDB_CODE_FILE_CORRUPTED; - mError("failed to read file:%s since %s", file, tstrerror(code)); + mError("failed to read sdb file:%s since %s", file, tstrerror(code)); break; } int32_t totalLen = sizeof(SSdbRaw) + pRaw->dataLen + sizeof(int32_t); if ((!taosCheckChecksumWhole((const uint8_t *)pRaw, totalLen)) != 0) { code = TSDB_CODE_CHECKSUM_ERROR; - mError("failed to read file:%s since %s", file, tstrerror(code)); + mError("failed to read sdb file:%s since %s", file, tstrerror(code)); break; } code = sdbWriteWithoutFree(pSdb, pRaw); if (code != 0) { - mError("failed to read file:%s since %s", file, terrstr()); + mError("failed to read sdb file:%s since %s", file, terrstr()); goto _OVER; } } code = 0; pSdb->lastCommitVer = pSdb->curVer; + pSdb->lastCommitTerm = pSdb->curTerm; memcpy(pSdb->tableVer, tableVer, sizeof(tableVer)); - mDebug("read file:%s successfully, ver:%" PRId64, file, pSdb->lastCommitVer); + mDebug("read sdb file:%s successfully, ver:%" PRId64 " term:%" PRId64, file, pSdb->lastCommitVer, + pSdb->lastCommitTerm); _OVER: taosCloseFile(&pFile); @@ -302,7 +305,7 @@ int32_t sdbReadFile(SSdb *pSdb) { sdbResetData(pSdb); int32_t code = sdbReadFileImp(pSdb); if (code != 0) { - mError("failed to read sdb since %s", terrstr()); + mError("failed to read sdb file since %s", terrstr()); sdbResetData(pSdb); } @@ -318,18 +321,19 @@ static int32_t sdbWriteFileImp(SSdb *pSdb) { char curfile[PATH_MAX] = {0}; snprintf(curfile, sizeof(curfile), "%s%ssdb.data", pSdb->currDir, TD_DIRSEP); - mDebug("start to write file:%s, current ver:%" PRId64 " term:%" PRId64 ", commit ver:%" PRId64, curfile, pSdb->curVer, - pSdb->curTerm, pSdb->lastCommitVer); + mDebug("start to write sdb file, current ver:%" PRId64 " term:%" PRId64 ", commit ver:%" PRId64 " term:%" PRId64 + " file:%s", + pSdb->curVer, pSdb->curTerm, pSdb->lastCommitVer, pSdb->lastCommitTerm, curfile); TdFilePtr pFile = taosOpenFile(tmpfile, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_TRUNC); if (pFile == NULL) { terrno = TAOS_SYSTEM_ERROR(errno); - mError("failed to open file:%s for write since %s", tmpfile, terrstr()); + mError("failed to open sdb file:%s for write since %s", tmpfile, terrstr()); return -1; } if (sdbWriteFileHead(pSdb, pFile) != 0) { - mError("failed to write file:%s head since %s", tmpfile, terrstr()); + mError("failed to write sdb file:%s head since %s", tmpfile, terrstr()); taosCloseFile(&pFile); return -1; } @@ -338,7 +342,7 @@ static int32_t sdbWriteFileImp(SSdb *pSdb) { SdbEncodeFp encodeFp = pSdb->encodeFps[i]; if (encodeFp == NULL) continue; - mTrace("write %s to file, total %d rows", sdbTableName(i), sdbGetSize(pSdb, i)); + mTrace("write %s to sdb file, total %d rows", sdbTableName(i), sdbGetSize(pSdb, i)); SHashObj *hash = pSdb->hashObjs[i]; TdThreadRwlock *pLock = &pSdb->locks[i]; @@ -394,7 +398,7 @@ static int32_t sdbWriteFileImp(SSdb *pSdb) { code = taosFsyncFile(pFile); if (code != 0) { code = TAOS_SYSTEM_ERROR(errno); - mError("failed to sync file:%s since %s", tmpfile, tstrerror(code)); + mError("failed to sync sdb file:%s since %s", tmpfile, tstrerror(code)); } } @@ -404,15 +408,17 @@ static int32_t sdbWriteFileImp(SSdb *pSdb) { code = taosRenameFile(tmpfile, curfile); if (code != 0) { code = TAOS_SYSTEM_ERROR(errno); - mError("failed to write file:%s since %s", curfile, tstrerror(code)); + mError("failed to write sdb file:%s since %s", curfile, tstrerror(code)); } } if (code != 0) { - mError("failed to write file:%s since %s", curfile, tstrerror(code)); + mError("failed to write sdb file:%s since %s", curfile, tstrerror(code)); } else { pSdb->lastCommitVer = pSdb->curVer; - mDebug("write file:%s successfully, ver:%" PRId64 " term:%" PRId64, curfile, pSdb->lastCommitVer, pSdb->curTerm); + pSdb->lastCommitTerm = pSdb->curTerm; + mDebug("write sdb file successfully, ver:%" PRId64 " term:%" PRId64 " file:%s", pSdb->lastCommitVer, + pSdb->lastCommitTerm, curfile); } terrno = code; @@ -427,7 +433,7 @@ int32_t sdbWriteFile(SSdb *pSdb) { taosThreadMutexLock(&pSdb->filelock); int32_t code = sdbWriteFileImp(pSdb); if (code != 0) { - mError("failed to write sdb since %s", terrstr()); + mError("failed to write sdb file since %s", terrstr()); } taosThreadMutexUnlock(&pSdb->filelock); return code; @@ -493,7 +499,7 @@ int32_t sdbStartRead(SSdb *pSdb, SSdbIter **ppIter) { if (taosCopyFile(datafile, pIter->name) < 0) { taosThreadMutexUnlock(&pSdb->filelock); terrno = TAOS_SYSTEM_ERROR(errno); - mError("failed to copy file %s to %s since %s", datafile, pIter->name, terrstr()); + mError("failed to copy sdb file %s to %s since %s", datafile, pIter->name, terrstr()); sdbCloseIter(pIter); return -1; } @@ -502,7 +508,7 @@ int32_t sdbStartRead(SSdb *pSdb, SSdbIter **ppIter) { pIter->file = taosOpenFile(pIter->name, TD_FILE_READ); if (pIter->file == NULL) { terrno = TAOS_SYSTEM_ERROR(errno); - mError("failed to open file:%s since %s", pIter->name, terrstr()); + mError("failed to open sdb file:%s since %s", pIter->name, terrstr()); sdbCloseIter(pIter); return -1; } diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c index 7201820854..655dcbc853 100644 --- a/source/libs/qworker/src/qworker.c +++ b/source/libs/qworker/src/qworker.c @@ -79,7 +79,11 @@ int32_t qwExecTask(QW_FPARAMS_DEF, SQWTaskCtx *ctx, bool *queryEnd) { if (taskHandle) { code = qExecTask(taskHandle, &pRes, &useconds); if (code) { - QW_TASK_ELOG("qExecTask failed, code:%x - %s", code, tstrerror(code)); + if (code != TSDB_CODE_OPS_NOT_SUPPORT) { + QW_TASK_ELOG("qExecTask failed, code:%x - %s", code, tstrerror(code)); + } else { + QW_TASK_DLOG("qExecTask failed, code:%x - %s", code, tstrerror(code)); + } QW_ERR_RET(code); } } From e18ad0eb696581f3c36729661e5620c8877a6d7f Mon Sep 17 00:00:00 2001 From: jiacy-jcy Date: Tue, 31 May 2022 14:51:58 +0800 Subject: [PATCH 04/28] add test case for stateduration --- tests/system-test/2-query/stateduration.py | 269 +++++++++++++++++++++ 1 file changed, 269 insertions(+) create mode 100644 tests/system-test/2-query/stateduration.py diff --git a/tests/system-test/2-query/stateduration.py b/tests/system-test/2-query/stateduration.py new file mode 100644 index 0000000000..6689fab2c3 --- /dev/null +++ b/tests/system-test/2-query/stateduration.py @@ -0,0 +1,269 @@ +################################################################### +# Copyright (c) 2016 by TAOS Technologies, Inc. +# All rights reserved. +# +# This file is proprietary and confidential to TAOS Technologies. +# No part of this file may be reproduced, stored, transmitted, +# disclosed or used in any form or by any means other than as +# expressly provided by the written permission from Jianhui Tao +# +################################################################### + +# -*- coding: utf-8 -*- + +from util.log import * +from util.cases import * +from util.sql import * + +class TDTestCase: + def init(self, conn, logSql): + tdLog.debug("start to execute %s" % __file__) + tdSql.init(conn.cursor()) + self.ts = 1537146000000 + self.param_list = ['LT','lt','Lt','lT','GT','gt','Gt','gT','LE','le','Le','lE','GE','ge','Ge','gE','NE','ne','Ne','nE','EQ','eq','Eq','eQ'] + self.row_num = 10 + def run(self): + tdSql.prepare() + + + + + # timestamp = 1ms , time_unit = 1s + tdSql.execute('''create table test(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double, + col7 bool, col8 binary(20), col9 nchar(20), col11 tinyint unsigned, col12 smallint unsigned, col13 int unsigned, col14 bigint unsigned)''') + for i in range(self.row_num): + tdSql.execute("insert into test values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)" + % (self.ts + i, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1)) + integer_list = [1,2,3,4,11,12,13,14] + float_list = [5,6] + + for i in integer_list: + for j in self.param_list: + tdSql.query(f"select stateduration(col{i},'{j}',5) from test") + tdSql.checkRows(10) + if j in ['LT' ,'lt','Lt','lT']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (0,), (0,), (0,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + elif j in ['GT','gt', 'Gt','gT']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (-1,), (0,), (0,), (0,), (0,), (0,)]) + elif j in ['LE','le','Le','lE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (0,), (0,), (0,), (0,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + elif j in [ 'GE','ge','Ge','gE']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (0,), (0,), (0,), (0,), (0,), (0,)]) + elif j in ['NE','ne','Ne','nE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (0,), (0,), (0,), (-1,), (0,), (0,), (0,), (0,), (0,)]) + elif j in ['EQ','eq','Eq','eQ']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (0,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + for i in float_list: + for j in self.param_list: + tdSql.query(f"select stateduration(col{i},'{j}',5) from test") + tdSql.checkRows(10) + if j in ['LT','lt','Lt','lT','LE','le','Le','lE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (0,), (0,), (0,), (0,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + elif j in ['GE','ge','Ge','gE','GT','gt','Gt','gT']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (-1,), (0,), (0,), (0,), (0,), (0,)]) + elif j in ['NE','ne','Ne','nE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (0,), (0,), (0,), (0,), (0,), (0,), (0,), (0,), (0,)]) + elif j in ['EQ','eq','Eq','eQ']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + + error_column_list = ['ts','col7','col8','col9','a',1] + for i in error_column_list: + for j in self.param_list: + tdSql.error(f"select stateduration({i},{j},5) from test") + + error_param_list = ['a',1] + for i in error_param_list: + tdSql.error(f"select stateduration(col1,{i},5) from test") + + # timestamp = 1s, time_unit =1s + tdSql.execute('''create table test1(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double, + col7 bool, col8 binary(20), col9 nchar(20), col11 tinyint unsigned, col12 smallint unsigned, col13 int unsigned, col14 bigint unsigned)''') + for i in range(self.row_num): + tdSql.execute("insert into test1 values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)" + % (self.ts + i*1000, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1)) + + for i in integer_list: + for j in self.param_list: + tdSql.query(f"select stateduration(col{i},'{j}',5) from test1") + tdSql.checkRows(10) + # print(tdSql.queryResult) + if j in ['LT' ,'lt','Lt','lT']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (1,), (2,), (3,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + elif j in ['GT','gt', 'Gt','gT']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (-1,), (0,), (1,), (2,), (3,), (4,)]) + elif j in ['LE','le','Le','lE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (1,), (2,), (3,), (4,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + elif j in [ 'GE','ge','Ge','gE']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (0,), (1,), (2,), (3,), (4,), (5,)]) + elif j in ['NE','ne','Ne','nE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (1,), (2,), (3,), (-1,), (0,), (1,), (2,), (3,), (4,)]) + elif j in ['EQ','eq','Eq','eQ']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (0,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + for i in float_list: + for j in self.param_list: + tdSql.query(f"select stateduration(col{i},'{j}',5) from test1") + tdSql.checkRows(10) + print(tdSql.queryResult) + if j in ['LT','lt','Lt','lT','LE','le','Le','lE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (1,), (2,), (3,), (4,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + elif j in ['GE','ge','Ge','gE','GT','gt','Gt','gT']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (-1,), (0,), (1,), (2,), (3,), (4,)]) + elif j in ['NE','ne','Ne','nE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (1,), (2,), (3,), (4,), (5,), (6,), (7,), (8,), (9,)]) + elif j in ['EQ','eq','Eq','eQ']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + + + # timestamp = 1m, time_unit =1m + tdSql.execute('''create table test2(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double, + col7 bool, col8 binary(20), col9 nchar(20), col11 tinyint unsigned, col12 smallint unsigned, col13 int unsigned, col14 bigint unsigned)''') + for i in range(self.row_num): + tdSql.execute("insert into test2 values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)" + % (self.ts + i*1000*60, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1)) + + for i in integer_list: + for j in self.param_list: + tdSql.query(f"select stateduration(col{i},'{j}',5,1m) from test2") + tdSql.checkRows(10) + # print(tdSql.queryResult) + if j in ['LT' ,'lt','Lt','lT']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (1,), (2,), (3,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + elif j in ['GT','gt', 'Gt','gT']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (-1,), (0,), (1,), (2,), (3,), (4,)]) + elif j in ['LE','le','Le','lE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (1,), (2,), (3,), (4,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + elif j in [ 'GE','ge','Ge','gE']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (0,), (1,), (2,), (3,), (4,), (5,)]) + elif j in ['NE','ne','Ne','nE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (1,), (2,), (3,), (-1,), (0,), (1,), (2,), (3,), (4,)]) + elif j in ['EQ','eq','Eq','eQ']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (0,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + for i in float_list: + for j in self.param_list: + tdSql.query(f"select stateduration(col{i},'{j}',5,1m) from test2") + tdSql.checkRows(10) + print(tdSql.queryResult) + if j in ['LT','lt','Lt','lT','LE','le','Le','lE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (1,), (2,), (3,), (4,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + elif j in ['GE','ge','Ge','gE','GT','gt','Gt','gT']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (-1,), (0,), (1,), (2,), (3,), (4,)]) + elif j in ['NE','ne','Ne','nE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (1,), (2,), (3,), (4,), (5,), (6,), (7,), (8,), (9,)]) + elif j in ['EQ','eq','Eq','eQ']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + + # timestamp = 1h, time_unit =1h + tdSql.execute('''create table test3(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double, + col7 bool, col8 binary(20), col9 nchar(20), col11 tinyint unsigned, col12 smallint unsigned, col13 int unsigned, col14 bigint unsigned)''') + for i in range(self.row_num): + tdSql.execute("insert into test3 values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)" + % (self.ts + i*1000*60*60, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1)) + + for i in integer_list: + for j in self.param_list: + tdSql.query(f"select stateduration(col{i},'{j}',5,1h) from test3") + tdSql.checkRows(10) + # print(tdSql.queryResult) + if j in ['LT' ,'lt','Lt','lT']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (1,), (2,), (3,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + elif j in ['GT','gt', 'Gt','gT']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (-1,), (0,), (1,), (2,), (3,), (4,)]) + elif j in ['LE','le','Le','lE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (1,), (2,), (3,), (4,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + elif j in [ 'GE','ge','Ge','gE']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (0,), (1,), (2,), (3,), (4,), (5,)]) + elif j in ['NE','ne','Ne','nE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (1,), (2,), (3,), (-1,), (0,), (1,), (2,), (3,), (4,)]) + elif j in ['EQ','eq','Eq','eQ']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (0,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + for i in float_list: + for j in self.param_list: + tdSql.query(f"select stateduration(col{i},'{j}',5,1h) from test3") + tdSql.checkRows(10) + print(tdSql.queryResult) + if j in ['LT','lt','Lt','lT','LE','le','Le','lE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (1,), (2,), (3,), (4,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + elif j in ['GE','ge','Ge','gE','GT','gt','Gt','gT']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (-1,), (0,), (1,), (2,), (3,), (4,)]) + elif j in ['NE','ne','Ne','nE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (1,), (2,), (3,), (4,), (5,), (6,), (7,), (8,), (9,)]) + elif j in ['EQ','eq','Eq','eQ']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + + # timestamp = 1h,time_unit =1m + for i in integer_list: + for j in self.param_list: + tdSql.query(f"select stateduration(col{i},'{j}',5,1m) from test3") + tdSql.checkRows(10) + # print(tdSql.queryResult) + if j in ['LT' ,'lt','Lt','lT']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (60,), (120,), (180,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + elif j in ['GT','gt', 'Gt','gT']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (-1,), (0,), (60,), (120,), (180,), (240,)]) + elif j in ['LE','le','Le','lE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (60,), (120,), (180,), (240,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + elif j in [ 'GE','ge','Ge','gE']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (0,), (60,), (120,), (180,), (240,), (300,)]) + elif j in ['NE','ne','Ne','nE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (60,), (120,), (180,), (-1,), (0,), (60,), (120,), (180,), (240,)]) + elif j in ['EQ','eq','Eq','eQ']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (0,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + for i in float_list: + for j in self.param_list: + tdSql.query(f"select stateduration(col{i},'{j}',5,1m) from test3") + tdSql.checkRows(10) + print(tdSql.queryResult) + if j in ['LT','lt','Lt','lT','LE','le','Le','lE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (60,), (120,), (180,), (240,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + elif j in ['GE','ge','Ge','gE','GT','gt','Gt','gT']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (-1,), (0,), (60,), (120,), (180,), (240,)]) + elif j in ['NE','ne','Ne','nE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (60,), (120,), (180,), (240,), (300,), (360,), (420,), (480,), (540,)]) + elif j in ['EQ','eq','Eq','eQ']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + + # for stb + tdSql.execute('''create table stb(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double, + col7 bool, col8 binary(20), col9 nchar(20), col11 tinyint unsigned, col12 smallint unsigned, col13 int unsigned, col14 bigint unsigned) tags(t0 int)''') + tdSql.execute('create table stb_1 using stb tags(1)') + for i in range(self.row_num): + tdSql.execute("insert into stb_1 values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)" + % (self.ts + i*1000*60*60, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1)) + + for i in integer_list: + for j in self.param_list: + tdSql.query(f"select stateduration(col{i},'{j}',5,1h) from stb") + tdSql.checkRows(10) + # print(tdSql.queryResult) + if j in ['LT' ,'lt','Lt','lT']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (1,), (2,), (3,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + elif j in ['GT','gt', 'Gt','gT']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (-1,), (0,), (1,), (2,), (3,), (4,)]) + elif j in ['LE','le','Le','lE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (1,), (2,), (3,), (4,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + elif j in [ 'GE','ge','Ge','gE']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (0,), (1,), (2,), (3,), (4,), (5,)]) + elif j in ['NE','ne','Ne','nE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (1,), (2,), (3,), (-1,), (0,), (1,), (2,), (3,), (4,)]) + elif j in ['EQ','eq','Eq','eQ']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (0,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + for i in float_list: + for j in self.param_list: + tdSql.query(f"select stateduration(col{i},'{j}',5,1h) from stb") + tdSql.checkRows(10) + print(tdSql.queryResult) + if j in ['LT','lt','Lt','lT','LE','le','Le','lE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (1,), (2,), (3,), (4,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + elif j in ['GE','ge','Ge','gE','GT','gt','Gt','gT']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (-1,), (0,), (1,), (2,), (3,), (4,)]) + elif j in ['NE','ne','Ne','nE']: + tdSql.checkEqual(tdSql.queryResult,[(0,), (1,), (2,), (3,), (4,), (5,), (6,), (7,), (8,), (9,)]) + elif j in ['EQ','eq','Eq','eQ']: + tdSql.checkEqual(tdSql.queryResult,[(-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,), (-1,)]) + + def stop(self): + tdSql.close() + tdLog.success("%s successfully executed" % __file__) + +tdCases.addWindows(__file__, TDTestCase()) +tdCases.addLinux(__file__, TDTestCase()) \ No newline at end of file From a714a64e2f7f5621c5a7be31458c7c6003c4a822 Mon Sep 17 00:00:00 2001 From: jiacy-jcy Date: Tue, 31 May 2022 15:02:12 +0800 Subject: [PATCH 05/28] update fulltest.sh --- tests/system-test/fulltest.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/system-test/fulltest.sh b/tests/system-test/fulltest.sh index 6331086fb3..5708a7adeb 100644 --- a/tests/system-test/fulltest.sh +++ b/tests/system-test/fulltest.sh @@ -55,8 +55,8 @@ python3 ./test.py -f 2-query/Timediff.py python3 ./test.py -f 2-query/top.py python3 ./test.py -f 2-query/bottom.py - - +python3 ./test.py -f 2-query/percentile.py +python3 ./test.py -f 2-query/apercentile.py python3 ./test.py -f 2-query/abs.py python3 ./test.py -f 2-query/ceil.py python3 ./test.py -f 2-query/floor.py From ce166fb146ef58e29396d8b14631a03c39697276 Mon Sep 17 00:00:00 2001 From: Xiaoyu Wang Date: Tue, 31 May 2022 15:07:15 +0800 Subject: [PATCH 06/28] fix: error in data precision of super table query --- include/common/ttokendef.h | 156 +-- source/libs/nodes/src/nodesCloneFuncs.c | 1 + source/libs/parser/inc/sql.y | 2 +- source/libs/parser/src/parTokenizer.c | 2 +- source/libs/parser/src/parTranslater.c | 42 +- source/libs/parser/src/sql.c | 1354 ++++++++++--------- source/libs/parser/test/parInitialDTest.cpp | 6 +- source/libs/parser/test/parSelectTest.cpp | 2 + source/libs/planner/src/planLogicCreater.c | 2 + 9 files changed, 795 insertions(+), 772 deletions(-) diff --git a/include/common/ttokendef.h b/include/common/ttokendef.h index 2fc524eeac..0e54f07991 100644 --- a/include/common/ttokendef.h +++ b/include/common/ttokendef.h @@ -162,84 +162,84 @@ #define TK_INTERVAL 144 #define TK_TOPIC 145 #define TK_AS 146 -#define TK_CGROUP 147 -#define TK_WITH 148 -#define TK_SCHEMA 149 -#define TK_DESC 150 -#define TK_DESCRIBE 151 -#define TK_RESET 152 -#define TK_QUERY 153 -#define TK_CACHE 154 -#define TK_EXPLAIN 155 -#define TK_ANALYZE 156 -#define TK_VERBOSE 157 -#define TK_NK_BOOL 158 -#define TK_RATIO 159 -#define TK_COMPACT 160 -#define TK_VNODES 161 -#define TK_IN 162 -#define TK_OUTPUTTYPE 163 -#define TK_AGGREGATE 164 -#define TK_BUFSIZE 165 -#define TK_STREAM 166 -#define TK_INTO 167 -#define TK_TRIGGER 168 -#define TK_AT_ONCE 169 -#define TK_WINDOW_CLOSE 170 -#define TK_WATERMARK 171 -#define TK_KILL 172 -#define TK_CONNECTION 173 -#define TK_TRANSACTION 174 -#define TK_MERGE 175 -#define TK_VGROUP 176 -#define TK_REDISTRIBUTE 177 -#define TK_SPLIT 178 -#define TK_SYNCDB 179 -#define TK_NULL 180 -#define TK_NK_QUESTION 181 -#define TK_NK_ARROW 182 -#define TK_ROWTS 183 -#define TK_TBNAME 184 -#define TK_QSTARTTS 185 -#define TK_QENDTS 186 -#define TK_WSTARTTS 187 -#define TK_WENDTS 188 -#define TK_WDURATION 189 -#define TK_CAST 190 -#define TK_NOW 191 -#define TK_TODAY 192 -#define TK_TIMEZONE 193 -#define TK_COUNT 194 -#define TK_FIRST 195 -#define TK_LAST 196 -#define TK_LAST_ROW 197 -#define TK_BETWEEN 198 -#define TK_IS 199 -#define TK_NK_LT 200 -#define TK_NK_GT 201 -#define TK_NK_LE 202 -#define TK_NK_GE 203 -#define TK_NK_NE 204 -#define TK_MATCH 205 -#define TK_NMATCH 206 -#define TK_CONTAINS 207 -#define TK_JOIN 208 -#define TK_INNER 209 -#define TK_SELECT 210 -#define TK_DISTINCT 211 -#define TK_WHERE 212 -#define TK_PARTITION 213 -#define TK_BY 214 -#define TK_SESSION 215 -#define TK_STATE_WINDOW 216 -#define TK_SLIDING 217 -#define TK_FILL 218 -#define TK_VALUE 219 -#define TK_NONE 220 -#define TK_PREV 221 -#define TK_LINEAR 222 -#define TK_NEXT 223 -#define TK_GROUP 224 +#define TK_CONSUMER 147 +#define TK_GROUP 148 +#define TK_WITH 149 +#define TK_SCHEMA 150 +#define TK_DESC 151 +#define TK_DESCRIBE 152 +#define TK_RESET 153 +#define TK_QUERY 154 +#define TK_CACHE 155 +#define TK_EXPLAIN 156 +#define TK_ANALYZE 157 +#define TK_VERBOSE 158 +#define TK_NK_BOOL 159 +#define TK_RATIO 160 +#define TK_COMPACT 161 +#define TK_VNODES 162 +#define TK_IN 163 +#define TK_OUTPUTTYPE 164 +#define TK_AGGREGATE 165 +#define TK_BUFSIZE 166 +#define TK_STREAM 167 +#define TK_INTO 168 +#define TK_TRIGGER 169 +#define TK_AT_ONCE 170 +#define TK_WINDOW_CLOSE 171 +#define TK_WATERMARK 172 +#define TK_KILL 173 +#define TK_CONNECTION 174 +#define TK_TRANSACTION 175 +#define TK_MERGE 176 +#define TK_VGROUP 177 +#define TK_REDISTRIBUTE 178 +#define TK_SPLIT 179 +#define TK_SYNCDB 180 +#define TK_NULL 181 +#define TK_NK_QUESTION 182 +#define TK_NK_ARROW 183 +#define TK_ROWTS 184 +#define TK_TBNAME 185 +#define TK_QSTARTTS 186 +#define TK_QENDTS 187 +#define TK_WSTARTTS 188 +#define TK_WENDTS 189 +#define TK_WDURATION 190 +#define TK_CAST 191 +#define TK_NOW 192 +#define TK_TODAY 193 +#define TK_TIMEZONE 194 +#define TK_COUNT 195 +#define TK_FIRST 196 +#define TK_LAST 197 +#define TK_LAST_ROW 198 +#define TK_BETWEEN 199 +#define TK_IS 200 +#define TK_NK_LT 201 +#define TK_NK_GT 202 +#define TK_NK_LE 203 +#define TK_NK_GE 204 +#define TK_NK_NE 205 +#define TK_MATCH 206 +#define TK_NMATCH 207 +#define TK_CONTAINS 208 +#define TK_JOIN 209 +#define TK_INNER 210 +#define TK_SELECT 211 +#define TK_DISTINCT 212 +#define TK_WHERE 213 +#define TK_PARTITION 214 +#define TK_BY 215 +#define TK_SESSION 216 +#define TK_STATE_WINDOW 217 +#define TK_SLIDING 218 +#define TK_FILL 219 +#define TK_VALUE 220 +#define TK_NONE 221 +#define TK_PREV 222 +#define TK_LINEAR 223 +#define TK_NEXT 224 #define TK_HAVING 225 #define TK_ORDER 226 #define TK_SLIMIT 227 diff --git a/source/libs/nodes/src/nodesCloneFuncs.c b/source/libs/nodes/src/nodesCloneFuncs.c index 68d3741b48..84b5e0a043 100644 --- a/source/libs/nodes/src/nodesCloneFuncs.c +++ b/source/libs/nodes/src/nodesCloneFuncs.c @@ -305,6 +305,7 @@ static SNode* logicNodeCopy(const SLogicNode* pSrc, SLogicNode* pDst) { CLONE_NODE_FIELD(pConditions); CLONE_NODE_LIST_FIELD(pChildren); COPY_SCALAR_FIELD(optimizedFlag); + COPY_SCALAR_FIELD(precision); return (SNode*)pDst; } diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y index 1fb60f83a5..f45f10f3b9 100644 --- a/source/libs/parser/inc/sql.y +++ b/source/libs/parser/inc/sql.y @@ -408,7 +408,7 @@ cmd ::= CREATE TOPIC not_exists_opt(A) cmd ::= CREATE TOPIC not_exists_opt(A) topic_name(B) topic_options(D) AS db_name(C). { pCxt->pRootNode = createCreateTopicStmt(pCxt, A, &B, NULL, &C, D); } cmd ::= DROP TOPIC exists_opt(A) topic_name(B). { pCxt->pRootNode = createDropTopicStmt(pCxt, A, &B); } -cmd ::= DROP CGROUP exists_opt(A) cgroup_name(B) ON topic_name(C). { pCxt->pRootNode = createDropCGroupStmt(pCxt, A, &B, &C); } +cmd ::= DROP CONSUMER GROUP exists_opt(A) cgroup_name(B) ON topic_name(C). { pCxt->pRootNode = createDropCGroupStmt(pCxt, A, &B, &C); } topic_options(A) ::= . { A = createTopicOptions(pCxt); } topic_options(A) ::= topic_options(B) WITH TABLE. { ((STopicOptions*)B)->withTable = true; A = B; } diff --git a/source/libs/parser/src/parTokenizer.c b/source/libs/parser/src/parTokenizer.c index 540de2d639..47edd3e5a8 100644 --- a/source/libs/parser/src/parTokenizer.c +++ b/source/libs/parser/src/parTokenizer.c @@ -53,7 +53,6 @@ static SKeyword keywordTable[] = { {"CACHE", TK_CACHE}, {"CACHELAST", TK_CACHELAST}, {"CAST", TK_CAST}, - {"CGROUP", TK_CGROUP}, {"CLUSTER", TK_CLUSTER}, {"COLUMN", TK_COLUMN}, {"COMMENT", TK_COMMENT}, @@ -62,6 +61,7 @@ static SKeyword keywordTable[] = { {"CONNS", TK_CONNS}, {"CONNECTION", TK_CONNECTION}, {"CONNECTIONS", TK_CONNECTIONS}, + {"CONSUMER", TK_CONSUMER}, {"COUNT", TK_COUNT}, {"CREATE", TK_CREATE}, {"DATABASE", TK_DATABASE}, diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index c6a7f95d5e..1fded1e4d5 100644 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -465,20 +465,22 @@ static bool isPrimaryKey(STempTableNode* pTable, SNode* pExpr) { return isPrimaryKeyImpl(pTable, pExpr); } -static bool findAndSetColumn(SColumnNode** pColRef, const STableNode* pTable) { +static int32_t findAndSetColumn(STranslateContext* pCxt, SColumnNode** pColRef, const STableNode* pTable, + bool* pFound) { SColumnNode* pCol = *pColRef; - bool found = false; + *pFound = false; if (QUERY_NODE_REAL_TABLE == nodeType(pTable)) { const STableMeta* pMeta = ((SRealTableNode*)pTable)->pMeta; if (isInternalPrimaryKey(pCol)) { setColumnInfoBySchema((SRealTableNode*)pTable, pMeta->schema, false, pCol); - return true; + *pFound = true; + return TSDB_CODE_SUCCESS; } int32_t nums = pMeta->tableInfo.numOfTags + pMeta->tableInfo.numOfColumns; for (int32_t i = 0; i < nums; ++i) { if (0 == strcmp(pCol->colName, pMeta->schema[i].name)) { setColumnInfoBySchema((SRealTableNode*)pTable, pMeta->schema + i, (i >= pMeta->tableInfo.numOfColumns), pCol); - found = true; + *pFound = true; break; } } @@ -489,13 +491,15 @@ static bool findAndSetColumn(SColumnNode** pColRef, const STableNode* pTable) { SExprNode* pExpr = (SExprNode*)pNode; if (0 == strcmp(pCol->colName, pExpr->aliasName) || (isPrimaryKey((STempTableNode*)pTable, pNode) && isInternalPrimaryKey(pCol))) { + if (*pFound) { + return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_AMBIGUOUS_COLUMN, pCol->colName); + } setColumnInfoByExpr(pTable, pExpr, pColRef); - found = true; - break; + *pFound = true; } } } - return found; + return TSDB_CODE_SUCCESS; } static EDealRes translateColumnWithPrefix(STranslateContext* pCxt, SColumnNode** pCol) { @@ -506,7 +510,12 @@ static EDealRes translateColumnWithPrefix(STranslateContext* pCxt, SColumnNode** STableNode* pTable = taosArrayGetP(pTables, i); if (belongTable(pCxt->pParseCxt->db, (*pCol), pTable)) { foundTable = true; - if (findAndSetColumn(pCol, pTable)) { + bool foundCol = false; + pCxt->errCode = findAndSetColumn(pCxt, pCol, pTable, &foundCol); + if (TSDB_CODE_SUCCESS != pCxt->errCode) { + return DEAL_RES_ERROR; + } + if (foundCol) { break; } return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_INVALID_COLUMN, (*pCol)->colName); @@ -525,14 +534,19 @@ static EDealRes translateColumnWithoutPrefix(STranslateContext* pCxt, SColumnNod bool isInternalPk = isInternalPrimaryKey(*pCol); for (size_t i = 0; i < nums; ++i) { STableNode* pTable = taosArrayGetP(pTables, i); - if (findAndSetColumn(pCol, pTable)) { + bool foundCol = false; + pCxt->errCode = findAndSetColumn(pCxt, pCol, pTable, &foundCol); + if (TSDB_CODE_SUCCESS != pCxt->errCode) { + return DEAL_RES_ERROR; + } + if (foundCol) { if (found) { return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_AMBIGUOUS_COLUMN, (*pCol)->colName); } found = true; - if (isInternalPk) { - break; - } + } + if (isInternalPk) { + break; } } if (!found) { @@ -1939,7 +1953,9 @@ static int32_t createPrimaryKeyColByTable(STranslateContext* pCxt, STableNode* p } pCol->colId = PRIMARYKEY_TIMESTAMP_COL_ID; strcpy(pCol->colName, PK_TS_COL_INTERNAL_NAME); - if (!findAndSetColumn(&pCol, pTable)) { + bool found = false; + int32_t code = findAndSetColumn(pCxt, &pCol, pTable, &found); + if (TSDB_CODE_SUCCESS != code || !found) { return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_TIMELINE_FUNC); } *pPrimaryKey = (SNode*)pCol; diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c index 262abac54b..6fb8faf391 100644 --- a/source/libs/parser/src/sql.c +++ b/source/libs/parser/src/sql.c @@ -134,17 +134,17 @@ typedef union { #define ParseCTX_FETCH #define ParseCTX_STORE #define YYFALLBACK 1 -#define YYNSTATE 611 +#define YYNSTATE 612 #define YYNRULE 455 #define YYNTOKEN 240 -#define YY_MAX_SHIFT 610 -#define YY_MIN_SHIFTREDUCE 901 -#define YY_MAX_SHIFTREDUCE 1355 -#define YY_ERROR_ACTION 1356 -#define YY_ACCEPT_ACTION 1357 -#define YY_NO_ACTION 1358 -#define YY_MIN_REDUCE 1359 -#define YY_MAX_REDUCE 1813 +#define YY_MAX_SHIFT 611 +#define YY_MIN_SHIFTREDUCE 902 +#define YY_MAX_SHIFTREDUCE 1356 +#define YY_ERROR_ACTION 1357 +#define YY_ACCEPT_ACTION 1358 +#define YY_NO_ACTION 1359 +#define YY_MIN_REDUCE 1360 +#define YY_MAX_REDUCE 1814 /************* End control #defines *******************************************/ #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) @@ -211,604 +211,606 @@ typedef union { ** yy_default[] Default action for each state. ** *********** Begin parsing tables **********************************************/ -#define YY_ACTTAB_COUNT (2153) +#define YY_ACTTAB_COUNT (2136) static const YYACTIONTYPE yy_action[] = { - /* 0 */ 386, 1647, 387, 1391, 295, 394, 524, 387, 1391, 28, - /* 10 */ 226, 931, 35, 33, 130, 1676, 1371, 1660, 104, 1791, - /* 20 */ 304, 1644, 1169, 477, 523, 424, 36, 34, 32, 31, - /* 30 */ 30, 385, 1790, 62, 389, 1490, 1788, 1640, 1646, 36, - /* 40 */ 34, 32, 31, 30, 1535, 1676, 108, 1167, 527, 935, - /* 50 */ 936, 294, 1000, 508, 524, 1485, 1533, 154, 14, 476, - /* 60 */ 35, 33, 1296, 507, 1175, 24, 350, 1630, 304, 1002, - /* 70 */ 1169, 1418, 277, 488, 523, 36, 34, 32, 31, 30, - /* 80 */ 56, 1, 60, 1490, 1689, 59, 524, 80, 1661, 510, - /* 90 */ 1663, 1664, 506, 1359, 527, 1167, 1207, 1729, 104, 603, - /* 100 */ 602, 276, 1725, 607, 1258, 429, 14, 36, 34, 32, - /* 110 */ 31, 30, 1175, 1791, 1168, 1490, 140, 103, 102, 101, - /* 120 */ 100, 99, 98, 97, 96, 95, 147, 376, 1529, 2, - /* 130 */ 1788, 583, 582, 581, 319, 39, 580, 579, 578, 114, - /* 140 */ 573, 572, 571, 570, 569, 568, 567, 566, 121, 562, - /* 150 */ 511, 607, 1568, 307, 1259, 55, 1580, 55, 1170, 156, - /* 160 */ 94, 1791, 1168, 93, 92, 91, 90, 89, 88, 87, - /* 170 */ 86, 85, 158, 157, 146, 352, 1264, 1352, 1788, 393, - /* 180 */ 1173, 1174, 389, 1220, 1221, 1223, 1224, 1225, 1226, 1227, - /* 190 */ 503, 525, 1235, 1236, 1237, 1238, 1239, 1240, 1468, 36, - /* 200 */ 34, 32, 31, 30, 64, 292, 1170, 131, 191, 274, - /* 210 */ 148, 1447, 27, 302, 1253, 1254, 1255, 1256, 1257, 1261, - /* 220 */ 1262, 1263, 1421, 36, 34, 32, 31, 30, 1173, 1174, - /* 230 */ 484, 1220, 1221, 1223, 1224, 1225, 1226, 1227, 503, 525, - /* 240 */ 1235, 1236, 1237, 1238, 1239, 1240, 35, 33, 1467, 948, - /* 250 */ 70, 947, 438, 437, 304, 403, 1169, 436, 1351, 112, - /* 260 */ 109, 433, 308, 1791, 432, 431, 430, 35, 33, 1310, - /* 270 */ 128, 1483, 1660, 403, 523, 304, 1789, 1169, 949, 1492, - /* 280 */ 1788, 1167, 438, 437, 148, 1193, 148, 436, 62, 972, - /* 290 */ 109, 433, 14, 1207, 432, 431, 430, 110, 1175, 1360, - /* 300 */ 1676, 1303, 1167, 1382, 1660, 524, 973, 1193, 508, 524, - /* 310 */ 1486, 486, 142, 1736, 1737, 2, 1741, 351, 507, 1175, - /* 320 */ 94, 361, 1630, 93, 92, 91, 90, 89, 88, 87, - /* 330 */ 86, 85, 1676, 1381, 1490, 38, 8, 607, 1490, 1689, - /* 340 */ 487, 559, 82, 1661, 510, 1663, 1664, 506, 1168, 527, - /* 350 */ 507, 1191, 1729, 1630, 1630, 1535, 1728, 1725, 607, 128, - /* 360 */ 558, 557, 309, 556, 555, 554, 1380, 1533, 1493, 1168, - /* 370 */ 565, 1689, 1462, 1535, 81, 1661, 510, 1663, 1664, 506, - /* 380 */ 315, 527, 524, 1630, 1729, 1533, 1743, 26, 297, 1725, - /* 390 */ 141, 478, 1170, 54, 362, 435, 434, 36, 34, 32, - /* 400 */ 31, 30, 218, 36, 34, 32, 31, 30, 466, 1756, - /* 410 */ 1740, 1490, 55, 1170, 1173, 1174, 1630, 1220, 1221, 1223, - /* 420 */ 1224, 1225, 1226, 1227, 503, 525, 1235, 1236, 1237, 1238, - /* 430 */ 1239, 1240, 460, 577, 575, 1173, 1174, 1379, 1220, 1221, - /* 440 */ 1223, 1224, 1225, 1226, 1227, 503, 525, 1235, 1236, 1237, - /* 450 */ 1238, 1239, 1240, 35, 33, 1241, 1378, 443, 1195, 610, - /* 460 */ 316, 304, 1377, 1169, 148, 148, 249, 1571, 1573, 1520, - /* 470 */ 1246, 1222, 451, 243, 35, 33, 1193, 1481, 1376, 1660, - /* 480 */ 1647, 461, 304, 312, 1169, 105, 190, 1630, 1167, 524, - /* 490 */ 473, 599, 595, 591, 587, 242, 391, 1644, 446, 1357, - /* 500 */ 1644, 402, 1191, 440, 561, 1175, 1630, 1676, 189, 1167, - /* 510 */ 337, 484, 1630, 1640, 1646, 508, 1640, 1646, 1490, 484, - /* 520 */ 78, 1791, 9, 237, 527, 507, 1175, 527, 1630, 1630, - /* 530 */ 339, 335, 564, 51, 145, 488, 50, 127, 1788, 511, - /* 540 */ 112, 148, 576, 9, 607, 1581, 1689, 1194, 112, 80, - /* 550 */ 1661, 510, 1663, 1664, 506, 1168, 527, 520, 320, 1729, - /* 560 */ 1375, 479, 474, 276, 1725, 607, 36, 34, 32, 31, - /* 570 */ 30, 1648, 1130, 314, 1479, 1791, 1168, 428, 110, 553, - /* 580 */ 1132, 128, 465, 340, 217, 198, 110, 1465, 145, 55, - /* 590 */ 1492, 1644, 1788, 143, 1736, 1737, 77, 1741, 1791, 1170, - /* 600 */ 427, 144, 1736, 1737, 1146, 1741, 193, 1640, 1646, 113, - /* 610 */ 1630, 145, 277, 1572, 1573, 1788, 490, 1482, 527, 1295, - /* 620 */ 1170, 1173, 1174, 1374, 1220, 1221, 1223, 1224, 1225, 1226, - /* 630 */ 1227, 503, 525, 1235, 1236, 1237, 1238, 1239, 1240, 286, - /* 640 */ 1222, 1131, 1173, 1174, 1258, 1220, 1221, 1223, 1224, 1225, - /* 650 */ 1226, 1227, 503, 525, 1235, 1236, 1237, 1238, 1239, 1240, - /* 660 */ 35, 33, 273, 559, 1191, 345, 1320, 344, 304, 524, - /* 670 */ 1169, 369, 524, 1630, 381, 32, 31, 30, 1748, 1291, - /* 680 */ 559, 1487, 558, 557, 1610, 556, 555, 554, 287, 7, - /* 690 */ 285, 284, 382, 426, 1259, 1167, 947, 428, 1490, 558, - /* 700 */ 557, 1490, 556, 555, 554, 470, 1318, 1319, 1321, 1322, - /* 710 */ 1535, 317, 1175, 11, 10, 1373, 1264, 1743, 148, 128, - /* 720 */ 427, 422, 1534, 935, 936, 1743, 1154, 1155, 1492, 2, - /* 730 */ 1038, 550, 549, 548, 1042, 547, 1044, 1045, 546, 1047, - /* 740 */ 543, 1739, 1053, 540, 1055, 1056, 537, 534, 346, 1738, - /* 750 */ 1370, 607, 27, 302, 1253, 1254, 1255, 1256, 1257, 1261, - /* 760 */ 1262, 1263, 1168, 380, 1466, 1630, 375, 374, 373, 372, - /* 770 */ 371, 368, 367, 366, 365, 364, 360, 359, 358, 357, - /* 780 */ 356, 355, 354, 353, 524, 524, 129, 524, 1791, 1196, - /* 790 */ 492, 255, 1192, 1193, 1272, 1260, 521, 522, 1475, 239, - /* 800 */ 1630, 145, 1369, 253, 53, 1788, 1170, 52, 1368, 1367, - /* 810 */ 1366, 452, 1365, 1490, 1490, 1364, 1490, 1265, 524, 1363, - /* 820 */ 1660, 561, 1362, 47, 159, 275, 1294, 1477, 1173, 1174, - /* 830 */ 318, 1220, 1221, 1223, 1224, 1225, 1226, 1227, 503, 525, - /* 840 */ 1235, 1236, 1237, 1238, 1239, 1240, 495, 1490, 1676, 55, - /* 850 */ 1473, 1791, 1630, 25, 1619, 194, 487, 1408, 1630, 1630, - /* 860 */ 1630, 1291, 1630, 1403, 145, 1630, 507, 1401, 1788, 1630, - /* 870 */ 1630, 182, 1630, 184, 180, 186, 183, 188, 185, 439, - /* 880 */ 187, 1660, 500, 450, 502, 441, 79, 1689, 76, 444, - /* 890 */ 81, 1661, 510, 1663, 1664, 506, 448, 527, 72, 327, - /* 900 */ 1729, 11, 10, 552, 297, 1725, 141, 1372, 459, 1676, - /* 910 */ 1354, 1355, 1650, 1448, 1660, 202, 1178, 508, 58, 57, - /* 920 */ 349, 118, 46, 153, 471, 1757, 1177, 507, 343, 205, - /* 930 */ 221, 1630, 37, 37, 37, 453, 212, 1677, 1392, 228, - /* 940 */ 272, 421, 1676, 333, 1530, 329, 325, 150, 1689, 1652, - /* 950 */ 508, 81, 1661, 510, 1663, 1664, 506, 1222, 527, 1759, - /* 960 */ 507, 1729, 462, 1317, 1630, 297, 1725, 1804, 1191, 116, - /* 970 */ 207, 117, 485, 1266, 1228, 1124, 1763, 493, 148, 1660, - /* 980 */ 230, 1689, 220, 1181, 81, 1661, 510, 1663, 1664, 506, - /* 990 */ 223, 527, 118, 1180, 1729, 1660, 46, 532, 297, 1725, - /* 1000 */ 1804, 322, 117, 225, 1250, 3, 118, 1676, 326, 1786, - /* 1010 */ 516, 282, 236, 1000, 283, 508, 119, 117, 244, 155, - /* 1020 */ 1138, 363, 370, 1676, 1570, 507, 378, 1660, 377, 1630, - /* 1030 */ 379, 508, 383, 1031, 1197, 496, 384, 248, 1059, 392, - /* 1040 */ 1200, 507, 395, 1063, 162, 1630, 1689, 1070, 396, 82, - /* 1050 */ 1661, 510, 1663, 1664, 506, 1676, 527, 1068, 120, 1729, - /* 1060 */ 1199, 164, 1689, 508, 1726, 81, 1661, 510, 1663, 1664, - /* 1070 */ 506, 1201, 527, 507, 397, 1729, 398, 1630, 1660, 297, - /* 1080 */ 1725, 1804, 167, 488, 399, 169, 1198, 400, 401, 172, - /* 1090 */ 1747, 61, 404, 1660, 1689, 175, 423, 262, 1661, 510, - /* 1100 */ 1663, 1664, 506, 425, 527, 84, 1676, 1175, 1480, 179, - /* 1110 */ 1476, 291, 181, 1614, 508, 122, 123, 1478, 1474, 124, - /* 1120 */ 125, 1676, 245, 1791, 507, 192, 455, 195, 1630, 508, - /* 1130 */ 246, 197, 454, 464, 488, 463, 147, 200, 1196, 507, - /* 1140 */ 1788, 458, 472, 1630, 1660, 1689, 1770, 203, 262, 1661, - /* 1150 */ 510, 1663, 1664, 506, 514, 527, 6, 1750, 469, 1769, - /* 1160 */ 1689, 211, 481, 82, 1661, 510, 1663, 1664, 506, 206, - /* 1170 */ 527, 1760, 1676, 1729, 1791, 296, 475, 499, 1725, 1195, - /* 1180 */ 505, 468, 5, 1291, 111, 40, 497, 145, 1744, 1807, - /* 1190 */ 507, 1788, 298, 18, 1630, 512, 1660, 513, 494, 306, - /* 1200 */ 311, 310, 1579, 135, 1578, 1660, 214, 517, 518, 519, - /* 1210 */ 1183, 1689, 213, 1787, 270, 1661, 510, 1663, 1664, 506, - /* 1220 */ 504, 527, 501, 1701, 1676, 219, 232, 71, 491, 1710, - /* 1230 */ 234, 247, 508, 1676, 69, 1176, 250, 1491, 241, 222, - /* 1240 */ 606, 508, 507, 1463, 498, 48, 1630, 530, 224, 256, - /* 1250 */ 134, 507, 1175, 1660, 263, 1630, 257, 293, 467, 252, - /* 1260 */ 254, 1624, 1623, 1689, 321, 1620, 132, 1661, 510, 1663, - /* 1270 */ 1664, 506, 1689, 527, 323, 271, 1661, 510, 1663, 1664, - /* 1280 */ 506, 1676, 527, 324, 1163, 1660, 1164, 151, 1618, 508, - /* 1290 */ 328, 528, 330, 331, 1617, 332, 334, 1616, 336, 507, - /* 1300 */ 1615, 338, 1179, 1630, 1600, 152, 341, 1141, 342, 1140, - /* 1310 */ 489, 1805, 1594, 1676, 1593, 347, 348, 1660, 1592, 1591, - /* 1320 */ 1689, 508, 1107, 266, 1661, 510, 1663, 1664, 506, 1563, - /* 1330 */ 527, 507, 1562, 1561, 1560, 1630, 1559, 1558, 1557, 1556, - /* 1340 */ 1555, 1554, 1553, 1552, 1551, 1676, 1184, 1550, 1549, 1548, - /* 1350 */ 1547, 1546, 1689, 508, 1545, 132, 1661, 510, 1663, 1664, - /* 1360 */ 506, 480, 527, 507, 115, 1660, 1544, 1630, 1187, 1543, - /* 1370 */ 301, 1542, 1541, 1540, 1109, 1539, 1538, 1537, 1660, 525, - /* 1380 */ 1235, 1236, 1536, 1420, 1689, 1388, 160, 271, 1661, 510, - /* 1390 */ 1663, 1664, 506, 1676, 527, 938, 106, 138, 937, 388, - /* 1400 */ 1806, 505, 1387, 161, 390, 107, 1676, 1608, 1602, 1586, - /* 1410 */ 1585, 507, 1576, 1469, 508, 1630, 166, 171, 1660, 1419, - /* 1420 */ 966, 1417, 1415, 407, 507, 405, 1413, 411, 1630, 415, - /* 1430 */ 1411, 303, 1689, 419, 406, 270, 1661, 510, 1663, 1664, - /* 1440 */ 506, 409, 527, 410, 1702, 1689, 1676, 413, 271, 1661, - /* 1450 */ 510, 1663, 1664, 506, 508, 527, 414, 1400, 177, 1399, - /* 1460 */ 418, 417, 1386, 1471, 507, 1074, 1660, 1470, 1630, 1073, - /* 1470 */ 139, 305, 574, 576, 999, 1169, 420, 416, 412, 408, - /* 1480 */ 176, 45, 998, 178, 997, 1689, 996, 993, 271, 1661, - /* 1490 */ 510, 1663, 1664, 506, 1676, 527, 992, 991, 1409, 288, - /* 1500 */ 1167, 1404, 508, 289, 442, 63, 1402, 290, 174, 1385, - /* 1510 */ 447, 445, 507, 1384, 449, 83, 1630, 1175, 1607, 1148, - /* 1520 */ 49, 1601, 456, 1660, 1584, 126, 1583, 1575, 199, 65, - /* 1530 */ 196, 4, 133, 1689, 201, 37, 258, 1661, 510, 1663, - /* 1540 */ 1664, 506, 204, 527, 15, 457, 43, 1316, 1309, 208, - /* 1550 */ 22, 1676, 209, 23, 210, 66, 607, 1288, 1650, 508, - /* 1560 */ 1287, 216, 1345, 42, 136, 41, 173, 1168, 165, 507, - /* 1570 */ 170, 1660, 168, 1630, 17, 1340, 1339, 16, 13, 1334, - /* 1580 */ 10, 299, 1344, 1343, 300, 1251, 19, 137, 149, 1230, - /* 1590 */ 1689, 163, 1215, 265, 1661, 510, 1663, 1664, 506, 1676, - /* 1600 */ 527, 1660, 509, 1574, 29, 515, 12, 508, 1649, 233, - /* 1610 */ 72, 1170, 1229, 20, 235, 1185, 531, 507, 238, 21, - /* 1620 */ 229, 1630, 227, 529, 1314, 964, 313, 231, 67, 1676, - /* 1630 */ 68, 1660, 1692, 1173, 1174, 1232, 526, 508, 1689, 44, - /* 1640 */ 533, 267, 1661, 510, 1663, 1664, 506, 507, 527, 1060, - /* 1650 */ 1057, 1630, 535, 538, 536, 541, 544, 1054, 539, 1676, - /* 1660 */ 1037, 1052, 1048, 542, 1069, 1046, 545, 508, 1689, 551, - /* 1670 */ 1051, 259, 1661, 510, 1663, 1664, 506, 507, 527, 1660, - /* 1680 */ 73, 1630, 74, 75, 1066, 1065, 1050, 560, 1660, 1049, - /* 1690 */ 988, 1006, 563, 240, 986, 985, 984, 983, 1689, 981, - /* 1700 */ 1067, 268, 1661, 510, 1663, 1664, 506, 1676, 527, 982, - /* 1710 */ 1003, 980, 979, 1001, 976, 508, 1676, 975, 974, 971, - /* 1720 */ 970, 969, 1416, 584, 508, 507, 585, 586, 1414, 1630, - /* 1730 */ 588, 589, 590, 1412, 507, 592, 1660, 593, 1630, 594, - /* 1740 */ 1410, 596, 597, 598, 1398, 600, 1689, 601, 1397, 260, - /* 1750 */ 1661, 510, 1663, 1664, 506, 1689, 527, 1383, 269, 1661, - /* 1760 */ 510, 1663, 1664, 506, 1676, 527, 609, 604, 605, 1358, - /* 1770 */ 1358, 1171, 508, 251, 608, 1358, 1358, 1358, 1358, 1358, - /* 1780 */ 1358, 1358, 507, 1358, 1660, 1358, 1630, 1358, 1358, 1358, - /* 1790 */ 1358, 1358, 1358, 1358, 1358, 1660, 1358, 1358, 1358, 1358, - /* 1800 */ 1358, 1358, 1358, 1689, 1358, 1358, 261, 1661, 510, 1663, - /* 1810 */ 1664, 506, 1676, 527, 1660, 1358, 1358, 1358, 1358, 1358, - /* 1820 */ 508, 1358, 1358, 1676, 1358, 1358, 1358, 1358, 1358, 1358, - /* 1830 */ 507, 508, 1358, 1358, 1630, 1358, 1358, 1358, 1358, 1358, - /* 1840 */ 1358, 507, 1676, 1358, 1358, 1630, 1358, 1358, 1358, 1358, - /* 1850 */ 508, 1689, 1358, 1358, 1672, 1661, 510, 1663, 1664, 506, - /* 1860 */ 507, 527, 1689, 1358, 1630, 1671, 1661, 510, 1663, 1664, - /* 1870 */ 506, 1358, 527, 1660, 1358, 1358, 1358, 1358, 1358, 1358, - /* 1880 */ 1358, 1689, 1660, 1358, 1670, 1661, 510, 1663, 1664, 506, - /* 1890 */ 1358, 527, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, - /* 1900 */ 1358, 1676, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 508, - /* 1910 */ 1676, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 508, 507, - /* 1920 */ 1358, 1358, 1358, 1630, 1358, 1358, 1358, 1358, 507, 1358, - /* 1930 */ 1358, 1358, 1630, 1358, 1358, 1358, 1358, 1358, 1358, 1358, - /* 1940 */ 1689, 1358, 1660, 280, 1661, 510, 1663, 1664, 506, 1689, - /* 1950 */ 527, 1660, 279, 1661, 510, 1663, 1664, 506, 1358, 527, - /* 1960 */ 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, - /* 1970 */ 1676, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 508, 1676, - /* 1980 */ 1358, 1358, 1358, 1358, 1358, 1358, 1358, 508, 507, 1358, - /* 1990 */ 1358, 1358, 1630, 1358, 1358, 1358, 1358, 507, 1358, 1660, - /* 2000 */ 1358, 1630, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1689, - /* 2010 */ 484, 1358, 281, 1661, 510, 1663, 1664, 506, 1689, 527, - /* 2020 */ 1358, 278, 1661, 510, 1663, 1664, 506, 1676, 527, 1358, - /* 2030 */ 1358, 1358, 1358, 1358, 1358, 508, 1358, 1358, 1358, 112, - /* 2040 */ 1358, 1358, 1358, 1358, 1358, 507, 484, 1358, 1358, 1630, - /* 2050 */ 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 488, - /* 2060 */ 1358, 1358, 1358, 1358, 1358, 1358, 1689, 1358, 1358, 264, - /* 2070 */ 1661, 510, 1663, 1664, 506, 112, 527, 110, 1358, 1358, - /* 2080 */ 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, - /* 2090 */ 1358, 1358, 215, 1736, 483, 488, 482, 1358, 1358, 1791, - /* 2100 */ 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, - /* 2110 */ 1358, 1358, 147, 110, 1358, 1358, 1788, 1358, 1358, 1358, - /* 2120 */ 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 215, 1736, - /* 2130 */ 483, 1358, 482, 1358, 1358, 1791, 1358, 1358, 1358, 1358, - /* 2140 */ 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 145, 1358, - /* 2150 */ 1358, 1358, 1788, + /* 0 */ 460, 1648, 1536, 1648, 295, 386, 312, 387, 1392, 294, + /* 10 */ 28, 226, 35, 33, 1534, 24, 1383, 1661, 932, 1480, + /* 20 */ 304, 1645, 1170, 1645, 140, 36, 34, 32, 31, 30, + /* 30 */ 36, 34, 32, 31, 30, 1482, 1530, 1641, 1647, 1641, + /* 40 */ 1647, 394, 1469, 387, 1392, 1677, 524, 1168, 528, 130, + /* 50 */ 528, 1372, 1792, 509, 485, 1645, 936, 937, 14, 524, + /* 60 */ 35, 33, 1297, 508, 1176, 1791, 1631, 1631, 304, 1789, + /* 70 */ 1170, 1641, 1647, 489, 36, 34, 32, 31, 30, 604, + /* 80 */ 603, 1, 528, 112, 1690, 1131, 525, 80, 1662, 511, + /* 90 */ 1664, 1665, 507, 1133, 528, 1168, 1661, 1730, 104, 404, + /* 100 */ 1311, 276, 1726, 608, 1744, 425, 14, 39, 35, 33, + /* 110 */ 1792, 1649, 1176, 1792, 1169, 1491, 304, 1744, 1170, 512, + /* 120 */ 277, 110, 307, 146, 1677, 1581, 147, 1789, 1741, 2, + /* 130 */ 1789, 1645, 506, 1304, 376, 487, 142, 1737, 1738, 1194, + /* 140 */ 1742, 1740, 508, 1168, 1208, 55, 1631, 1641, 1647, 525, + /* 150 */ 56, 608, 1259, 131, 14, 1132, 1677, 1448, 528, 1171, + /* 160 */ 1176, 350, 1169, 1690, 478, 404, 270, 1662, 511, 1664, + /* 170 */ 1665, 507, 505, 528, 502, 1702, 1382, 2, 1491, 158, + /* 180 */ 157, 1174, 1175, 1194, 1221, 1222, 1224, 1225, 1226, 1227, + /* 190 */ 1228, 504, 526, 1236, 1237, 1238, 1239, 1240, 1241, 608, + /* 200 */ 477, 62, 1260, 154, 64, 292, 1296, 1171, 191, 94, + /* 210 */ 1169, 148, 93, 92, 91, 90, 89, 88, 87, 86, + /* 220 */ 85, 1381, 345, 1487, 344, 1265, 1631, 55, 60, 1174, + /* 230 */ 1175, 59, 1221, 1222, 1224, 1225, 1226, 1227, 1228, 504, + /* 240 */ 526, 1236, 1237, 1238, 1239, 1240, 1241, 1419, 286, 479, + /* 250 */ 36, 34, 32, 31, 30, 1171, 36, 34, 32, 31, + /* 260 */ 30, 27, 302, 1254, 1255, 1256, 1257, 1258, 1262, 1263, + /* 270 */ 1264, 1631, 55, 1358, 1744, 148, 385, 1174, 1175, 389, + /* 280 */ 1221, 1222, 1224, 1225, 1226, 1227, 1228, 504, 526, 1236, + /* 290 */ 1237, 1238, 1239, 1240, 1241, 35, 33, 287, 1739, 285, + /* 300 */ 284, 524, 427, 304, 1223, 1170, 429, 584, 583, 582, + /* 310 */ 319, 1467, 581, 580, 579, 114, 574, 573, 572, 571, + /* 320 */ 570, 569, 568, 567, 121, 563, 439, 438, 62, 428, + /* 330 */ 1168, 437, 320, 1661, 109, 434, 560, 346, 433, 432, + /* 340 */ 431, 108, 525, 35, 33, 1242, 391, 1176, 1192, 948, + /* 350 */ 1486, 304, 1192, 1170, 351, 559, 558, 148, 557, 556, + /* 360 */ 555, 1677, 38, 1792, 8, 308, 1380, 474, 562, 488, + /* 370 */ 1261, 1491, 1792, 128, 423, 453, 1790, 1792, 1168, 508, + /* 380 */ 1789, 1321, 1493, 1631, 127, 145, 608, 436, 435, 1789, + /* 390 */ 145, 35, 33, 1266, 1789, 1176, 949, 1169, 948, 304, + /* 400 */ 1690, 1170, 148, 81, 1662, 511, 1664, 1665, 507, 55, + /* 410 */ 528, 1379, 9, 1730, 1295, 1792, 1631, 297, 1726, 141, + /* 420 */ 471, 1319, 1320, 1322, 1323, 950, 1168, 1361, 145, 25, + /* 430 */ 512, 218, 1789, 314, 608, 1422, 1582, 467, 1757, 480, + /* 440 */ 475, 128, 1171, 1176, 1409, 1169, 393, 1378, 94, 389, + /* 450 */ 1493, 93, 92, 91, 90, 89, 88, 87, 86, 85, + /* 460 */ 9, 1631, 578, 576, 1174, 1175, 440, 1221, 1222, 1224, + /* 470 */ 1225, 1226, 1227, 1228, 504, 526, 1236, 1237, 1238, 1239, + /* 480 */ 1240, 1241, 608, 36, 34, 32, 31, 30, 1468, 70, + /* 490 */ 1171, 1569, 148, 1169, 148, 439, 438, 1631, 156, 1536, + /* 500 */ 437, 7, 525, 109, 434, 1195, 309, 433, 432, 431, + /* 510 */ 1484, 1534, 1174, 1175, 361, 1221, 1222, 1224, 1225, 1226, + /* 520 */ 1227, 1228, 504, 526, 1236, 1237, 1238, 1239, 1240, 1241, + /* 530 */ 493, 1491, 36, 34, 32, 31, 30, 1196, 1171, 148, + /* 540 */ 1039, 551, 550, 549, 1043, 548, 1045, 1046, 547, 1048, + /* 550 */ 544, 316, 1054, 541, 1056, 1057, 538, 535, 1572, 1574, + /* 560 */ 1174, 1175, 1377, 1221, 1222, 1224, 1225, 1226, 1227, 1228, + /* 570 */ 504, 526, 1236, 1237, 1238, 1239, 1240, 1241, 35, 33, + /* 580 */ 273, 560, 1192, 26, 11, 10, 304, 1661, 1170, 369, + /* 590 */ 54, 1001, 381, 36, 34, 32, 31, 30, 1573, 1574, + /* 600 */ 559, 558, 1208, 557, 556, 555, 177, 525, 1003, 1536, + /* 610 */ 382, 1247, 1631, 1168, 1360, 1677, 315, 1194, 139, 362, + /* 620 */ 525, 1534, 1353, 509, 421, 417, 413, 409, 176, 1376, + /* 630 */ 1176, 337, 403, 508, 936, 937, 1491, 1631, 103, 102, + /* 640 */ 101, 100, 99, 98, 97, 96, 95, 2, 485, 1491, + /* 650 */ 1193, 339, 335, 63, 1690, 77, 174, 81, 1662, 511, + /* 660 */ 1664, 1665, 507, 217, 528, 1273, 128, 1730, 113, 608, + /* 670 */ 352, 297, 1726, 1805, 1292, 1494, 1483, 112, 461, 1631, + /* 680 */ 1169, 380, 1764, 1375, 375, 374, 373, 372, 371, 368, + /* 690 */ 367, 366, 365, 364, 360, 359, 358, 357, 356, 355, + /* 700 */ 354, 353, 1352, 249, 274, 129, 1521, 525, 554, 525, + /* 710 */ 255, 32, 31, 30, 173, 110, 165, 494, 170, 1488, + /* 720 */ 399, 104, 253, 53, 562, 1171, 52, 462, 430, 565, + /* 730 */ 143, 1737, 1738, 1631, 1742, 1197, 1491, 1661, 1491, 182, + /* 740 */ 163, 1466, 180, 159, 1374, 496, 1371, 1174, 1175, 1194, + /* 750 */ 1221, 1222, 1224, 1225, 1226, 1227, 1228, 504, 526, 1236, + /* 760 */ 1237, 1238, 1239, 1240, 1241, 1677, 1370, 1792, 55, 525, + /* 770 */ 566, 317, 1463, 509, 36, 34, 32, 31, 30, 128, + /* 780 */ 145, 1611, 1223, 508, 1789, 1749, 1292, 1631, 1493, 525, + /* 790 */ 525, 1369, 1620, 489, 1631, 485, 1631, 1368, 1491, 1476, + /* 800 */ 429, 522, 523, 525, 1690, 79, 485, 80, 1662, 511, + /* 810 */ 1664, 1665, 507, 491, 528, 239, 1631, 1730, 1491, 1491, + /* 820 */ 277, 276, 1726, 428, 112, 1367, 1155, 1156, 184, 1404, + /* 830 */ 525, 183, 1491, 1792, 560, 112, 1661, 327, 58, 57, + /* 840 */ 349, 1631, 318, 153, 489, 1170, 145, 1631, 343, 1366, + /* 850 */ 1789, 442, 1259, 559, 558, 1365, 557, 556, 555, 1491, + /* 860 */ 272, 202, 110, 333, 1677, 329, 325, 150, 1364, 1363, + /* 870 */ 1168, 501, 488, 110, 577, 1631, 1478, 215, 1737, 484, + /* 880 */ 186, 483, 508, 185, 1792, 76, 1631, 1176, 144, 1737, + /* 890 */ 1738, 47, 1742, 188, 275, 72, 187, 147, 148, 1631, + /* 900 */ 1536, 1789, 1260, 1690, 1661, 1631, 81, 1662, 511, 1664, + /* 910 */ 1665, 507, 1535, 528, 1223, 340, 1730, 1402, 1631, 1631, + /* 920 */ 297, 1726, 141, 451, 485, 1265, 608, 11, 10, 1355, + /* 930 */ 1356, 118, 1677, 1373, 497, 1179, 449, 1169, 1474, 445, + /* 940 */ 509, 1758, 46, 1651, 205, 1178, 1449, 194, 503, 553, + /* 950 */ 508, 37, 37, 112, 1631, 37, 228, 116, 221, 117, + /* 960 */ 118, 27, 302, 1254, 1255, 1256, 1257, 1258, 1262, 1263, + /* 970 */ 1264, 1690, 463, 489, 81, 1662, 511, 1664, 1665, 507, + /* 980 */ 1653, 528, 1171, 1318, 1730, 207, 46, 1661, 297, 1726, + /* 990 */ 1805, 110, 1267, 1229, 1251, 533, 1125, 230, 517, 1787, + /* 1000 */ 236, 1032, 1182, 117, 1174, 1175, 215, 1737, 484, 118, + /* 1010 */ 483, 119, 1181, 1792, 973, 1677, 454, 212, 472, 1661, + /* 1020 */ 1678, 1393, 117, 509, 422, 1760, 145, 248, 1531, 486, + /* 1030 */ 1789, 974, 220, 508, 223, 225, 1060, 1631, 3, 1192, + /* 1040 */ 322, 326, 282, 283, 1064, 1001, 1139, 1677, 244, 1661, + /* 1050 */ 1071, 363, 1069, 1571, 1690, 509, 155, 81, 1662, 511, + /* 1060 */ 1664, 1665, 507, 120, 528, 508, 370, 1730, 378, 1631, + /* 1070 */ 377, 297, 1726, 1805, 379, 489, 383, 1677, 1198, 384, + /* 1080 */ 392, 1201, 1748, 395, 1200, 509, 1690, 162, 396, 262, + /* 1090 */ 1662, 511, 1664, 1665, 507, 508, 528, 164, 1202, 1631, + /* 1100 */ 398, 167, 397, 169, 400, 489, 401, 1661, 1199, 402, + /* 1110 */ 444, 172, 61, 405, 175, 1792, 1690, 424, 426, 262, + /* 1120 */ 1662, 511, 1664, 1665, 507, 452, 528, 84, 147, 1481, + /* 1130 */ 291, 179, 1789, 1477, 1176, 1677, 181, 122, 123, 190, + /* 1140 */ 1479, 1475, 124, 509, 125, 1792, 1615, 1661, 245, 192, + /* 1150 */ 455, 447, 246, 508, 456, 464, 441, 1631, 145, 195, + /* 1160 */ 197, 189, 1789, 459, 1197, 465, 1661, 473, 515, 1771, + /* 1170 */ 1770, 6, 470, 200, 1690, 1677, 203, 82, 1662, 511, + /* 1180 */ 1664, 1665, 507, 509, 528, 206, 51, 1730, 296, 50, + /* 1190 */ 1761, 1729, 1726, 508, 1677, 1751, 482, 1631, 1661, 211, + /* 1200 */ 469, 476, 509, 5, 135, 1292, 111, 1196, 1745, 40, + /* 1210 */ 213, 214, 508, 18, 1690, 495, 1631, 82, 1662, 511, + /* 1220 */ 1664, 1665, 507, 498, 528, 298, 1677, 1730, 1580, 513, + /* 1230 */ 514, 500, 1726, 1690, 509, 1788, 132, 1662, 511, 1664, + /* 1240 */ 1665, 507, 306, 528, 508, 1579, 219, 1808, 1631, 492, + /* 1250 */ 1711, 518, 519, 611, 222, 232, 520, 234, 247, 69, + /* 1260 */ 499, 1492, 71, 1661, 531, 1690, 224, 243, 82, 1662, + /* 1270 */ 511, 1664, 1665, 507, 1464, 528, 250, 241, 1730, 105, + /* 1280 */ 490, 1806, 607, 1727, 134, 600, 596, 592, 588, 242, + /* 1290 */ 256, 1677, 263, 257, 48, 293, 252, 254, 1625, 509, + /* 1300 */ 1624, 321, 1621, 323, 324, 1164, 1165, 151, 328, 508, + /* 1310 */ 1619, 1661, 330, 1631, 78, 331, 468, 237, 332, 1618, + /* 1320 */ 334, 1617, 336, 1616, 338, 1601, 152, 341, 342, 1142, + /* 1330 */ 1690, 1141, 1595, 271, 1662, 511, 1664, 1665, 507, 1677, + /* 1340 */ 528, 1594, 1593, 347, 348, 1592, 1564, 509, 1108, 1563, + /* 1350 */ 1562, 521, 1561, 1560, 1559, 1558, 1557, 508, 1556, 1661, + /* 1360 */ 1555, 1631, 1554, 1553, 1552, 1551, 1550, 1549, 1661, 1548, + /* 1370 */ 1547, 115, 1546, 1545, 1544, 1543, 466, 1542, 1690, 198, + /* 1380 */ 1541, 266, 1662, 511, 1664, 1665, 507, 1677, 528, 1540, + /* 1390 */ 1110, 1539, 1538, 1537, 1421, 509, 1677, 160, 106, 1147, + /* 1400 */ 1389, 193, 939, 388, 509, 508, 1388, 1609, 1603, 1631, + /* 1410 */ 938, 1587, 138, 1586, 508, 168, 161, 1577, 1631, 481, + /* 1420 */ 390, 301, 1661, 107, 166, 1470, 1690, 171, 1420, 132, + /* 1430 */ 1662, 511, 1664, 1665, 507, 1690, 528, 1661, 271, 1662, + /* 1440 */ 511, 1664, 1665, 507, 967, 528, 1418, 407, 406, 408, + /* 1450 */ 1677, 1416, 410, 412, 411, 1414, 416, 414, 506, 415, + /* 1460 */ 1412, 420, 418, 419, 1401, 1677, 1400, 1387, 508, 1472, + /* 1470 */ 1661, 45, 1631, 509, 1807, 1074, 1075, 1471, 1000, 999, + /* 1480 */ 998, 997, 575, 508, 577, 1661, 178, 1631, 1410, 1690, + /* 1490 */ 303, 994, 270, 1662, 511, 1664, 1665, 507, 1677, 528, + /* 1500 */ 288, 1703, 1405, 993, 1690, 992, 509, 271, 1662, 511, + /* 1510 */ 1664, 1665, 507, 1677, 528, 1403, 508, 289, 443, 290, + /* 1520 */ 1631, 509, 446, 305, 1386, 1661, 448, 1385, 450, 83, + /* 1530 */ 1608, 508, 1149, 1602, 457, 1631, 1585, 1690, 196, 1584, + /* 1540 */ 271, 1662, 511, 1664, 1665, 507, 1576, 528, 126, 49, + /* 1550 */ 458, 199, 1690, 1677, 65, 258, 1662, 511, 1664, 1665, + /* 1560 */ 507, 509, 528, 201, 4, 204, 37, 43, 1317, 1310, + /* 1570 */ 133, 508, 208, 22, 10, 1631, 209, 1661, 210, 66, + /* 1580 */ 29, 1651, 1289, 23, 216, 1288, 42, 136, 17, 1346, + /* 1590 */ 1335, 1341, 1690, 19, 15, 265, 1662, 511, 1664, 1665, + /* 1600 */ 507, 1340, 528, 299, 1345, 1677, 1344, 300, 1252, 137, + /* 1610 */ 1231, 1230, 12, 509, 16, 149, 1216, 1575, 510, 20, + /* 1620 */ 516, 233, 235, 508, 1650, 1661, 238, 1631, 965, 41, + /* 1630 */ 21, 1186, 227, 1315, 532, 313, 13, 536, 539, 229, + /* 1640 */ 1661, 1038, 231, 67, 1690, 68, 72, 267, 1662, 511, + /* 1650 */ 1664, 1665, 507, 1677, 528, 1693, 552, 1233, 527, 44, + /* 1660 */ 530, 509, 542, 1061, 534, 545, 1066, 1058, 1677, 1070, + /* 1670 */ 537, 508, 1053, 1661, 1055, 1631, 509, 540, 1052, 1049, + /* 1680 */ 543, 1051, 1047, 546, 1050, 73, 508, 1067, 74, 75, + /* 1690 */ 1631, 561, 1690, 989, 1007, 259, 1662, 511, 1664, 1665, + /* 1700 */ 507, 1677, 528, 564, 240, 987, 986, 1690, 985, 509, + /* 1710 */ 268, 1662, 511, 1664, 1665, 507, 982, 528, 984, 508, + /* 1720 */ 983, 981, 980, 1631, 1068, 1002, 1004, 1661, 977, 976, + /* 1730 */ 975, 972, 971, 970, 1417, 585, 1661, 586, 587, 1415, + /* 1740 */ 1690, 590, 589, 260, 1662, 511, 1664, 1665, 507, 591, + /* 1750 */ 528, 1413, 593, 594, 595, 1677, 597, 599, 598, 1399, + /* 1760 */ 1398, 601, 602, 509, 1677, 1411, 1384, 605, 606, 1359, + /* 1770 */ 1172, 251, 509, 508, 609, 610, 1359, 1631, 1359, 1359, + /* 1780 */ 1359, 1359, 508, 1359, 1661, 1359, 1631, 1359, 1359, 1359, + /* 1790 */ 1359, 1359, 1359, 1359, 1690, 1359, 1661, 269, 1662, 511, + /* 1800 */ 1664, 1665, 507, 1690, 528, 1359, 261, 1662, 511, 1664, + /* 1810 */ 1665, 507, 1677, 528, 1359, 1359, 1359, 1359, 1359, 1359, + /* 1820 */ 509, 1359, 1359, 1359, 1677, 1359, 1359, 1359, 1359, 1359, + /* 1830 */ 508, 1359, 509, 1359, 1631, 1359, 1661, 1359, 1359, 1359, + /* 1840 */ 1359, 1359, 508, 1359, 1359, 1359, 1631, 1359, 1359, 1661, + /* 1850 */ 1359, 1690, 1359, 1359, 1673, 1662, 511, 1664, 1665, 507, + /* 1860 */ 1359, 528, 1359, 1690, 1677, 1359, 1672, 1662, 511, 1664, + /* 1870 */ 1665, 507, 509, 528, 1359, 1359, 1359, 1677, 1359, 1359, + /* 1880 */ 1359, 1359, 508, 1359, 1359, 509, 1631, 1359, 1359, 1359, + /* 1890 */ 1359, 1359, 1359, 1359, 1359, 508, 1359, 1661, 1359, 1631, + /* 1900 */ 1359, 1359, 1359, 1690, 1359, 1359, 1671, 1662, 511, 1664, + /* 1910 */ 1665, 507, 1661, 528, 1359, 1359, 1690, 1359, 1359, 280, + /* 1920 */ 1662, 511, 1664, 1665, 507, 1677, 528, 1359, 1359, 1359, + /* 1930 */ 1359, 1359, 1359, 509, 1359, 1359, 1359, 1359, 1359, 1359, + /* 1940 */ 1677, 1359, 1359, 508, 1359, 1661, 1359, 1631, 509, 1359, + /* 1950 */ 1359, 1359, 1359, 311, 310, 1359, 1359, 1359, 508, 1359, + /* 1960 */ 1359, 1359, 1631, 1184, 1690, 1359, 1359, 279, 1662, 511, + /* 1970 */ 1664, 1665, 507, 1677, 528, 1359, 1359, 1359, 1359, 1690, + /* 1980 */ 1359, 509, 281, 1662, 511, 1664, 1665, 507, 1177, 528, + /* 1990 */ 1359, 508, 1359, 1359, 1359, 1631, 1359, 1359, 1359, 1661, + /* 2000 */ 1359, 1359, 1359, 1359, 1359, 1176, 1359, 1359, 1359, 1359, + /* 2010 */ 1359, 1359, 1690, 1359, 1359, 278, 1662, 511, 1664, 1665, + /* 2020 */ 507, 1359, 528, 1359, 1359, 1359, 1359, 1677, 1359, 1359, + /* 2030 */ 1359, 1359, 1359, 1359, 1359, 509, 1359, 1359, 1359, 1359, + /* 2040 */ 1359, 1359, 1359, 1359, 529, 508, 1359, 1359, 1359, 1631, + /* 2050 */ 1359, 1359, 1359, 1359, 1359, 1180, 1359, 1359, 1359, 1359, + /* 2060 */ 1359, 1359, 1359, 1359, 1359, 1359, 1690, 1359, 1359, 264, + /* 2070 */ 1662, 511, 1664, 1665, 507, 1359, 528, 1359, 1359, 1359, + /* 2080 */ 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, + /* 2090 */ 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, + /* 2100 */ 1185, 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, + /* 2110 */ 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, + /* 2120 */ 1359, 1359, 1188, 1359, 1359, 1359, 1359, 1359, 1359, 1359, + /* 2130 */ 1359, 1359, 1359, 526, 1236, 1237, }; static const YYCODETYPE yy_lookahead[] = { - /* 0 */ 246, 273, 248, 249, 276, 246, 250, 248, 249, 324, - /* 10 */ 325, 4, 12, 13, 242, 271, 244, 243, 262, 339, - /* 20 */ 20, 293, 22, 279, 20, 269, 12, 13, 14, 15, - /* 30 */ 16, 247, 352, 255, 250, 279, 356, 309, 310, 12, - /* 40 */ 13, 14, 15, 16, 271, 271, 268, 47, 320, 42, - /* 50 */ 43, 278, 47, 279, 250, 277, 283, 55, 58, 315, - /* 60 */ 12, 13, 14, 289, 64, 2, 262, 293, 20, 64, - /* 70 */ 22, 0, 58, 299, 20, 12, 13, 14, 15, 16, - /* 80 */ 4, 81, 80, 279, 310, 83, 250, 313, 314, 315, - /* 90 */ 316, 317, 318, 0, 320, 47, 82, 323, 262, 251, - /* 100 */ 252, 327, 328, 103, 90, 269, 58, 12, 13, 14, - /* 110 */ 15, 16, 64, 339, 114, 279, 270, 24, 25, 26, - /* 120 */ 27, 28, 29, 30, 31, 32, 352, 75, 282, 81, - /* 130 */ 356, 60, 61, 62, 63, 81, 65, 66, 67, 68, - /* 140 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, - /* 150 */ 289, 103, 279, 292, 140, 81, 295, 81, 158, 286, - /* 160 */ 21, 339, 114, 24, 25, 26, 27, 28, 29, 30, - /* 170 */ 31, 32, 120, 121, 352, 250, 162, 150, 356, 247, - /* 180 */ 180, 181, 250, 183, 184, 185, 186, 187, 188, 189, - /* 190 */ 190, 191, 192, 193, 194, 195, 196, 197, 0, 12, - /* 200 */ 13, 14, 15, 16, 167, 168, 158, 256, 171, 284, - /* 210 */ 210, 260, 198, 199, 200, 201, 202, 203, 204, 205, - /* 220 */ 206, 207, 0, 12, 13, 14, 15, 16, 180, 181, - /* 230 */ 250, 183, 184, 185, 186, 187, 188, 189, 190, 191, - /* 240 */ 192, 193, 194, 195, 196, 197, 12, 13, 0, 20, - /* 250 */ 253, 22, 60, 61, 20, 57, 22, 65, 231, 279, - /* 260 */ 68, 69, 263, 339, 72, 73, 74, 12, 13, 82, - /* 270 */ 271, 274, 243, 57, 20, 20, 352, 22, 49, 280, - /* 280 */ 356, 47, 60, 61, 210, 20, 210, 65, 255, 47, - /* 290 */ 68, 69, 58, 82, 72, 73, 74, 317, 64, 0, - /* 300 */ 271, 14, 47, 243, 243, 250, 64, 20, 279, 250, - /* 310 */ 277, 331, 332, 333, 334, 81, 336, 262, 289, 64, - /* 320 */ 21, 262, 293, 24, 25, 26, 27, 28, 29, 30, - /* 330 */ 31, 32, 271, 243, 279, 81, 81, 103, 279, 310, - /* 340 */ 279, 93, 313, 314, 315, 316, 317, 318, 114, 320, - /* 350 */ 289, 20, 323, 293, 293, 271, 327, 328, 103, 271, - /* 360 */ 112, 113, 278, 115, 116, 117, 243, 283, 280, 114, - /* 370 */ 259, 310, 261, 271, 313, 314, 315, 316, 317, 318, - /* 380 */ 278, 320, 250, 293, 323, 283, 311, 2, 327, 328, - /* 390 */ 329, 20, 158, 3, 262, 257, 258, 12, 13, 14, - /* 400 */ 15, 16, 341, 12, 13, 14, 15, 16, 347, 348, - /* 410 */ 335, 279, 81, 158, 180, 181, 293, 183, 184, 185, - /* 420 */ 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - /* 430 */ 196, 197, 250, 257, 258, 180, 181, 243, 183, 184, - /* 440 */ 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - /* 450 */ 195, 196, 197, 12, 13, 14, 243, 4, 20, 19, - /* 460 */ 281, 20, 243, 22, 210, 210, 264, 288, 289, 267, - /* 470 */ 14, 184, 19, 33, 12, 13, 20, 273, 243, 243, - /* 480 */ 273, 299, 20, 276, 22, 45, 33, 293, 47, 250, - /* 490 */ 144, 51, 52, 53, 54, 55, 14, 293, 45, 240, - /* 500 */ 293, 262, 20, 50, 57, 64, 293, 271, 55, 47, - /* 510 */ 153, 250, 293, 309, 310, 279, 309, 310, 279, 250, - /* 520 */ 80, 339, 81, 83, 320, 289, 64, 320, 293, 293, - /* 530 */ 173, 174, 64, 80, 352, 299, 83, 146, 356, 289, - /* 540 */ 279, 210, 41, 81, 103, 295, 310, 20, 279, 313, - /* 550 */ 314, 315, 316, 317, 318, 114, 320, 117, 299, 323, - /* 560 */ 243, 215, 216, 327, 328, 103, 12, 13, 14, 15, - /* 570 */ 16, 273, 80, 263, 272, 339, 114, 93, 317, 92, - /* 580 */ 88, 271, 142, 82, 146, 145, 317, 0, 352, 81, - /* 590 */ 280, 293, 356, 332, 333, 334, 253, 336, 339, 158, - /* 600 */ 116, 332, 333, 334, 164, 336, 166, 309, 310, 266, - /* 610 */ 293, 352, 58, 288, 289, 356, 226, 274, 320, 4, - /* 620 */ 158, 180, 181, 243, 183, 184, 185, 186, 187, 188, - /* 630 */ 189, 190, 191, 192, 193, 194, 195, 196, 197, 35, - /* 640 */ 184, 149, 180, 181, 90, 183, 184, 185, 186, 187, - /* 650 */ 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - /* 660 */ 12, 13, 18, 93, 20, 157, 180, 159, 20, 250, - /* 670 */ 22, 27, 250, 293, 30, 14, 15, 16, 208, 209, - /* 680 */ 93, 262, 112, 113, 262, 115, 116, 117, 84, 37, - /* 690 */ 86, 87, 48, 89, 140, 47, 22, 93, 279, 112, - /* 700 */ 113, 279, 115, 116, 117, 219, 220, 221, 222, 223, - /* 710 */ 271, 263, 64, 1, 2, 243, 162, 311, 210, 271, - /* 720 */ 116, 47, 283, 42, 43, 311, 169, 170, 280, 81, - /* 730 */ 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - /* 740 */ 104, 335, 106, 107, 108, 109, 110, 111, 299, 335, - /* 750 */ 243, 103, 198, 199, 200, 201, 202, 203, 204, 205, - /* 760 */ 206, 207, 114, 119, 0, 293, 122, 123, 124, 125, - /* 770 */ 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - /* 780 */ 136, 137, 138, 139, 250, 250, 18, 250, 339, 20, - /* 790 */ 41, 23, 20, 20, 82, 140, 262, 262, 272, 262, - /* 800 */ 293, 352, 243, 35, 36, 356, 158, 39, 243, 243, - /* 810 */ 243, 299, 243, 279, 279, 243, 279, 162, 250, 243, - /* 820 */ 243, 57, 243, 146, 56, 148, 211, 272, 180, 181, - /* 830 */ 262, 183, 184, 185, 186, 187, 188, 189, 190, 191, - /* 840 */ 192, 193, 194, 195, 196, 197, 41, 279, 271, 81, - /* 850 */ 272, 339, 293, 198, 0, 272, 279, 0, 293, 293, - /* 860 */ 293, 209, 293, 0, 352, 293, 289, 0, 356, 293, - /* 870 */ 293, 85, 293, 85, 88, 85, 88, 85, 88, 22, - /* 880 */ 88, 243, 58, 21, 272, 22, 118, 310, 81, 22, - /* 890 */ 313, 314, 315, 316, 317, 318, 34, 320, 91, 45, - /* 900 */ 323, 1, 2, 272, 327, 328, 329, 244, 303, 271, - /* 910 */ 195, 196, 44, 260, 243, 146, 47, 279, 150, 151, - /* 920 */ 152, 41, 41, 155, 350, 348, 47, 289, 160, 41, - /* 930 */ 359, 293, 41, 41, 41, 307, 344, 271, 249, 41, - /* 940 */ 172, 251, 271, 175, 282, 177, 178, 179, 310, 81, - /* 950 */ 279, 313, 314, 315, 316, 317, 318, 184, 320, 312, - /* 960 */ 289, 323, 82, 82, 293, 327, 328, 329, 20, 41, - /* 970 */ 82, 41, 337, 82, 82, 82, 338, 228, 210, 243, - /* 980 */ 82, 310, 353, 114, 313, 314, 315, 316, 317, 318, - /* 990 */ 353, 320, 41, 114, 323, 243, 41, 41, 327, 328, - /* 1000 */ 329, 250, 41, 353, 180, 340, 41, 271, 45, 338, - /* 1010 */ 82, 308, 82, 47, 257, 279, 41, 41, 301, 40, - /* 1020 */ 156, 250, 287, 271, 250, 289, 140, 243, 285, 293, - /* 1030 */ 285, 279, 250, 82, 20, 230, 245, 82, 82, 245, - /* 1040 */ 20, 289, 305, 82, 255, 293, 310, 82, 289, 313, - /* 1050 */ 314, 315, 316, 317, 318, 271, 320, 82, 82, 323, - /* 1060 */ 20, 255, 310, 279, 328, 313, 314, 315, 316, 317, - /* 1070 */ 318, 20, 320, 289, 297, 323, 300, 293, 243, 327, - /* 1080 */ 328, 329, 255, 299, 297, 255, 20, 279, 290, 255, - /* 1090 */ 338, 255, 250, 243, 310, 255, 245, 313, 314, 315, - /* 1100 */ 316, 317, 318, 271, 320, 250, 271, 64, 271, 271, - /* 1110 */ 271, 245, 271, 293, 279, 271, 271, 271, 271, 271, - /* 1120 */ 271, 271, 305, 339, 289, 253, 304, 253, 293, 279, - /* 1130 */ 297, 253, 165, 290, 299, 279, 352, 253, 20, 289, - /* 1140 */ 356, 289, 218, 293, 243, 310, 349, 294, 313, 314, - /* 1150 */ 315, 316, 317, 318, 217, 320, 225, 346, 293, 349, - /* 1160 */ 310, 345, 224, 313, 314, 315, 316, 317, 318, 294, - /* 1170 */ 320, 312, 271, 323, 339, 293, 293, 327, 328, 20, - /* 1180 */ 279, 213, 212, 209, 279, 40, 229, 352, 311, 360, - /* 1190 */ 289, 356, 232, 81, 293, 293, 243, 293, 227, 293, - /* 1200 */ 12, 13, 294, 343, 294, 243, 330, 143, 291, 290, - /* 1210 */ 22, 310, 342, 355, 313, 314, 315, 316, 317, 318, - /* 1220 */ 319, 320, 321, 322, 271, 354, 279, 81, 355, 326, - /* 1230 */ 253, 267, 279, 271, 253, 47, 250, 279, 253, 354, - /* 1240 */ 245, 279, 289, 261, 355, 302, 293, 275, 354, 265, - /* 1250 */ 306, 289, 64, 243, 265, 293, 265, 298, 296, 254, - /* 1260 */ 241, 0, 0, 310, 72, 0, 313, 314, 315, 316, - /* 1270 */ 317, 318, 310, 320, 47, 313, 314, 315, 316, 317, - /* 1280 */ 318, 271, 320, 176, 47, 243, 47, 47, 0, 279, - /* 1290 */ 176, 103, 47, 47, 0, 176, 47, 0, 47, 289, - /* 1300 */ 0, 47, 114, 293, 0, 81, 162, 114, 161, 158, - /* 1310 */ 357, 358, 0, 271, 0, 154, 153, 243, 0, 0, - /* 1320 */ 310, 279, 44, 313, 314, 315, 316, 317, 318, 0, - /* 1330 */ 320, 289, 0, 0, 0, 293, 0, 0, 0, 0, - /* 1340 */ 0, 0, 0, 0, 0, 271, 158, 0, 0, 0, - /* 1350 */ 0, 0, 310, 279, 0, 313, 314, 315, 316, 317, - /* 1360 */ 318, 351, 320, 289, 40, 243, 0, 293, 180, 0, - /* 1370 */ 296, 0, 0, 0, 22, 0, 0, 0, 243, 191, - /* 1380 */ 192, 193, 0, 0, 310, 0, 40, 313, 314, 315, - /* 1390 */ 316, 317, 318, 271, 320, 14, 37, 41, 14, 44, - /* 1400 */ 358, 279, 0, 38, 44, 37, 271, 0, 0, 0, - /* 1410 */ 0, 289, 0, 0, 279, 293, 37, 37, 243, 0, - /* 1420 */ 59, 0, 0, 37, 289, 47, 0, 37, 293, 37, - /* 1430 */ 0, 296, 310, 37, 45, 313, 314, 315, 316, 317, - /* 1440 */ 318, 47, 320, 45, 322, 310, 271, 47, 313, 314, - /* 1450 */ 315, 316, 317, 318, 279, 320, 45, 0, 33, 0, - /* 1460 */ 45, 47, 0, 0, 289, 47, 243, 0, 293, 22, - /* 1470 */ 45, 296, 41, 41, 47, 22, 51, 52, 53, 54, - /* 1480 */ 55, 90, 47, 88, 47, 310, 47, 47, 313, 314, - /* 1490 */ 315, 316, 317, 318, 271, 320, 47, 47, 0, 22, - /* 1500 */ 47, 0, 279, 22, 48, 80, 0, 22, 83, 0, - /* 1510 */ 22, 47, 289, 0, 22, 20, 293, 64, 0, 47, - /* 1520 */ 146, 0, 22, 243, 0, 163, 0, 0, 37, 81, - /* 1530 */ 143, 41, 81, 310, 141, 41, 313, 314, 315, 316, - /* 1540 */ 317, 318, 82, 320, 214, 146, 41, 82, 82, 81, - /* 1550 */ 81, 271, 41, 41, 44, 81, 103, 82, 44, 279, - /* 1560 */ 82, 44, 82, 41, 44, 208, 141, 114, 143, 289, - /* 1570 */ 145, 243, 147, 293, 41, 47, 47, 214, 214, 82, - /* 1580 */ 2, 47, 47, 47, 47, 180, 41, 44, 44, 82, - /* 1590 */ 310, 166, 22, 313, 314, 315, 316, 317, 318, 271, - /* 1600 */ 320, 243, 182, 0, 81, 144, 81, 279, 44, 37, - /* 1610 */ 91, 158, 82, 81, 141, 22, 47, 289, 44, 81, - /* 1620 */ 81, 293, 82, 92, 82, 59, 47, 81, 81, 271, - /* 1630 */ 81, 243, 81, 180, 181, 82, 81, 279, 310, 81, - /* 1640 */ 81, 313, 314, 315, 316, 317, 318, 289, 320, 82, - /* 1650 */ 82, 293, 47, 47, 81, 47, 47, 82, 81, 271, - /* 1660 */ 22, 105, 82, 81, 47, 82, 81, 279, 310, 93, - /* 1670 */ 105, 313, 314, 315, 316, 317, 318, 289, 320, 243, - /* 1680 */ 81, 293, 81, 81, 47, 22, 105, 58, 243, 105, - /* 1690 */ 47, 64, 79, 41, 47, 47, 47, 47, 310, 22, - /* 1700 */ 114, 313, 314, 315, 316, 317, 318, 271, 320, 47, - /* 1710 */ 64, 47, 47, 47, 47, 279, 271, 47, 47, 47, - /* 1720 */ 47, 47, 0, 47, 279, 289, 45, 37, 0, 293, - /* 1730 */ 47, 45, 37, 0, 289, 47, 243, 45, 293, 37, - /* 1740 */ 0, 47, 45, 37, 0, 47, 310, 46, 0, 313, - /* 1750 */ 314, 315, 316, 317, 318, 310, 320, 0, 313, 314, - /* 1760 */ 315, 316, 317, 318, 271, 320, 20, 22, 21, 361, - /* 1770 */ 361, 22, 279, 22, 21, 361, 361, 361, 361, 361, + /* 0 */ 303, 273, 271, 273, 276, 246, 276, 248, 249, 278, + /* 10 */ 324, 325, 12, 13, 283, 2, 243, 243, 4, 272, + /* 20 */ 20, 293, 22, 293, 270, 12, 13, 14, 15, 16, + /* 30 */ 12, 13, 14, 15, 16, 273, 282, 309, 310, 309, + /* 40 */ 310, 246, 0, 248, 249, 271, 20, 47, 320, 242, + /* 50 */ 320, 244, 339, 279, 250, 293, 42, 43, 58, 20, + /* 60 */ 12, 13, 14, 289, 64, 352, 293, 293, 20, 356, + /* 70 */ 22, 309, 310, 299, 12, 13, 14, 15, 16, 251, + /* 80 */ 252, 81, 320, 279, 310, 80, 250, 313, 314, 315, + /* 90 */ 316, 317, 318, 88, 320, 47, 243, 323, 262, 57, + /* 100 */ 82, 327, 328, 103, 311, 269, 58, 81, 12, 13, + /* 110 */ 339, 273, 64, 339, 114, 279, 20, 311, 22, 289, + /* 120 */ 58, 317, 292, 352, 271, 295, 352, 356, 335, 81, + /* 130 */ 356, 293, 279, 14, 75, 331, 332, 333, 334, 20, + /* 140 */ 336, 335, 289, 47, 82, 81, 293, 309, 310, 250, + /* 150 */ 4, 103, 90, 256, 58, 150, 271, 260, 320, 159, + /* 160 */ 64, 262, 114, 310, 279, 57, 313, 314, 315, 316, + /* 170 */ 317, 318, 319, 320, 321, 322, 243, 81, 279, 120, + /* 180 */ 121, 181, 182, 20, 184, 185, 186, 187, 188, 189, + /* 190 */ 190, 191, 192, 193, 194, 195, 196, 197, 198, 103, + /* 200 */ 315, 255, 140, 55, 168, 169, 4, 159, 172, 21, + /* 210 */ 114, 211, 24, 25, 26, 27, 28, 29, 30, 31, + /* 220 */ 32, 243, 158, 277, 160, 163, 293, 81, 80, 181, + /* 230 */ 182, 83, 184, 185, 186, 187, 188, 189, 190, 191, + /* 240 */ 192, 193, 194, 195, 196, 197, 198, 0, 35, 20, + /* 250 */ 12, 13, 14, 15, 16, 159, 12, 13, 14, 15, + /* 260 */ 16, 199, 200, 201, 202, 203, 204, 205, 206, 207, + /* 270 */ 208, 293, 81, 240, 311, 211, 247, 181, 182, 250, + /* 280 */ 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + /* 290 */ 194, 195, 196, 197, 198, 12, 13, 84, 335, 86, + /* 300 */ 87, 20, 89, 20, 185, 22, 93, 60, 61, 62, + /* 310 */ 63, 0, 65, 66, 67, 68, 69, 70, 71, 72, + /* 320 */ 73, 74, 75, 76, 77, 78, 60, 61, 255, 116, + /* 330 */ 47, 65, 299, 243, 68, 69, 93, 299, 72, 73, + /* 340 */ 74, 268, 250, 12, 13, 14, 14, 64, 20, 22, + /* 350 */ 277, 20, 20, 22, 262, 112, 113, 211, 115, 116, + /* 360 */ 117, 271, 81, 339, 81, 263, 243, 144, 57, 279, + /* 370 */ 140, 279, 339, 271, 47, 299, 352, 339, 47, 289, + /* 380 */ 356, 181, 280, 293, 146, 352, 103, 257, 258, 356, + /* 390 */ 352, 12, 13, 163, 356, 64, 20, 114, 22, 20, + /* 400 */ 310, 22, 211, 313, 314, 315, 316, 317, 318, 81, + /* 410 */ 320, 243, 81, 323, 212, 339, 293, 327, 328, 329, + /* 420 */ 220, 221, 222, 223, 224, 49, 47, 0, 352, 199, + /* 430 */ 289, 341, 356, 263, 103, 0, 295, 347, 348, 216, + /* 440 */ 217, 271, 159, 64, 0, 114, 247, 243, 21, 250, + /* 450 */ 280, 24, 25, 26, 27, 28, 29, 30, 31, 32, + /* 460 */ 81, 293, 257, 258, 181, 182, 22, 184, 185, 186, + /* 470 */ 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + /* 480 */ 197, 198, 103, 12, 13, 14, 15, 16, 0, 253, + /* 490 */ 159, 279, 211, 114, 211, 60, 61, 293, 286, 271, + /* 500 */ 65, 37, 250, 68, 69, 20, 278, 72, 73, 74, + /* 510 */ 274, 283, 181, 182, 262, 184, 185, 186, 187, 188, + /* 520 */ 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + /* 530 */ 41, 279, 12, 13, 14, 15, 16, 20, 159, 211, + /* 540 */ 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + /* 550 */ 104, 281, 106, 107, 108, 109, 110, 111, 288, 289, + /* 560 */ 181, 182, 243, 184, 185, 186, 187, 188, 189, 190, + /* 570 */ 191, 192, 193, 194, 195, 196, 197, 198, 12, 13, + /* 580 */ 18, 93, 20, 2, 1, 2, 20, 243, 22, 27, + /* 590 */ 3, 47, 30, 12, 13, 14, 15, 16, 288, 289, + /* 600 */ 112, 113, 82, 115, 116, 117, 33, 250, 64, 271, + /* 610 */ 48, 14, 293, 47, 0, 271, 278, 20, 45, 262, + /* 620 */ 250, 283, 151, 279, 51, 52, 53, 54, 55, 243, + /* 630 */ 64, 154, 262, 289, 42, 43, 279, 293, 24, 25, + /* 640 */ 26, 27, 28, 29, 30, 31, 32, 81, 250, 279, + /* 650 */ 20, 174, 175, 80, 310, 253, 83, 313, 314, 315, + /* 660 */ 316, 317, 318, 146, 320, 82, 271, 323, 266, 103, + /* 670 */ 250, 327, 328, 329, 210, 280, 274, 279, 250, 293, + /* 680 */ 114, 119, 338, 243, 122, 123, 124, 125, 126, 127, + /* 690 */ 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + /* 700 */ 138, 139, 231, 264, 284, 18, 267, 250, 92, 250, + /* 710 */ 23, 14, 15, 16, 141, 317, 143, 228, 145, 262, + /* 720 */ 147, 262, 35, 36, 57, 159, 39, 299, 269, 64, + /* 730 */ 332, 333, 334, 293, 336, 20, 279, 243, 279, 85, + /* 740 */ 167, 0, 88, 56, 243, 41, 243, 181, 182, 20, + /* 750 */ 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + /* 760 */ 194, 195, 196, 197, 198, 271, 243, 339, 81, 250, + /* 770 */ 259, 263, 261, 279, 12, 13, 14, 15, 16, 271, + /* 780 */ 352, 262, 185, 289, 356, 209, 210, 293, 280, 250, + /* 790 */ 250, 243, 0, 299, 293, 250, 293, 243, 279, 272, + /* 800 */ 93, 262, 262, 250, 310, 118, 250, 313, 314, 315, + /* 810 */ 316, 317, 318, 226, 320, 262, 293, 323, 279, 279, + /* 820 */ 58, 327, 328, 116, 279, 243, 170, 171, 85, 0, + /* 830 */ 250, 88, 279, 339, 93, 279, 243, 45, 151, 152, + /* 840 */ 153, 293, 262, 156, 299, 22, 352, 293, 161, 243, + /* 850 */ 356, 22, 90, 112, 113, 243, 115, 116, 117, 279, + /* 860 */ 173, 146, 317, 176, 271, 178, 179, 180, 243, 243, + /* 870 */ 47, 58, 279, 317, 41, 293, 272, 332, 333, 334, + /* 880 */ 85, 336, 289, 88, 339, 81, 293, 64, 332, 333, + /* 890 */ 334, 146, 336, 85, 149, 91, 88, 352, 211, 293, + /* 900 */ 271, 356, 140, 310, 243, 293, 313, 314, 315, 316, + /* 910 */ 317, 318, 283, 320, 185, 82, 323, 0, 293, 293, + /* 920 */ 327, 328, 329, 21, 250, 163, 103, 1, 2, 196, + /* 930 */ 197, 41, 271, 244, 230, 47, 34, 114, 272, 22, + /* 940 */ 279, 348, 41, 44, 41, 47, 260, 272, 272, 272, + /* 950 */ 289, 41, 41, 279, 293, 41, 41, 41, 359, 41, + /* 960 */ 41, 199, 200, 201, 202, 203, 204, 205, 206, 207, + /* 970 */ 208, 310, 82, 299, 313, 314, 315, 316, 317, 318, + /* 980 */ 81, 320, 159, 82, 323, 82, 41, 243, 327, 328, + /* 990 */ 329, 317, 82, 82, 181, 41, 82, 82, 82, 338, + /* 1000 */ 82, 82, 114, 41, 181, 182, 332, 333, 334, 41, + /* 1010 */ 336, 41, 114, 339, 47, 271, 307, 344, 350, 243, + /* 1020 */ 271, 249, 41, 279, 251, 312, 352, 82, 282, 337, + /* 1030 */ 356, 64, 353, 289, 353, 353, 82, 293, 340, 20, + /* 1040 */ 250, 45, 308, 257, 82, 47, 157, 271, 301, 243, + /* 1050 */ 82, 250, 82, 250, 310, 279, 40, 313, 314, 315, + /* 1060 */ 316, 317, 318, 82, 320, 289, 287, 323, 140, 293, + /* 1070 */ 285, 327, 328, 329, 285, 299, 250, 271, 20, 245, + /* 1080 */ 245, 20, 338, 305, 20, 279, 310, 255, 289, 313, + /* 1090 */ 314, 315, 316, 317, 318, 289, 320, 255, 20, 293, + /* 1100 */ 300, 255, 297, 255, 297, 299, 279, 243, 20, 290, + /* 1110 */ 4, 255, 255, 250, 255, 339, 310, 245, 271, 313, + /* 1120 */ 314, 315, 316, 317, 318, 19, 320, 250, 352, 271, + /* 1130 */ 245, 271, 356, 271, 64, 271, 271, 271, 271, 33, + /* 1140 */ 271, 271, 271, 279, 271, 339, 293, 243, 305, 253, + /* 1150 */ 166, 45, 297, 289, 304, 279, 50, 293, 352, 253, + /* 1160 */ 253, 55, 356, 289, 20, 290, 243, 219, 218, 349, + /* 1170 */ 349, 225, 293, 253, 310, 271, 294, 313, 314, 315, + /* 1180 */ 316, 317, 318, 279, 320, 294, 80, 323, 293, 83, + /* 1190 */ 312, 327, 328, 289, 271, 346, 148, 293, 243, 345, + /* 1200 */ 214, 293, 279, 213, 343, 210, 279, 20, 311, 40, + /* 1210 */ 342, 330, 289, 81, 310, 227, 293, 313, 314, 315, + /* 1220 */ 316, 317, 318, 229, 320, 232, 271, 323, 294, 293, + /* 1230 */ 293, 327, 328, 310, 279, 355, 313, 314, 315, 316, + /* 1240 */ 317, 318, 293, 320, 289, 294, 354, 360, 293, 355, + /* 1250 */ 326, 143, 291, 19, 354, 279, 290, 253, 267, 253, + /* 1260 */ 355, 279, 81, 243, 275, 310, 354, 33, 313, 314, + /* 1270 */ 315, 316, 317, 318, 261, 320, 250, 253, 323, 45, + /* 1280 */ 357, 358, 245, 328, 306, 51, 52, 53, 54, 55, + /* 1290 */ 265, 271, 265, 265, 302, 298, 254, 241, 0, 279, + /* 1300 */ 0, 72, 0, 47, 177, 47, 47, 47, 177, 289, + /* 1310 */ 0, 243, 47, 293, 80, 47, 296, 83, 177, 0, + /* 1320 */ 47, 0, 47, 0, 47, 0, 81, 163, 162, 114, + /* 1330 */ 310, 159, 0, 313, 314, 315, 316, 317, 318, 271, + /* 1340 */ 320, 0, 0, 155, 154, 0, 0, 279, 44, 0, + /* 1350 */ 0, 117, 0, 0, 0, 0, 0, 289, 0, 243, + /* 1360 */ 0, 293, 0, 0, 0, 0, 0, 0, 243, 0, + /* 1370 */ 0, 40, 0, 0, 0, 0, 142, 0, 310, 145, + /* 1380 */ 0, 313, 314, 315, 316, 317, 318, 271, 320, 0, + /* 1390 */ 22, 0, 0, 0, 0, 279, 271, 40, 37, 165, + /* 1400 */ 0, 167, 14, 44, 279, 289, 0, 0, 0, 293, + /* 1410 */ 14, 0, 41, 0, 289, 148, 38, 0, 293, 351, + /* 1420 */ 44, 296, 243, 37, 37, 0, 310, 37, 0, 313, + /* 1430 */ 314, 315, 316, 317, 318, 310, 320, 243, 313, 314, + /* 1440 */ 315, 316, 317, 318, 59, 320, 0, 45, 47, 37, + /* 1450 */ 271, 0, 47, 37, 45, 0, 37, 47, 279, 45, + /* 1460 */ 0, 37, 47, 45, 0, 271, 0, 0, 289, 0, + /* 1470 */ 243, 90, 293, 279, 358, 22, 47, 0, 47, 47, + /* 1480 */ 47, 47, 41, 289, 41, 243, 88, 293, 0, 310, + /* 1490 */ 296, 47, 313, 314, 315, 316, 317, 318, 271, 320, + /* 1500 */ 22, 322, 0, 47, 310, 47, 279, 313, 314, 315, + /* 1510 */ 316, 317, 318, 271, 320, 0, 289, 22, 48, 22, + /* 1520 */ 293, 279, 47, 296, 0, 243, 22, 0, 22, 20, + /* 1530 */ 0, 289, 47, 0, 22, 293, 0, 310, 143, 0, + /* 1540 */ 313, 314, 315, 316, 317, 318, 0, 320, 164, 146, + /* 1550 */ 146, 37, 310, 271, 81, 313, 314, 315, 316, 317, + /* 1560 */ 318, 279, 320, 141, 41, 82, 41, 41, 82, 82, + /* 1570 */ 81, 289, 81, 81, 2, 293, 41, 243, 44, 81, + /* 1580 */ 81, 44, 82, 41, 44, 82, 41, 44, 41, 82, + /* 1590 */ 82, 47, 310, 41, 215, 313, 314, 315, 316, 317, + /* 1600 */ 318, 47, 320, 47, 47, 271, 47, 47, 181, 44, + /* 1610 */ 82, 82, 81, 279, 215, 44, 22, 0, 183, 81, + /* 1620 */ 144, 37, 141, 289, 44, 243, 44, 293, 59, 209, + /* 1630 */ 81, 22, 82, 82, 47, 47, 215, 47, 47, 81, + /* 1640 */ 243, 22, 81, 81, 310, 81, 91, 313, 314, 315, + /* 1650 */ 316, 317, 318, 271, 320, 81, 93, 82, 81, 81, + /* 1660 */ 92, 279, 47, 82, 81, 47, 22, 82, 271, 47, + /* 1670 */ 81, 289, 105, 243, 82, 293, 279, 81, 105, 82, + /* 1680 */ 81, 105, 82, 81, 105, 81, 289, 47, 81, 81, + /* 1690 */ 293, 58, 310, 47, 64, 313, 314, 315, 316, 317, + /* 1700 */ 318, 271, 320, 79, 41, 47, 47, 310, 47, 279, + /* 1710 */ 313, 314, 315, 316, 317, 318, 22, 320, 47, 289, + /* 1720 */ 47, 47, 47, 293, 114, 47, 64, 243, 47, 47, + /* 1730 */ 47, 47, 47, 47, 0, 47, 243, 45, 37, 0, + /* 1740 */ 310, 45, 47, 313, 314, 315, 316, 317, 318, 37, + /* 1750 */ 320, 0, 47, 45, 37, 271, 47, 37, 45, 0, + /* 1760 */ 0, 47, 46, 279, 271, 0, 0, 22, 21, 361, + /* 1770 */ 22, 22, 279, 289, 21, 20, 361, 293, 361, 361, /* 1780 */ 361, 361, 289, 361, 243, 361, 293, 361, 361, 361, - /* 1790 */ 361, 361, 361, 361, 361, 243, 361, 361, 361, 361, - /* 1800 */ 361, 361, 361, 310, 361, 361, 313, 314, 315, 316, - /* 1810 */ 317, 318, 271, 320, 243, 361, 361, 361, 361, 361, - /* 1820 */ 279, 361, 361, 271, 361, 361, 361, 361, 361, 361, - /* 1830 */ 289, 279, 361, 361, 293, 361, 361, 361, 361, 361, - /* 1840 */ 361, 289, 271, 361, 361, 293, 361, 361, 361, 361, - /* 1850 */ 279, 310, 361, 361, 313, 314, 315, 316, 317, 318, - /* 1860 */ 289, 320, 310, 361, 293, 313, 314, 315, 316, 317, - /* 1870 */ 318, 361, 320, 243, 361, 361, 361, 361, 361, 361, - /* 1880 */ 361, 310, 243, 361, 313, 314, 315, 316, 317, 318, - /* 1890 */ 361, 320, 361, 361, 361, 361, 361, 361, 361, 361, - /* 1900 */ 361, 271, 361, 361, 361, 361, 361, 361, 361, 279, - /* 1910 */ 271, 361, 361, 361, 361, 361, 361, 361, 279, 289, - /* 1920 */ 361, 361, 361, 293, 361, 361, 361, 361, 289, 361, - /* 1930 */ 361, 361, 293, 361, 361, 361, 361, 361, 361, 361, - /* 1940 */ 310, 361, 243, 313, 314, 315, 316, 317, 318, 310, - /* 1950 */ 320, 243, 313, 314, 315, 316, 317, 318, 361, 320, - /* 1960 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, - /* 1970 */ 271, 361, 361, 361, 361, 361, 361, 361, 279, 271, - /* 1980 */ 361, 361, 361, 361, 361, 361, 361, 279, 289, 361, - /* 1990 */ 361, 361, 293, 361, 361, 361, 361, 289, 361, 243, - /* 2000 */ 361, 293, 361, 361, 361, 361, 361, 361, 361, 310, - /* 2010 */ 250, 361, 313, 314, 315, 316, 317, 318, 310, 320, - /* 2020 */ 361, 313, 314, 315, 316, 317, 318, 271, 320, 361, - /* 2030 */ 361, 361, 361, 361, 361, 279, 361, 361, 361, 279, - /* 2040 */ 361, 361, 361, 361, 361, 289, 250, 361, 361, 293, - /* 2050 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 299, + /* 1790 */ 361, 361, 361, 361, 310, 361, 243, 313, 314, 315, + /* 1800 */ 316, 317, 318, 310, 320, 361, 313, 314, 315, 316, + /* 1810 */ 317, 318, 271, 320, 361, 361, 361, 361, 361, 361, + /* 1820 */ 279, 361, 361, 361, 271, 361, 361, 361, 361, 361, + /* 1830 */ 289, 361, 279, 361, 293, 361, 243, 361, 361, 361, + /* 1840 */ 361, 361, 289, 361, 361, 361, 293, 361, 361, 243, + /* 1850 */ 361, 310, 361, 361, 313, 314, 315, 316, 317, 318, + /* 1860 */ 361, 320, 361, 310, 271, 361, 313, 314, 315, 316, + /* 1870 */ 317, 318, 279, 320, 361, 361, 361, 271, 361, 361, + /* 1880 */ 361, 361, 289, 361, 361, 279, 293, 361, 361, 361, + /* 1890 */ 361, 361, 361, 361, 361, 289, 361, 243, 361, 293, + /* 1900 */ 361, 361, 361, 310, 361, 361, 313, 314, 315, 316, + /* 1910 */ 317, 318, 243, 320, 361, 361, 310, 361, 361, 313, + /* 1920 */ 314, 315, 316, 317, 318, 271, 320, 361, 361, 361, + /* 1930 */ 361, 361, 361, 279, 361, 361, 361, 361, 361, 361, + /* 1940 */ 271, 361, 361, 289, 361, 243, 361, 293, 279, 361, + /* 1950 */ 361, 361, 361, 12, 13, 361, 361, 361, 289, 361, + /* 1960 */ 361, 361, 293, 22, 310, 361, 361, 313, 314, 315, + /* 1970 */ 316, 317, 318, 271, 320, 361, 361, 361, 361, 310, + /* 1980 */ 361, 279, 313, 314, 315, 316, 317, 318, 47, 320, + /* 1990 */ 361, 289, 361, 361, 361, 293, 361, 361, 361, 243, + /* 2000 */ 361, 361, 361, 361, 361, 64, 361, 361, 361, 361, + /* 2010 */ 361, 361, 310, 361, 361, 313, 314, 315, 316, 317, + /* 2020 */ 318, 361, 320, 361, 361, 361, 361, 271, 361, 361, + /* 2030 */ 361, 361, 361, 361, 361, 279, 361, 361, 361, 361, + /* 2040 */ 361, 361, 361, 361, 103, 289, 361, 361, 361, 293, + /* 2050 */ 361, 361, 361, 361, 361, 114, 361, 361, 361, 361, /* 2060 */ 361, 361, 361, 361, 361, 361, 310, 361, 361, 313, - /* 2070 */ 314, 315, 316, 317, 318, 279, 320, 317, 361, 361, + /* 2070 */ 314, 315, 316, 317, 318, 361, 320, 361, 361, 361, /* 2080 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, - /* 2090 */ 361, 361, 332, 333, 334, 299, 336, 361, 361, 339, - /* 2100 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, - /* 2110 */ 361, 361, 352, 317, 361, 361, 356, 361, 361, 361, - /* 2120 */ 361, 361, 361, 361, 361, 361, 361, 361, 332, 333, - /* 2130 */ 334, 361, 336, 361, 361, 339, 361, 361, 361, 361, - /* 2140 */ 361, 361, 361, 361, 361, 361, 361, 361, 352, 361, - /* 2150 */ 361, 361, 356, + /* 2090 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, + /* 2100 */ 159, 361, 361, 361, 361, 361, 361, 361, 361, 361, + /* 2110 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, + /* 2120 */ 361, 361, 181, 361, 361, 361, 361, 361, 361, 361, + /* 2130 */ 361, 361, 361, 192, 193, 194, 361, 361, 361, 361, + /* 2140 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, + /* 2150 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, + /* 2160 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, + /* 2170 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, + /* 2180 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, + /* 2190 */ 361, 361, 361, 361, }; -#define YY_SHIFT_COUNT (610) +#define YY_SHIFT_COUNT (611) #define YY_SHIFT_MIN (0) -#define YY_SHIFT_MAX (1757) +#define YY_SHIFT_MAX (1941) static const unsigned short int yy_shift_ofst[] = { - /* 0 */ 768, 0, 0, 48, 234, 234, 234, 234, 255, 255, - /* 10 */ 234, 234, 441, 462, 648, 462, 462, 462, 462, 462, - /* 20 */ 462, 462, 462, 462, 462, 462, 462, 462, 462, 462, - /* 30 */ 462, 462, 462, 462, 462, 462, 462, 462, 254, 254, - /* 40 */ 54, 54, 54, 1188, 1188, 1188, 1188, 331, 508, 74, - /* 50 */ 4, 4, 7, 7, 76, 74, 74, 4, 4, 4, - /* 60 */ 4, 4, 4, 216, 4, 265, 371, 527, 265, 4, - /* 70 */ 4, 265, 4, 265, 265, 527, 265, 4, 447, 644, - /* 80 */ 14, 554, 554, 139, 192, 1453, 1453, 1453, 1453, 1453, - /* 90 */ 1453, 1453, 1453, 1453, 1453, 1453, 1453, 1453, 1453, 1453, - /* 100 */ 1453, 1453, 1453, 1453, 604, 229, 482, 482, 198, 5, - /* 110 */ 438, 438, 438, 764, 5, 772, 527, 265, 265, 527, - /* 120 */ 487, 468, 636, 636, 636, 636, 636, 636, 636, 440, - /* 130 */ 299, 222, 27, 486, 37, 346, 287, 456, 681, 674, - /* 140 */ 484, 769, 470, 652, 470, 390, 390, 390, 615, 773, - /* 150 */ 948, 963, 966, 864, 948, 948, 979, 886, 886, 948, - /* 160 */ 1014, 1014, 1020, 216, 527, 216, 1040, 1051, 216, 1040, - /* 170 */ 216, 772, 1066, 216, 216, 948, 216, 1014, 265, 265, - /* 180 */ 265, 265, 265, 265, 265, 265, 265, 265, 265, 948, - /* 190 */ 1014, 1043, 1020, 447, 967, 527, 447, 1040, 447, 772, - /* 200 */ 1066, 447, 1118, 924, 937, 1043, 924, 937, 1043, 1043, - /* 210 */ 265, 931, 938, 968, 970, 974, 772, 1159, 1145, 957, - /* 220 */ 971, 960, 957, 971, 957, 971, 1112, 937, 1043, 1043, - /* 230 */ 937, 1043, 1064, 772, 1066, 447, 487, 447, 772, 1146, - /* 240 */ 468, 948, 447, 1014, 2153, 2153, 2153, 2153, 2153, 2153, - /* 250 */ 2153, 2153, 71, 1425, 93, 453, 248, 587, 187, 63, - /* 260 */ 385, 391, 211, 570, 95, 95, 95, 95, 95, 95, - /* 270 */ 95, 95, 357, 2, 52, 492, 712, 655, 661, 661, - /* 280 */ 661, 661, 854, 501, 786, 788, 790, 792, 857, 863, - /* 290 */ 867, 862, 557, 677, 880, 881, 888, 900, 715, 749, - /* 300 */ 805, 891, 824, 892, 868, 893, 898, 928, 930, 951, - /* 310 */ 869, 879, 955, 956, 961, 965, 975, 976, 807, 242, - /* 320 */ 1261, 1262, 1192, 1265, 1227, 1107, 1237, 1239, 1240, 1114, - /* 330 */ 1288, 1245, 1246, 1119, 1294, 1249, 1297, 1251, 1300, 1254, - /* 340 */ 1304, 1224, 1144, 1147, 1193, 1151, 1312, 1314, 1161, 1163, - /* 350 */ 1318, 1319, 1278, 1329, 1332, 1333, 1334, 1336, 1337, 1338, - /* 360 */ 1339, 1340, 1341, 1342, 1343, 1344, 1347, 1348, 1349, 1350, - /* 370 */ 1351, 1324, 1354, 1366, 1369, 1371, 1372, 1373, 1352, 1375, - /* 380 */ 1376, 1377, 1382, 1383, 1385, 1346, 1359, 1356, 1381, 1355, - /* 390 */ 1384, 1360, 1402, 1365, 1368, 1407, 1408, 1409, 1379, 1410, - /* 400 */ 1412, 1380, 1413, 1361, 1419, 1421, 1378, 1389, 1386, 1422, - /* 410 */ 1394, 1398, 1390, 1426, 1400, 1411, 1392, 1430, 1414, 1415, - /* 420 */ 1396, 1457, 1459, 1462, 1463, 1391, 1395, 1418, 1447, 1467, - /* 430 */ 1427, 1435, 1437, 1439, 1431, 1432, 1440, 1449, 1450, 1498, - /* 440 */ 1477, 1501, 1481, 1456, 1506, 1485, 1464, 1509, 1488, 1513, - /* 450 */ 1492, 1495, 1518, 1374, 1472, 1521, 1362, 1500, 1399, 1387, - /* 460 */ 1524, 1526, 1527, 1448, 1491, 1393, 1490, 1494, 1330, 1460, - /* 470 */ 1505, 1465, 1451, 1468, 1469, 1466, 1511, 1510, 1514, 1474, - /* 480 */ 1512, 1363, 1475, 1478, 1517, 1357, 1522, 1520, 1480, 1533, - /* 490 */ 1364, 1497, 1528, 1529, 1534, 1535, 1536, 1537, 1497, 1578, - /* 500 */ 1405, 1545, 1507, 1523, 1530, 1543, 1525, 1532, 1544, 1570, - /* 510 */ 1420, 1538, 1540, 1542, 1539, 1546, 1461, 1547, 1603, 1572, - /* 520 */ 1473, 1549, 1519, 1564, 1574, 1551, 1553, 1555, 1593, 1558, - /* 530 */ 1531, 1567, 1569, 1579, 1559, 1568, 1605, 1573, 1575, 1606, - /* 540 */ 1577, 1580, 1608, 1582, 1583, 1609, 1585, 1556, 1565, 1581, - /* 550 */ 1584, 1638, 1576, 1599, 1601, 1617, 1602, 1586, 1637, 1663, - /* 560 */ 1566, 1629, 1643, 1627, 1613, 1652, 1647, 1648, 1649, 1650, - /* 570 */ 1662, 1677, 1664, 1665, 1646, 1431, 1666, 1432, 1667, 1670, - /* 580 */ 1671, 1672, 1673, 1674, 1722, 1676, 1681, 1690, 1728, 1683, - /* 590 */ 1686, 1695, 1733, 1688, 1692, 1702, 1740, 1694, 1697, 1706, - /* 600 */ 1744, 1698, 1701, 1748, 1757, 1745, 1747, 1749, 1751, 1753, - /* 610 */ 1746, + /* 0 */ 687, 0, 0, 48, 96, 96, 96, 96, 283, 283, + /* 10 */ 96, 96, 331, 379, 566, 379, 379, 379, 379, 379, + /* 20 */ 379, 379, 379, 379, 379, 379, 379, 379, 379, 379, + /* 30 */ 379, 379, 379, 379, 379, 379, 379, 379, 281, 281, + /* 40 */ 26, 26, 26, 1941, 1941, 1941, 1941, 328, 64, 191, + /* 50 */ 39, 39, 14, 14, 146, 191, 191, 39, 39, 39, + /* 60 */ 39, 39, 39, 108, 39, 163, 229, 485, 163, 39, + /* 70 */ 39, 163, 39, 163, 163, 485, 163, 39, 667, 562, + /* 80 */ 62, 762, 762, 188, 266, 823, 823, 823, 823, 823, + /* 90 */ 823, 823, 823, 823, 823, 823, 823, 823, 823, 823, + /* 100 */ 823, 823, 823, 823, 213, 376, 332, 332, 42, 544, + /* 110 */ 517, 517, 517, 311, 544, 630, 485, 163, 163, 485, + /* 120 */ 616, 665, 446, 446, 446, 446, 446, 446, 446, 1234, + /* 130 */ 427, 435, 471, 200, 36, 223, 119, 597, 592, 327, + /* 140 */ 707, 715, 576, 464, 576, 587, 587, 587, 202, 729, + /* 150 */ 1019, 996, 998, 889, 1019, 1019, 1016, 928, 928, 1019, + /* 160 */ 1058, 1058, 1061, 108, 485, 108, 1064, 1078, 108, 1064, + /* 170 */ 108, 630, 1088, 108, 108, 1019, 108, 1058, 163, 163, + /* 180 */ 163, 163, 163, 163, 163, 163, 163, 163, 163, 1019, + /* 190 */ 1058, 1070, 1061, 667, 984, 485, 667, 1064, 667, 630, + /* 200 */ 1088, 667, 1144, 948, 950, 1070, 948, 950, 1070, 1070, + /* 210 */ 163, 946, 1048, 986, 990, 995, 630, 1187, 1169, 994, + /* 220 */ 988, 993, 994, 988, 994, 988, 1132, 950, 1070, 1070, + /* 230 */ 950, 1070, 1108, 630, 1088, 667, 616, 667, 630, 1181, + /* 240 */ 665, 1019, 667, 1058, 2136, 2136, 2136, 2136, 2136, 2136, + /* 250 */ 2136, 2136, 247, 573, 614, 1106, 488, 741, 18, 13, + /* 260 */ 581, 238, 520, 243, 244, 244, 244, 244, 244, 244, + /* 270 */ 244, 244, 477, 148, 59, 5, 583, 230, 697, 697, + /* 280 */ 697, 697, 792, 833, 654, 743, 795, 808, 444, 829, + /* 290 */ 917, 902, 656, 745, 890, 901, 903, 926, 733, 489, + /* 300 */ 704, 910, 813, 911, 899, 914, 915, 916, 918, 919, + /* 310 */ 888, 898, 945, 954, 962, 968, 970, 981, 804, 967, + /* 320 */ 1298, 1300, 1229, 1302, 1256, 1127, 1258, 1259, 1260, 1131, + /* 330 */ 1310, 1265, 1268, 1141, 1319, 1273, 1321, 1275, 1323, 1277, + /* 340 */ 1325, 1245, 1164, 1166, 1215, 1172, 1332, 1341, 1188, 1190, + /* 350 */ 1342, 1345, 1304, 1346, 1349, 1350, 1352, 1353, 1354, 1355, + /* 360 */ 1356, 1358, 1360, 1362, 1363, 1364, 1365, 1366, 1367, 1369, + /* 370 */ 1370, 1331, 1372, 1373, 1374, 1375, 1377, 1380, 1368, 1389, + /* 380 */ 1391, 1392, 1393, 1394, 1400, 1357, 1361, 1371, 1388, 1359, + /* 390 */ 1396, 1376, 1406, 1378, 1386, 1407, 1408, 1411, 1387, 1267, + /* 400 */ 1413, 1417, 1390, 1425, 1385, 1428, 1446, 1401, 1402, 1412, + /* 410 */ 1451, 1405, 1409, 1416, 1455, 1410, 1414, 1419, 1460, 1415, + /* 420 */ 1418, 1424, 1464, 1466, 1467, 1469, 1381, 1398, 1429, 1453, + /* 430 */ 1477, 1431, 1432, 1433, 1434, 1441, 1443, 1444, 1456, 1458, + /* 440 */ 1488, 1478, 1502, 1495, 1470, 1515, 1497, 1475, 1524, 1504, + /* 450 */ 1527, 1506, 1509, 1530, 1403, 1485, 1533, 1384, 1512, 1404, + /* 460 */ 1395, 1536, 1539, 1546, 1473, 1514, 1422, 1523, 1525, 1379, + /* 470 */ 1483, 1526, 1486, 1489, 1491, 1492, 1487, 1535, 1534, 1537, + /* 480 */ 1498, 1542, 1399, 1500, 1503, 1540, 1420, 1545, 1543, 1507, + /* 490 */ 1547, 1421, 1508, 1544, 1554, 1556, 1557, 1559, 1560, 1508, + /* 500 */ 1572, 1427, 1552, 1528, 1499, 1529, 1565, 1531, 1538, 1571, + /* 510 */ 1594, 1435, 1549, 1550, 1551, 1558, 1561, 1476, 1562, 1617, + /* 520 */ 1584, 1481, 1564, 1555, 1580, 1582, 1574, 1575, 1577, 1609, + /* 530 */ 1578, 1568, 1581, 1587, 1588, 1583, 1585, 1590, 1589, 1592, + /* 540 */ 1591, 1596, 1597, 1615, 1599, 1600, 1618, 1602, 1567, 1573, + /* 550 */ 1576, 1579, 1619, 1563, 1604, 1607, 1622, 1608, 1610, 1640, + /* 560 */ 1644, 1569, 1633, 1646, 1630, 1624, 1663, 1658, 1659, 1661, + /* 570 */ 1671, 1673, 1694, 1674, 1675, 1662, 1441, 1678, 1443, 1681, + /* 580 */ 1682, 1683, 1684, 1685, 1686, 1734, 1688, 1692, 1701, 1739, + /* 590 */ 1695, 1696, 1712, 1751, 1705, 1708, 1717, 1765, 1709, 1713, + /* 600 */ 1720, 1759, 1714, 1716, 1760, 1766, 1745, 1747, 1748, 1749, + /* 610 */ 1753, 1755, }; #define YY_REDUCE_COUNT (251) -#define YY_REDUCE_MIN (-320) -#define YY_REDUCE_MAX (1796) +#define YY_REDUCE_MIN (-314) +#define YY_REDUCE_MAX (1756) static const short yy_reduce_ofst[] = { - /* 0 */ 259, -226, 236, 61, 577, 638, 671, 752, 784, 835, - /* 10 */ 29, 850, 901, 953, 736, 962, 1010, 1042, 1074, 1122, - /* 20 */ 1135, 1175, 1223, 1280, 1328, 1358, 1388, 1436, 1445, 1493, - /* 30 */ 1541, 1552, 1571, 1630, 1639, 1699, 1708, 1756, 1760, 1796, - /* 40 */ -20, 261, 269, -272, 207, 204, 298, 182, 449, 512, - /* 50 */ -244, -164, -246, -241, -320, -178, -76, -196, 55, 59, - /* 60 */ 132, 239, 419, -222, 422, -227, -256, -139, -1, 534, - /* 70 */ 535, 84, 537, 310, 102, 179, 448, 568, 343, -75, - /* 80 */ -315, -315, -315, -228, -49, 60, 90, 123, 194, 213, - /* 90 */ 219, 235, 317, 380, 472, 507, 559, 565, 566, 567, - /* 100 */ 569, 572, 576, 579, -154, -152, -216, -68, 33, 138, - /* 110 */ 75, 406, 414, -3, 176, -127, 250, 88, 439, 325, - /* 120 */ 202, 111, 302, 526, 555, 578, 583, 612, 631, 605, - /* 130 */ 663, 653, 571, 574, 628, 592, 666, 666, 689, 690, - /* 140 */ 662, 647, 635, 635, 635, 629, 637, 650, 665, 666, - /* 150 */ 751, 703, 757, 717, 771, 774, 735, 743, 745, 782, - /* 160 */ 791, 794, 737, 789, 759, 806, 777, 776, 827, 787, - /* 170 */ 830, 808, 798, 834, 836, 842, 840, 851, 832, 837, - /* 180 */ 838, 839, 841, 844, 845, 846, 847, 848, 849, 855, - /* 190 */ 866, 820, 817, 872, 822, 852, 874, 833, 878, 856, - /* 200 */ 843, 884, 859, 797, 853, 865, 810, 875, 882, 883, - /* 210 */ 666, 811, 816, 860, 870, 635, 905, 877, 876, 858, - /* 220 */ 871, 829, 873, 885, 889, 894, 903, 908, 902, 904, - /* 230 */ 910, 906, 917, 947, 919, 977, 964, 981, 958, 972, - /* 240 */ 982, 986, 985, 995, 943, 944, 959, 984, 989, 991, - /* 250 */ 1005, 1019, + /* 0 */ 33, -226, 494, 90, 593, 344, 661, 744, 776, 806, + /* 10 */ 864, 904, -147, 923, 955, 1020, 1068, 1116, 1125, 1179, + /* 20 */ 1194, 1227, 1242, 1282, 1334, 1382, 1397, 1430, 1484, 1493, + /* 30 */ 1541, 1553, 1593, 1606, 1654, 1669, 1702, 1756, 545, 674, + /* 40 */ -196, 398, 556, -272, -270, -238, -162, 428, 38, 76, + /* 50 */ -164, 459, -241, -205, -287, -229, 24, -101, 92, 252, + /* 60 */ 357, 370, 457, 73, 519, -269, -115, -170, 102, 539, + /* 70 */ 540, 228, 553, 170, 338, 270, 508, 580, 402, 420, + /* 80 */ -314, -314, -314, -193, -103, -227, -67, -22, 123, 168, + /* 90 */ 204, 319, 386, 440, 501, 503, 523, 548, 554, 582, + /* 100 */ 606, 612, 625, 626, -246, -172, 29, 199, -54, 130, + /* 110 */ -207, -194, -37, 236, 205, 212, 141, 395, 629, 310, + /* 120 */ 439, 511, -253, 527, 604, 666, 675, 676, 677, -303, + /* 130 */ 689, 686, 599, 668, 709, 673, 749, 749, 772, 773, + /* 140 */ 746, 713, 692, 692, 692, 679, 681, 682, 698, 749, + /* 150 */ 790, 734, 786, 747, 801, 803, 779, 785, 789, 826, + /* 160 */ 834, 835, 778, 832, 799, 842, 805, 800, 846, 807, + /* 170 */ 848, 827, 819, 856, 857, 863, 859, 872, 847, 858, + /* 180 */ 860, 862, 865, 866, 867, 869, 870, 871, 873, 877, + /* 190 */ 885, 853, 843, 896, 850, 874, 906, 855, 907, 876, + /* 200 */ 875, 920, 878, 820, 882, 879, 821, 891, 895, 908, + /* 210 */ 749, 849, 854, 861, 868, 692, 927, 897, 881, 880, + /* 220 */ 892, 887, 894, 900, 905, 912, 924, 934, 936, 937, + /* 230 */ 951, 949, 961, 976, 966, 1004, 991, 1006, 982, 989, + /* 240 */ 1013, 1026, 1024, 1037, 992, 978, 997, 1025, 1027, 1028, + /* 250 */ 1042, 1056, }; static const YYACTIONTYPE yy_default[] = { - /* 0 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 10 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 20 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 30 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 40 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 50 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 60 */ 1356, 1356, 1356, 1425, 1356, 1356, 1356, 1356, 1356, 1356, - /* 70 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1423, 1564, - /* 80 */ 1356, 1731, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 90 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 100 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1425, 1356, - /* 110 */ 1742, 1742, 1742, 1423, 1356, 1356, 1356, 1356, 1356, 1356, - /* 120 */ 1519, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1603, - /* 130 */ 1356, 1356, 1808, 1356, 1609, 1766, 1356, 1356, 1356, 1356, - /* 140 */ 1472, 1758, 1734, 1748, 1735, 1793, 1793, 1793, 1751, 1356, - /* 150 */ 1356, 1356, 1356, 1595, 1356, 1356, 1569, 1566, 1566, 1356, - /* 160 */ 1356, 1356, 1356, 1425, 1356, 1425, 1356, 1356, 1425, 1356, - /* 170 */ 1425, 1356, 1356, 1425, 1425, 1356, 1425, 1356, 1356, 1356, - /* 180 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 190 */ 1356, 1356, 1356, 1423, 1605, 1356, 1423, 1356, 1423, 1356, - /* 200 */ 1356, 1423, 1356, 1773, 1771, 1356, 1773, 1771, 1356, 1356, - /* 210 */ 1356, 1785, 1781, 1764, 1762, 1748, 1356, 1356, 1356, 1799, - /* 220 */ 1795, 1811, 1799, 1795, 1799, 1795, 1356, 1771, 1356, 1356, - /* 230 */ 1771, 1356, 1577, 1356, 1356, 1423, 1356, 1423, 1356, 1488, - /* 240 */ 1356, 1356, 1423, 1356, 1597, 1611, 1587, 1522, 1522, 1522, - /* 250 */ 1426, 1361, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 260 */ 1356, 1356, 1356, 1484, 1675, 1784, 1783, 1707, 1706, 1705, - /* 270 */ 1703, 1674, 1356, 1356, 1356, 1356, 1356, 1356, 1668, 1669, - /* 280 */ 1667, 1666, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 290 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1732, 1356, 1796, - /* 300 */ 1800, 1356, 1356, 1356, 1651, 1356, 1356, 1356, 1356, 1356, - /* 310 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 320 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 330 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 340 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 350 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 360 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 370 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 380 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1390, 1356, 1356, - /* 390 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 400 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 410 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 420 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 430 */ 1356, 1356, 1356, 1356, 1453, 1452, 1356, 1356, 1356, 1356, - /* 440 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 450 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 460 */ 1356, 1356, 1356, 1356, 1356, 1356, 1755, 1765, 1356, 1356, - /* 470 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1651, 1356, - /* 480 */ 1782, 1356, 1741, 1737, 1356, 1356, 1733, 1356, 1356, 1794, - /* 490 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1727, - /* 500 */ 1356, 1700, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 510 */ 1662, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 520 */ 1356, 1356, 1356, 1650, 1356, 1691, 1356, 1356, 1356, 1356, - /* 530 */ 1356, 1356, 1356, 1356, 1516, 1356, 1356, 1356, 1356, 1356, - /* 540 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1501, 1499, 1498, - /* 550 */ 1497, 1356, 1494, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 560 */ 1356, 1356, 1356, 1356, 1356, 1445, 1356, 1356, 1356, 1356, - /* 570 */ 1356, 1356, 1356, 1356, 1356, 1436, 1356, 1435, 1356, 1356, - /* 580 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 590 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 600 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, - /* 610 */ 1356, + /* 0 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 10 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 20 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 30 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 40 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 50 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 60 */ 1357, 1357, 1357, 1426, 1357, 1357, 1357, 1357, 1357, 1357, + /* 70 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1424, 1565, + /* 80 */ 1357, 1732, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 90 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 100 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1426, 1357, + /* 110 */ 1743, 1743, 1743, 1424, 1357, 1357, 1357, 1357, 1357, 1357, + /* 120 */ 1520, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1604, + /* 130 */ 1357, 1357, 1809, 1357, 1610, 1767, 1357, 1357, 1357, 1357, + /* 140 */ 1473, 1759, 1735, 1749, 1736, 1794, 1794, 1794, 1752, 1357, + /* 150 */ 1357, 1357, 1357, 1596, 1357, 1357, 1570, 1567, 1567, 1357, + /* 160 */ 1357, 1357, 1357, 1426, 1357, 1426, 1357, 1357, 1426, 1357, + /* 170 */ 1426, 1357, 1357, 1426, 1426, 1357, 1426, 1357, 1357, 1357, + /* 180 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 190 */ 1357, 1357, 1357, 1424, 1606, 1357, 1424, 1357, 1424, 1357, + /* 200 */ 1357, 1424, 1357, 1774, 1772, 1357, 1774, 1772, 1357, 1357, + /* 210 */ 1357, 1786, 1782, 1765, 1763, 1749, 1357, 1357, 1357, 1800, + /* 220 */ 1796, 1812, 1800, 1796, 1800, 1796, 1357, 1772, 1357, 1357, + /* 230 */ 1772, 1357, 1578, 1357, 1357, 1424, 1357, 1424, 1357, 1489, + /* 240 */ 1357, 1357, 1424, 1357, 1598, 1612, 1588, 1523, 1523, 1523, + /* 250 */ 1427, 1362, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 260 */ 1357, 1357, 1357, 1485, 1676, 1785, 1784, 1708, 1707, 1706, + /* 270 */ 1704, 1675, 1357, 1357, 1357, 1357, 1357, 1357, 1669, 1670, + /* 280 */ 1668, 1667, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 290 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1733, 1357, 1797, + /* 300 */ 1801, 1357, 1357, 1357, 1652, 1357, 1357, 1357, 1357, 1357, + /* 310 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 320 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 330 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 340 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 350 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 360 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 370 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 380 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1391, 1357, 1357, + /* 390 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 400 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 410 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 420 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 430 */ 1357, 1357, 1357, 1357, 1357, 1454, 1453, 1357, 1357, 1357, + /* 440 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 450 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 460 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1756, 1766, 1357, + /* 470 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1652, + /* 480 */ 1357, 1783, 1357, 1742, 1738, 1357, 1357, 1734, 1357, 1357, + /* 490 */ 1795, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 500 */ 1728, 1357, 1701, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 510 */ 1357, 1663, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 520 */ 1357, 1357, 1357, 1357, 1651, 1357, 1692, 1357, 1357, 1357, + /* 530 */ 1357, 1357, 1357, 1357, 1357, 1517, 1357, 1357, 1357, 1357, + /* 540 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1502, 1500, + /* 550 */ 1499, 1498, 1357, 1495, 1357, 1357, 1357, 1357, 1357, 1357, + /* 560 */ 1357, 1357, 1357, 1357, 1357, 1357, 1446, 1357, 1357, 1357, + /* 570 */ 1357, 1357, 1357, 1357, 1357, 1357, 1437, 1357, 1436, 1357, + /* 580 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 590 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 600 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, + /* 610 */ 1357, 1357, }; /********** End of lemon-generated parsing tables *****************************/ @@ -975,7 +977,8 @@ static const YYCODETYPE yyFallback[] = { 0, /* INTERVAL => nothing */ 0, /* TOPIC => nothing */ 0, /* AS => nothing */ - 0, /* CGROUP => nothing */ + 0, /* CONSUMER => nothing */ + 0, /* GROUP => nothing */ 0, /* WITH => nothing */ 0, /* SCHEMA => nothing */ 0, /* DESC => nothing */ @@ -1052,7 +1055,6 @@ static const YYCODETYPE yyFallback[] = { 0, /* PREV => nothing */ 0, /* LINEAR => nothing */ 0, /* NEXT => nothing */ - 0, /* GROUP => nothing */ 0, /* HAVING => nothing */ 0, /* ORDER => nothing */ 0, /* SLIMIT => nothing */ @@ -1302,84 +1304,84 @@ static const char *const yyTokenName[] = { /* 144 */ "INTERVAL", /* 145 */ "TOPIC", /* 146 */ "AS", - /* 147 */ "CGROUP", - /* 148 */ "WITH", - /* 149 */ "SCHEMA", - /* 150 */ "DESC", - /* 151 */ "DESCRIBE", - /* 152 */ "RESET", - /* 153 */ "QUERY", - /* 154 */ "CACHE", - /* 155 */ "EXPLAIN", - /* 156 */ "ANALYZE", - /* 157 */ "VERBOSE", - /* 158 */ "NK_BOOL", - /* 159 */ "RATIO", - /* 160 */ "COMPACT", - /* 161 */ "VNODES", - /* 162 */ "IN", - /* 163 */ "OUTPUTTYPE", - /* 164 */ "AGGREGATE", - /* 165 */ "BUFSIZE", - /* 166 */ "STREAM", - /* 167 */ "INTO", - /* 168 */ "TRIGGER", - /* 169 */ "AT_ONCE", - /* 170 */ "WINDOW_CLOSE", - /* 171 */ "WATERMARK", - /* 172 */ "KILL", - /* 173 */ "CONNECTION", - /* 174 */ "TRANSACTION", - /* 175 */ "MERGE", - /* 176 */ "VGROUP", - /* 177 */ "REDISTRIBUTE", - /* 178 */ "SPLIT", - /* 179 */ "SYNCDB", - /* 180 */ "NULL", - /* 181 */ "NK_QUESTION", - /* 182 */ "NK_ARROW", - /* 183 */ "ROWTS", - /* 184 */ "TBNAME", - /* 185 */ "QSTARTTS", - /* 186 */ "QENDTS", - /* 187 */ "WSTARTTS", - /* 188 */ "WENDTS", - /* 189 */ "WDURATION", - /* 190 */ "CAST", - /* 191 */ "NOW", - /* 192 */ "TODAY", - /* 193 */ "TIMEZONE", - /* 194 */ "COUNT", - /* 195 */ "FIRST", - /* 196 */ "LAST", - /* 197 */ "LAST_ROW", - /* 198 */ "BETWEEN", - /* 199 */ "IS", - /* 200 */ "NK_LT", - /* 201 */ "NK_GT", - /* 202 */ "NK_LE", - /* 203 */ "NK_GE", - /* 204 */ "NK_NE", - /* 205 */ "MATCH", - /* 206 */ "NMATCH", - /* 207 */ "CONTAINS", - /* 208 */ "JOIN", - /* 209 */ "INNER", - /* 210 */ "SELECT", - /* 211 */ "DISTINCT", - /* 212 */ "WHERE", - /* 213 */ "PARTITION", - /* 214 */ "BY", - /* 215 */ "SESSION", - /* 216 */ "STATE_WINDOW", - /* 217 */ "SLIDING", - /* 218 */ "FILL", - /* 219 */ "VALUE", - /* 220 */ "NONE", - /* 221 */ "PREV", - /* 222 */ "LINEAR", - /* 223 */ "NEXT", - /* 224 */ "GROUP", + /* 147 */ "CONSUMER", + /* 148 */ "GROUP", + /* 149 */ "WITH", + /* 150 */ "SCHEMA", + /* 151 */ "DESC", + /* 152 */ "DESCRIBE", + /* 153 */ "RESET", + /* 154 */ "QUERY", + /* 155 */ "CACHE", + /* 156 */ "EXPLAIN", + /* 157 */ "ANALYZE", + /* 158 */ "VERBOSE", + /* 159 */ "NK_BOOL", + /* 160 */ "RATIO", + /* 161 */ "COMPACT", + /* 162 */ "VNODES", + /* 163 */ "IN", + /* 164 */ "OUTPUTTYPE", + /* 165 */ "AGGREGATE", + /* 166 */ "BUFSIZE", + /* 167 */ "STREAM", + /* 168 */ "INTO", + /* 169 */ "TRIGGER", + /* 170 */ "AT_ONCE", + /* 171 */ "WINDOW_CLOSE", + /* 172 */ "WATERMARK", + /* 173 */ "KILL", + /* 174 */ "CONNECTION", + /* 175 */ "TRANSACTION", + /* 176 */ "MERGE", + /* 177 */ "VGROUP", + /* 178 */ "REDISTRIBUTE", + /* 179 */ "SPLIT", + /* 180 */ "SYNCDB", + /* 181 */ "NULL", + /* 182 */ "NK_QUESTION", + /* 183 */ "NK_ARROW", + /* 184 */ "ROWTS", + /* 185 */ "TBNAME", + /* 186 */ "QSTARTTS", + /* 187 */ "QENDTS", + /* 188 */ "WSTARTTS", + /* 189 */ "WENDTS", + /* 190 */ "WDURATION", + /* 191 */ "CAST", + /* 192 */ "NOW", + /* 193 */ "TODAY", + /* 194 */ "TIMEZONE", + /* 195 */ "COUNT", + /* 196 */ "FIRST", + /* 197 */ "LAST", + /* 198 */ "LAST_ROW", + /* 199 */ "BETWEEN", + /* 200 */ "IS", + /* 201 */ "NK_LT", + /* 202 */ "NK_GT", + /* 203 */ "NK_LE", + /* 204 */ "NK_GE", + /* 205 */ "NK_NE", + /* 206 */ "MATCH", + /* 207 */ "NMATCH", + /* 208 */ "CONTAINS", + /* 209 */ "JOIN", + /* 210 */ "INNER", + /* 211 */ "SELECT", + /* 212 */ "DISTINCT", + /* 213 */ "WHERE", + /* 214 */ "PARTITION", + /* 215 */ "BY", + /* 216 */ "SESSION", + /* 217 */ "STATE_WINDOW", + /* 218 */ "SLIDING", + /* 219 */ "FILL", + /* 220 */ "VALUE", + /* 221 */ "NONE", + /* 222 */ "PREV", + /* 223 */ "LINEAR", + /* 224 */ "NEXT", /* 225 */ "HAVING", /* 226 */ "ORDER", /* 227 */ "SLIMIT", @@ -1750,7 +1752,7 @@ static const char *const yyRuleName[] = { /* 224 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS query_expression", /* 225 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS db_name", /* 226 */ "cmd ::= DROP TOPIC exists_opt topic_name", - /* 227 */ "cmd ::= DROP CGROUP exists_opt cgroup_name ON topic_name", + /* 227 */ "cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name", /* 228 */ "topic_options ::=", /* 229 */ "topic_options ::= topic_options WITH TABLE", /* 230 */ "topic_options ::= topic_options WITH SCHEMA", @@ -2798,7 +2800,7 @@ static const struct { { 240, -7 }, /* (224) cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS query_expression */ { 240, -7 }, /* (225) cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS db_name */ { 240, -4 }, /* (226) cmd ::= DROP TOPIC exists_opt topic_name */ - { 240, -6 }, /* (227) cmd ::= DROP CGROUP exists_opt cgroup_name ON topic_name */ + { 240, -7 }, /* (227) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ { 298, 0 }, /* (228) topic_options ::= */ { 298, -3 }, /* (229) topic_options ::= topic_options WITH TABLE */ { 298, -3 }, /* (230) topic_options ::= topic_options WITH SCHEMA */ @@ -3827,7 +3829,7 @@ static YYACTIONTYPE yy_reduce( case 226: /* cmd ::= DROP TOPIC exists_opt topic_name */ { pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy603, &yymsp[0].minor.yy53); } break; - case 227: /* cmd ::= DROP CGROUP exists_opt cgroup_name ON topic_name */ + case 227: /* cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ { pCxt->pRootNode = createDropCGroupStmt(pCxt, yymsp[-3].minor.yy603, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy53); } break; case 228: /* topic_options ::= */ diff --git a/source/libs/parser/test/parInitialDTest.cpp b/source/libs/parser/test/parInitialDTest.cpp index 57d349e7ee..5ad427d964 100644 --- a/source/libs/parser/test/parInitialDTest.cpp +++ b/source/libs/parser/test/parInitialDTest.cpp @@ -32,7 +32,7 @@ TEST_F(ParserInitialDTest, dropBnode) { run("DROP BNODE ON DNODE 1"); } -// DROP CGROUP [ IF EXISTS ] cgroup_name ON topic_name +// DROP CONSUMER GROUP [ IF EXISTS ] cgroup_name ON topic_name TEST_F(ParserInitialDTest, dropCGroup) { useDb("root", "test"); @@ -56,10 +56,10 @@ TEST_F(ParserInitialDTest, dropCGroup) { }); setDropCgroupReqFunc("tp1", "cg1"); - run("DROP CGROUP cg1 ON tp1"); + run("DROP CONSUMER GROUP cg1 ON tp1"); setDropCgroupReqFunc("tp1", "cg1", 1); - run("DROP CGROUP IF EXISTS cg1 ON tp1"); + run("DROP CONSUMER GROUP IF EXISTS cg1 ON tp1"); } // todo drop database diff --git a/source/libs/parser/test/parSelectTest.cpp b/source/libs/parser/test/parSelectTest.cpp index a675bb936f..a5192595f0 100644 --- a/source/libs/parser/test/parSelectTest.cpp +++ b/source/libs/parser/test/parSelectTest.cpp @@ -252,6 +252,8 @@ TEST_F(ParserSelectTest, semanticError) { // TSDB_CODE_PAR_AMBIGUOUS_COLUMN run("SELECT c2 FROM t1 tt1, t1 tt2 WHERE tt1.c1 = tt2.c1", TSDB_CODE_PAR_AMBIGUOUS_COLUMN, PARSER_STAGE_TRANSLATE); + run("SELECT c2 FROM (SELECT c1 c2, c2 FROM t1)", TSDB_CODE_PAR_AMBIGUOUS_COLUMN, PARSER_STAGE_TRANSLATE); + // TSDB_CODE_PAR_WRONG_VALUE_TYPE run("SELECT timestamp '2010a' FROM t1", TSDB_CODE_PAR_WRONG_VALUE_TYPE, PARSER_STAGE_TRANSLATE); diff --git a/source/libs/planner/src/planLogicCreater.c b/source/libs/planner/src/planLogicCreater.c index 467b26b7c4..2df248e53f 100644 --- a/source/libs/planner/src/planLogicCreater.c +++ b/source/libs/planner/src/planLogicCreater.c @@ -124,6 +124,7 @@ static int32_t createChildLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelec SLogicNode* pNode = NULL; int32_t code = func(pCxt, pSelect, &pNode); if (TSDB_CODE_SUCCESS == code && NULL != pNode) { + pNode->precision = pSelect->precision; code = pushLogicNode(pCxt, pRoot, pNode); } if (TSDB_CODE_SUCCESS != code) { @@ -400,6 +401,7 @@ static int32_t createLogicNodeByTable(SLogicPlanContext* pCxt, SSelectStmt* pSel nodesDestroyNode(pNode); return TSDB_CODE_OUT_OF_MEMORY; } + pNode->precision = pSelect->precision; *pLogicNode = pNode; } return code; From 9a6776c321eeb68f4c6f9ee9359e337bfa9d2672 Mon Sep 17 00:00:00 2001 From: Xiaoyu Wang Date: Tue, 31 May 2022 15:11:26 +0800 Subject: [PATCH 07/28] fix: error in data precision of super table query --- include/libs/nodes/cmdnodes.h | 1 - include/util/tdef.h | 3 --- source/libs/parser/inc/parAst.h | 1 - source/libs/parser/inc/sql.y | 1 - source/libs/parser/src/parAstCreater.c | 5 ----- source/libs/parser/src/parTranslater.c | 6 +----- 6 files changed, 1 insertion(+), 16 deletions(-) diff --git a/include/libs/nodes/cmdnodes.h b/include/libs/nodes/cmdnodes.h index 7bd3a40c71..0bd6d73ce1 100644 --- a/include/libs/nodes/cmdnodes.h +++ b/include/libs/nodes/cmdnodes.h @@ -80,7 +80,6 @@ typedef struct SAlterDatabaseStmt { typedef struct STableOptions { ENodeType type; char comment[TSDB_TB_COMMENT_LEN]; - int32_t delay; float filesFactor; SNodeList* pRollupFuncs; int32_t ttl; diff --git a/include/util/tdef.h b/include/util/tdef.h index 7c1f46ce69..1e1770d1b9 100644 --- a/include/util/tdef.h +++ b/include/util/tdef.h @@ -344,9 +344,6 @@ typedef enum ELogicConditionType { #define TSDB_MIN_ROLLUP_FILE_FACTOR 0 #define TSDB_MAX_ROLLUP_FILE_FACTOR 1 #define TSDB_DEFAULT_ROLLUP_FILE_FACTOR 0.1 -#define TSDB_MIN_ROLLUP_DELAY 1 -#define TSDB_MAX_ROLLUP_DELAY 10 -#define TSDB_DEFAULT_ROLLUP_DELAY 2 #define TSDB_MIN_TABLE_TTL 0 #define TSDB_DEFAULT_TABLE_TTL 0 diff --git a/source/libs/parser/inc/parAst.h b/source/libs/parser/inc/parAst.h index a1c304118b..9c9aa5ccb9 100644 --- a/source/libs/parser/inc/parAst.h +++ b/source/libs/parser/inc/parAst.h @@ -59,7 +59,6 @@ typedef enum EDatabaseOptionType { typedef enum ETableOptionType { TABLE_OPTION_COMMENT = 1, - TABLE_OPTION_DELAY, TABLE_OPTION_FILE_FACTOR, TABLE_OPTION_ROLLUP, TABLE_OPTION_TTL, diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y index f45f10f3b9..ec5a9c26d4 100644 --- a/source/libs/parser/inc/sql.y +++ b/source/libs/parser/inc/sql.y @@ -313,7 +313,6 @@ tags_def(A) ::= TAGS NK_LP column_def_list(B) NK_RP. table_options(A) ::= . { A = createDefaultTableOptions(pCxt); } table_options(A) ::= table_options(B) COMMENT NK_STRING(C). { A = setTableOption(pCxt, B, TABLE_OPTION_COMMENT, &C); } -table_options(A) ::= table_options(B) DELAY NK_INTEGER(C). { A = setTableOption(pCxt, B, TABLE_OPTION_DELAY, &C); } table_options(A) ::= table_options(B) FILE_FACTOR NK_FLOAT(C). { A = setTableOption(pCxt, B, TABLE_OPTION_FILE_FACTOR, &C); } table_options(A) ::= table_options(B) ROLLUP NK_LP func_name_list(C) NK_RP. { A = setTableOption(pCxt, B, TABLE_OPTION_ROLLUP, C); } table_options(A) ::= table_options(B) TTL NK_INTEGER(C). { A = setTableOption(pCxt, B, TABLE_OPTION_TTL, &C); } diff --git a/source/libs/parser/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c index 836a0cb520..4380e28727 100644 --- a/source/libs/parser/src/parAstCreater.c +++ b/source/libs/parser/src/parAstCreater.c @@ -857,7 +857,6 @@ SNode* createDefaultTableOptions(SAstCreateContext* pCxt) { CHECK_PARSER_STATUS(pCxt); STableOptions* pOptions = nodesMakeNode(QUERY_NODE_TABLE_OPTIONS); CHECK_OUT_OF_MEM(pOptions); - pOptions->delay = TSDB_DEFAULT_ROLLUP_DELAY; pOptions->filesFactor = TSDB_DEFAULT_ROLLUP_FILE_FACTOR; pOptions->ttl = TSDB_DEFAULT_TABLE_TTL; return (SNode*)pOptions; @@ -867,7 +866,6 @@ SNode* createAlterTableOptions(SAstCreateContext* pCxt) { CHECK_PARSER_STATUS(pCxt); STableOptions* pOptions = nodesMakeNode(QUERY_NODE_TABLE_OPTIONS); CHECK_OUT_OF_MEM(pOptions); - pOptions->delay = -1; pOptions->filesFactor = -1; pOptions->ttl = -1; return (SNode*)pOptions; @@ -882,9 +880,6 @@ SNode* setTableOption(SAstCreateContext* pCxt, SNode* pOptions, ETableOptionType sizeof(((STableOptions*)pOptions)->comment)); } break; - case TABLE_OPTION_DELAY: - ((STableOptions*)pOptions)->delay = taosStr2Int32(((SToken*)pVal)->z, NULL, 10); - break; case TABLE_OPTION_FILE_FACTOR: ((STableOptions*)pOptions)->filesFactor = taosStr2Float(((SToken*)pVal)->z, NULL); break; diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index 1fded1e4d5..0dda71023f 100644 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -2633,10 +2633,7 @@ static int32_t checkTableSchema(STranslateContext* pCxt, SCreateTableStmt* pStmt } static int32_t checkCreateTable(STranslateContext* pCxt, SCreateTableStmt* pStmt) { - int32_t code = checkRangeOption(pCxt, "delay", pStmt->pOptions->delay, TSDB_MIN_ROLLUP_DELAY, TSDB_MAX_ROLLUP_DELAY); - if (TSDB_CODE_SUCCESS == code) { - code = checTableFactorOption(pCxt, pStmt->pOptions->filesFactor); - } + int32_t code = checTableFactorOption(pCxt, pStmt->pOptions->filesFactor); if (TSDB_CODE_SUCCESS == code) { code = checkTableRollupOption(pCxt, pStmt->pOptions->pRollupFuncs); } @@ -2877,7 +2874,6 @@ static int32_t buildRollupAst(STranslateContext* pCxt, SCreateTableStmt* pStmt, static int32_t buildCreateStbReq(STranslateContext* pCxt, SCreateTableStmt* pStmt, SMCreateStbReq* pReq) { pReq->igExists = pStmt->ignoreExists; pReq->xFilesFactor = pStmt->pOptions->filesFactor; - pReq->delay = pStmt->pOptions->delay; pReq->ttl = pStmt->pOptions->ttl; columnDefNodeToField(pStmt->pCols, &pReq->pColumns); columnDefNodeToField(pStmt->pTags, &pReq->pTags); From 44b00ed346c4c8d2e687ca04046d9a58ff0ee3db Mon Sep 17 00:00:00 2001 From: Xiaoyu Wang Date: Tue, 31 May 2022 15:12:31 +0800 Subject: [PATCH 08/28] fix: error in data precision of super table query --- include/common/ttokendef.h | 255 +- source/libs/parser/src/parTokenizer.c | 1 - source/libs/parser/src/sql.c | 4970 +++++++++++++------------ 3 files changed, 2616 insertions(+), 2610 deletions(-) diff --git a/include/common/ttokendef.h b/include/common/ttokendef.h index 0e54f07991..a7a534533e 100644 --- a/include/common/ttokendef.h +++ b/include/common/ttokendef.h @@ -127,134 +127,133 @@ #define TK_BLOB 109 #define TK_VARBINARY 110 #define TK_DECIMAL 111 -#define TK_DELAY 112 -#define TK_FILE_FACTOR 113 -#define TK_NK_FLOAT 114 -#define TK_ROLLUP 115 -#define TK_TTL 116 -#define TK_SMA 117 -#define TK_SHOW 118 -#define TK_DATABASES 119 -#define TK_TABLES 120 -#define TK_STABLES 121 -#define TK_MNODES 122 -#define TK_MODULES 123 -#define TK_QNODES 124 -#define TK_FUNCTIONS 125 -#define TK_INDEXES 126 -#define TK_ACCOUNTS 127 -#define TK_APPS 128 -#define TK_CONNECTIONS 129 -#define TK_LICENCE 130 -#define TK_GRANTS 131 -#define TK_QUERIES 132 -#define TK_SCORES 133 -#define TK_TOPICS 134 -#define TK_VARIABLES 135 -#define TK_BNODES 136 -#define TK_SNODES 137 -#define TK_CLUSTER 138 -#define TK_TRANSACTIONS 139 -#define TK_LIKE 140 -#define TK_INDEX 141 -#define TK_FULLTEXT 142 -#define TK_FUNCTION 143 -#define TK_INTERVAL 144 -#define TK_TOPIC 145 -#define TK_AS 146 -#define TK_CONSUMER 147 -#define TK_GROUP 148 -#define TK_WITH 149 -#define TK_SCHEMA 150 -#define TK_DESC 151 -#define TK_DESCRIBE 152 -#define TK_RESET 153 -#define TK_QUERY 154 -#define TK_CACHE 155 -#define TK_EXPLAIN 156 -#define TK_ANALYZE 157 -#define TK_VERBOSE 158 -#define TK_NK_BOOL 159 -#define TK_RATIO 160 -#define TK_COMPACT 161 -#define TK_VNODES 162 -#define TK_IN 163 -#define TK_OUTPUTTYPE 164 -#define TK_AGGREGATE 165 -#define TK_BUFSIZE 166 -#define TK_STREAM 167 -#define TK_INTO 168 -#define TK_TRIGGER 169 -#define TK_AT_ONCE 170 -#define TK_WINDOW_CLOSE 171 -#define TK_WATERMARK 172 -#define TK_KILL 173 -#define TK_CONNECTION 174 -#define TK_TRANSACTION 175 -#define TK_MERGE 176 -#define TK_VGROUP 177 -#define TK_REDISTRIBUTE 178 -#define TK_SPLIT 179 -#define TK_SYNCDB 180 -#define TK_NULL 181 -#define TK_NK_QUESTION 182 -#define TK_NK_ARROW 183 -#define TK_ROWTS 184 -#define TK_TBNAME 185 -#define TK_QSTARTTS 186 -#define TK_QENDTS 187 -#define TK_WSTARTTS 188 -#define TK_WENDTS 189 -#define TK_WDURATION 190 -#define TK_CAST 191 -#define TK_NOW 192 -#define TK_TODAY 193 -#define TK_TIMEZONE 194 -#define TK_COUNT 195 -#define TK_FIRST 196 -#define TK_LAST 197 -#define TK_LAST_ROW 198 -#define TK_BETWEEN 199 -#define TK_IS 200 -#define TK_NK_LT 201 -#define TK_NK_GT 202 -#define TK_NK_LE 203 -#define TK_NK_GE 204 -#define TK_NK_NE 205 -#define TK_MATCH 206 -#define TK_NMATCH 207 -#define TK_CONTAINS 208 -#define TK_JOIN 209 -#define TK_INNER 210 -#define TK_SELECT 211 -#define TK_DISTINCT 212 -#define TK_WHERE 213 -#define TK_PARTITION 214 -#define TK_BY 215 -#define TK_SESSION 216 -#define TK_STATE_WINDOW 217 -#define TK_SLIDING 218 -#define TK_FILL 219 -#define TK_VALUE 220 -#define TK_NONE 221 -#define TK_PREV 222 -#define TK_LINEAR 223 -#define TK_NEXT 224 -#define TK_HAVING 225 -#define TK_ORDER 226 -#define TK_SLIMIT 227 -#define TK_SOFFSET 228 -#define TK_LIMIT 229 -#define TK_OFFSET 230 -#define TK_ASC 231 -#define TK_NULLS 232 -#define TK_ID 233 -#define TK_NK_BITNOT 234 -#define TK_INSERT 235 -#define TK_VALUES 236 -#define TK_IMPORT 237 -#define TK_NK_SEMI 238 -#define TK_FILE 239 +#define TK_FILE_FACTOR 112 +#define TK_NK_FLOAT 113 +#define TK_ROLLUP 114 +#define TK_TTL 115 +#define TK_SMA 116 +#define TK_SHOW 117 +#define TK_DATABASES 118 +#define TK_TABLES 119 +#define TK_STABLES 120 +#define TK_MNODES 121 +#define TK_MODULES 122 +#define TK_QNODES 123 +#define TK_FUNCTIONS 124 +#define TK_INDEXES 125 +#define TK_ACCOUNTS 126 +#define TK_APPS 127 +#define TK_CONNECTIONS 128 +#define TK_LICENCE 129 +#define TK_GRANTS 130 +#define TK_QUERIES 131 +#define TK_SCORES 132 +#define TK_TOPICS 133 +#define TK_VARIABLES 134 +#define TK_BNODES 135 +#define TK_SNODES 136 +#define TK_CLUSTER 137 +#define TK_TRANSACTIONS 138 +#define TK_LIKE 139 +#define TK_INDEX 140 +#define TK_FULLTEXT 141 +#define TK_FUNCTION 142 +#define TK_INTERVAL 143 +#define TK_TOPIC 144 +#define TK_AS 145 +#define TK_CONSUMER 146 +#define TK_GROUP 147 +#define TK_WITH 148 +#define TK_SCHEMA 149 +#define TK_DESC 150 +#define TK_DESCRIBE 151 +#define TK_RESET 152 +#define TK_QUERY 153 +#define TK_CACHE 154 +#define TK_EXPLAIN 155 +#define TK_ANALYZE 156 +#define TK_VERBOSE 157 +#define TK_NK_BOOL 158 +#define TK_RATIO 159 +#define TK_COMPACT 160 +#define TK_VNODES 161 +#define TK_IN 162 +#define TK_OUTPUTTYPE 163 +#define TK_AGGREGATE 164 +#define TK_BUFSIZE 165 +#define TK_STREAM 166 +#define TK_INTO 167 +#define TK_TRIGGER 168 +#define TK_AT_ONCE 169 +#define TK_WINDOW_CLOSE 170 +#define TK_WATERMARK 171 +#define TK_KILL 172 +#define TK_CONNECTION 173 +#define TK_TRANSACTION 174 +#define TK_MERGE 175 +#define TK_VGROUP 176 +#define TK_REDISTRIBUTE 177 +#define TK_SPLIT 178 +#define TK_SYNCDB 179 +#define TK_NULL 180 +#define TK_NK_QUESTION 181 +#define TK_NK_ARROW 182 +#define TK_ROWTS 183 +#define TK_TBNAME 184 +#define TK_QSTARTTS 185 +#define TK_QENDTS 186 +#define TK_WSTARTTS 187 +#define TK_WENDTS 188 +#define TK_WDURATION 189 +#define TK_CAST 190 +#define TK_NOW 191 +#define TK_TODAY 192 +#define TK_TIMEZONE 193 +#define TK_COUNT 194 +#define TK_FIRST 195 +#define TK_LAST 196 +#define TK_LAST_ROW 197 +#define TK_BETWEEN 198 +#define TK_IS 199 +#define TK_NK_LT 200 +#define TK_NK_GT 201 +#define TK_NK_LE 202 +#define TK_NK_GE 203 +#define TK_NK_NE 204 +#define TK_MATCH 205 +#define TK_NMATCH 206 +#define TK_CONTAINS 207 +#define TK_JOIN 208 +#define TK_INNER 209 +#define TK_SELECT 210 +#define TK_DISTINCT 211 +#define TK_WHERE 212 +#define TK_PARTITION 213 +#define TK_BY 214 +#define TK_SESSION 215 +#define TK_STATE_WINDOW 216 +#define TK_SLIDING 217 +#define TK_FILL 218 +#define TK_VALUE 219 +#define TK_NONE 220 +#define TK_PREV 221 +#define TK_LINEAR 222 +#define TK_NEXT 223 +#define TK_HAVING 224 +#define TK_ORDER 225 +#define TK_SLIMIT 226 +#define TK_SOFFSET 227 +#define TK_LIMIT 228 +#define TK_OFFSET 229 +#define TK_ASC 230 +#define TK_NULLS 231 +#define TK_ID 232 +#define TK_NK_BITNOT 233 +#define TK_INSERT 234 +#define TK_VALUES 235 +#define TK_IMPORT 236 +#define TK_NK_SEMI 237 +#define TK_FILE 238 #define TK_NK_SPACE 300 #define TK_NK_COMMENT 301 diff --git a/source/libs/parser/src/parTokenizer.c b/source/libs/parser/src/parTokenizer.c index 47edd3e5a8..5f478532b9 100644 --- a/source/libs/parser/src/parTokenizer.c +++ b/source/libs/parser/src/parTokenizer.c @@ -68,7 +68,6 @@ static SKeyword keywordTable[] = { {"DATABASES", TK_DATABASES}, {"DAYS", TK_DAYS}, {"DBS", TK_DBS}, - {"DELAY", TK_DELAY}, {"DESC", TK_DESC}, {"DESCRIBE", TK_DESCRIBE}, {"DISTINCT", TK_DISTINCT}, diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c index 6fb8faf391..775702a5c6 100644 --- a/source/libs/parser/src/sql.c +++ b/source/libs/parser/src/sql.c @@ -100,25 +100,25 @@ #endif /************* Begin control #defines *****************************************/ #define YYCODETYPE unsigned short int -#define YYNOCODE 361 +#define YYNOCODE 360 #define YYACTIONTYPE unsigned short int #define ParseTOKENTYPE SToken typedef union { int yyinit; ParseTOKENTYPE yy0; - EFillMode yy18; - SAlterOption yy25; - SToken yy53; - EOperatorType yy136; - int32_t yy158; - ENullOrder yy185; - SNodeList* yy236; - EJoinType yy342; - EOrder yy430; - int64_t yy435; - SDataType yy450; - bool yy603; - SNode* yy636; + EFillMode yy54; + int32_t yy100; + bool yy137; + int64_t yy189; + SToken yy209; + ENullOrder yy217; + SDataType yy304; + EOperatorType yy380; + SNodeList* yy424; + EOrder yy578; + SAlterOption yy605; + EJoinType yy612; + SNode* yy632; } YYMINORTYPE; #ifndef YYSTACKDEPTH #define YYSTACKDEPTH 100 @@ -134,17 +134,17 @@ typedef union { #define ParseCTX_FETCH #define ParseCTX_STORE #define YYFALLBACK 1 -#define YYNSTATE 612 -#define YYNRULE 455 -#define YYNTOKEN 240 -#define YY_MAX_SHIFT 611 -#define YY_MIN_SHIFTREDUCE 902 -#define YY_MAX_SHIFTREDUCE 1356 -#define YY_ERROR_ACTION 1357 -#define YY_ACCEPT_ACTION 1358 -#define YY_NO_ACTION 1359 -#define YY_MIN_REDUCE 1360 -#define YY_MAX_REDUCE 1814 +#define YYNSTATE 611 +#define YYNRULE 454 +#define YYNTOKEN 239 +#define YY_MAX_SHIFT 610 +#define YY_MIN_SHIFTREDUCE 900 +#define YY_MAX_SHIFTREDUCE 1353 +#define YY_ERROR_ACTION 1354 +#define YY_ACCEPT_ACTION 1355 +#define YY_NO_ACTION 1356 +#define YY_MIN_REDUCE 1357 +#define YY_MAX_REDUCE 1810 /************* End control #defines *******************************************/ #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) @@ -211,606 +211,622 @@ typedef union { ** yy_default[] Default action for each state. ** *********** Begin parsing tables **********************************************/ -#define YY_ACTTAB_COUNT (2136) +#define YY_ACTTAB_COUNT (2213) static const YYACTIONTYPE yy_action[] = { - /* 0 */ 460, 1648, 1536, 1648, 295, 386, 312, 387, 1392, 294, - /* 10 */ 28, 226, 35, 33, 1534, 24, 1383, 1661, 932, 1480, - /* 20 */ 304, 1645, 1170, 1645, 140, 36, 34, 32, 31, 30, - /* 30 */ 36, 34, 32, 31, 30, 1482, 1530, 1641, 1647, 1641, - /* 40 */ 1647, 394, 1469, 387, 1392, 1677, 524, 1168, 528, 130, - /* 50 */ 528, 1372, 1792, 509, 485, 1645, 936, 937, 14, 524, - /* 60 */ 35, 33, 1297, 508, 1176, 1791, 1631, 1631, 304, 1789, - /* 70 */ 1170, 1641, 1647, 489, 36, 34, 32, 31, 30, 604, - /* 80 */ 603, 1, 528, 112, 1690, 1131, 525, 80, 1662, 511, - /* 90 */ 1664, 1665, 507, 1133, 528, 1168, 1661, 1730, 104, 404, - /* 100 */ 1311, 276, 1726, 608, 1744, 425, 14, 39, 35, 33, - /* 110 */ 1792, 1649, 1176, 1792, 1169, 1491, 304, 1744, 1170, 512, - /* 120 */ 277, 110, 307, 146, 1677, 1581, 147, 1789, 1741, 2, - /* 130 */ 1789, 1645, 506, 1304, 376, 487, 142, 1737, 1738, 1194, - /* 140 */ 1742, 1740, 508, 1168, 1208, 55, 1631, 1641, 1647, 525, - /* 150 */ 56, 608, 1259, 131, 14, 1132, 1677, 1448, 528, 1171, - /* 160 */ 1176, 350, 1169, 1690, 478, 404, 270, 1662, 511, 1664, - /* 170 */ 1665, 507, 505, 528, 502, 1702, 1382, 2, 1491, 158, - /* 180 */ 157, 1174, 1175, 1194, 1221, 1222, 1224, 1225, 1226, 1227, - /* 190 */ 1228, 504, 526, 1236, 1237, 1238, 1239, 1240, 1241, 608, - /* 200 */ 477, 62, 1260, 154, 64, 292, 1296, 1171, 191, 94, - /* 210 */ 1169, 148, 93, 92, 91, 90, 89, 88, 87, 86, - /* 220 */ 85, 1381, 345, 1487, 344, 1265, 1631, 55, 60, 1174, - /* 230 */ 1175, 59, 1221, 1222, 1224, 1225, 1226, 1227, 1228, 504, - /* 240 */ 526, 1236, 1237, 1238, 1239, 1240, 1241, 1419, 286, 479, - /* 250 */ 36, 34, 32, 31, 30, 1171, 36, 34, 32, 31, - /* 260 */ 30, 27, 302, 1254, 1255, 1256, 1257, 1258, 1262, 1263, - /* 270 */ 1264, 1631, 55, 1358, 1744, 148, 385, 1174, 1175, 389, - /* 280 */ 1221, 1222, 1224, 1225, 1226, 1227, 1228, 504, 526, 1236, - /* 290 */ 1237, 1238, 1239, 1240, 1241, 35, 33, 287, 1739, 285, - /* 300 */ 284, 524, 427, 304, 1223, 1170, 429, 584, 583, 582, - /* 310 */ 319, 1467, 581, 580, 579, 114, 574, 573, 572, 571, - /* 320 */ 570, 569, 568, 567, 121, 563, 439, 438, 62, 428, - /* 330 */ 1168, 437, 320, 1661, 109, 434, 560, 346, 433, 432, - /* 340 */ 431, 108, 525, 35, 33, 1242, 391, 1176, 1192, 948, - /* 350 */ 1486, 304, 1192, 1170, 351, 559, 558, 148, 557, 556, - /* 360 */ 555, 1677, 38, 1792, 8, 308, 1380, 474, 562, 488, - /* 370 */ 1261, 1491, 1792, 128, 423, 453, 1790, 1792, 1168, 508, - /* 380 */ 1789, 1321, 1493, 1631, 127, 145, 608, 436, 435, 1789, - /* 390 */ 145, 35, 33, 1266, 1789, 1176, 949, 1169, 948, 304, - /* 400 */ 1690, 1170, 148, 81, 1662, 511, 1664, 1665, 507, 55, - /* 410 */ 528, 1379, 9, 1730, 1295, 1792, 1631, 297, 1726, 141, - /* 420 */ 471, 1319, 1320, 1322, 1323, 950, 1168, 1361, 145, 25, - /* 430 */ 512, 218, 1789, 314, 608, 1422, 1582, 467, 1757, 480, - /* 440 */ 475, 128, 1171, 1176, 1409, 1169, 393, 1378, 94, 389, - /* 450 */ 1493, 93, 92, 91, 90, 89, 88, 87, 86, 85, - /* 460 */ 9, 1631, 578, 576, 1174, 1175, 440, 1221, 1222, 1224, - /* 470 */ 1225, 1226, 1227, 1228, 504, 526, 1236, 1237, 1238, 1239, - /* 480 */ 1240, 1241, 608, 36, 34, 32, 31, 30, 1468, 70, - /* 490 */ 1171, 1569, 148, 1169, 148, 439, 438, 1631, 156, 1536, - /* 500 */ 437, 7, 525, 109, 434, 1195, 309, 433, 432, 431, - /* 510 */ 1484, 1534, 1174, 1175, 361, 1221, 1222, 1224, 1225, 1226, - /* 520 */ 1227, 1228, 504, 526, 1236, 1237, 1238, 1239, 1240, 1241, - /* 530 */ 493, 1491, 36, 34, 32, 31, 30, 1196, 1171, 148, - /* 540 */ 1039, 551, 550, 549, 1043, 548, 1045, 1046, 547, 1048, - /* 550 */ 544, 316, 1054, 541, 1056, 1057, 538, 535, 1572, 1574, - /* 560 */ 1174, 1175, 1377, 1221, 1222, 1224, 1225, 1226, 1227, 1228, - /* 570 */ 504, 526, 1236, 1237, 1238, 1239, 1240, 1241, 35, 33, - /* 580 */ 273, 560, 1192, 26, 11, 10, 304, 1661, 1170, 369, - /* 590 */ 54, 1001, 381, 36, 34, 32, 31, 30, 1573, 1574, - /* 600 */ 559, 558, 1208, 557, 556, 555, 177, 525, 1003, 1536, - /* 610 */ 382, 1247, 1631, 1168, 1360, 1677, 315, 1194, 139, 362, - /* 620 */ 525, 1534, 1353, 509, 421, 417, 413, 409, 176, 1376, - /* 630 */ 1176, 337, 403, 508, 936, 937, 1491, 1631, 103, 102, - /* 640 */ 101, 100, 99, 98, 97, 96, 95, 2, 485, 1491, - /* 650 */ 1193, 339, 335, 63, 1690, 77, 174, 81, 1662, 511, - /* 660 */ 1664, 1665, 507, 217, 528, 1273, 128, 1730, 113, 608, - /* 670 */ 352, 297, 1726, 1805, 1292, 1494, 1483, 112, 461, 1631, - /* 680 */ 1169, 380, 1764, 1375, 375, 374, 373, 372, 371, 368, - /* 690 */ 367, 366, 365, 364, 360, 359, 358, 357, 356, 355, - /* 700 */ 354, 353, 1352, 249, 274, 129, 1521, 525, 554, 525, - /* 710 */ 255, 32, 31, 30, 173, 110, 165, 494, 170, 1488, - /* 720 */ 399, 104, 253, 53, 562, 1171, 52, 462, 430, 565, - /* 730 */ 143, 1737, 1738, 1631, 1742, 1197, 1491, 1661, 1491, 182, - /* 740 */ 163, 1466, 180, 159, 1374, 496, 1371, 1174, 1175, 1194, - /* 750 */ 1221, 1222, 1224, 1225, 1226, 1227, 1228, 504, 526, 1236, - /* 760 */ 1237, 1238, 1239, 1240, 1241, 1677, 1370, 1792, 55, 525, - /* 770 */ 566, 317, 1463, 509, 36, 34, 32, 31, 30, 128, - /* 780 */ 145, 1611, 1223, 508, 1789, 1749, 1292, 1631, 1493, 525, - /* 790 */ 525, 1369, 1620, 489, 1631, 485, 1631, 1368, 1491, 1476, - /* 800 */ 429, 522, 523, 525, 1690, 79, 485, 80, 1662, 511, - /* 810 */ 1664, 1665, 507, 491, 528, 239, 1631, 1730, 1491, 1491, - /* 820 */ 277, 276, 1726, 428, 112, 1367, 1155, 1156, 184, 1404, - /* 830 */ 525, 183, 1491, 1792, 560, 112, 1661, 327, 58, 57, - /* 840 */ 349, 1631, 318, 153, 489, 1170, 145, 1631, 343, 1366, - /* 850 */ 1789, 442, 1259, 559, 558, 1365, 557, 556, 555, 1491, - /* 860 */ 272, 202, 110, 333, 1677, 329, 325, 150, 1364, 1363, - /* 870 */ 1168, 501, 488, 110, 577, 1631, 1478, 215, 1737, 484, - /* 880 */ 186, 483, 508, 185, 1792, 76, 1631, 1176, 144, 1737, - /* 890 */ 1738, 47, 1742, 188, 275, 72, 187, 147, 148, 1631, - /* 900 */ 1536, 1789, 1260, 1690, 1661, 1631, 81, 1662, 511, 1664, - /* 910 */ 1665, 507, 1535, 528, 1223, 340, 1730, 1402, 1631, 1631, - /* 920 */ 297, 1726, 141, 451, 485, 1265, 608, 11, 10, 1355, - /* 930 */ 1356, 118, 1677, 1373, 497, 1179, 449, 1169, 1474, 445, - /* 940 */ 509, 1758, 46, 1651, 205, 1178, 1449, 194, 503, 553, - /* 950 */ 508, 37, 37, 112, 1631, 37, 228, 116, 221, 117, - /* 960 */ 118, 27, 302, 1254, 1255, 1256, 1257, 1258, 1262, 1263, - /* 970 */ 1264, 1690, 463, 489, 81, 1662, 511, 1664, 1665, 507, - /* 980 */ 1653, 528, 1171, 1318, 1730, 207, 46, 1661, 297, 1726, - /* 990 */ 1805, 110, 1267, 1229, 1251, 533, 1125, 230, 517, 1787, - /* 1000 */ 236, 1032, 1182, 117, 1174, 1175, 215, 1737, 484, 118, - /* 1010 */ 483, 119, 1181, 1792, 973, 1677, 454, 212, 472, 1661, - /* 1020 */ 1678, 1393, 117, 509, 422, 1760, 145, 248, 1531, 486, - /* 1030 */ 1789, 974, 220, 508, 223, 225, 1060, 1631, 3, 1192, - /* 1040 */ 322, 326, 282, 283, 1064, 1001, 1139, 1677, 244, 1661, - /* 1050 */ 1071, 363, 1069, 1571, 1690, 509, 155, 81, 1662, 511, - /* 1060 */ 1664, 1665, 507, 120, 528, 508, 370, 1730, 378, 1631, - /* 1070 */ 377, 297, 1726, 1805, 379, 489, 383, 1677, 1198, 384, - /* 1080 */ 392, 1201, 1748, 395, 1200, 509, 1690, 162, 396, 262, - /* 1090 */ 1662, 511, 1664, 1665, 507, 508, 528, 164, 1202, 1631, - /* 1100 */ 398, 167, 397, 169, 400, 489, 401, 1661, 1199, 402, - /* 1110 */ 444, 172, 61, 405, 175, 1792, 1690, 424, 426, 262, - /* 1120 */ 1662, 511, 1664, 1665, 507, 452, 528, 84, 147, 1481, - /* 1130 */ 291, 179, 1789, 1477, 1176, 1677, 181, 122, 123, 190, - /* 1140 */ 1479, 1475, 124, 509, 125, 1792, 1615, 1661, 245, 192, - /* 1150 */ 455, 447, 246, 508, 456, 464, 441, 1631, 145, 195, - /* 1160 */ 197, 189, 1789, 459, 1197, 465, 1661, 473, 515, 1771, - /* 1170 */ 1770, 6, 470, 200, 1690, 1677, 203, 82, 1662, 511, - /* 1180 */ 1664, 1665, 507, 509, 528, 206, 51, 1730, 296, 50, - /* 1190 */ 1761, 1729, 1726, 508, 1677, 1751, 482, 1631, 1661, 211, - /* 1200 */ 469, 476, 509, 5, 135, 1292, 111, 1196, 1745, 40, - /* 1210 */ 213, 214, 508, 18, 1690, 495, 1631, 82, 1662, 511, - /* 1220 */ 1664, 1665, 507, 498, 528, 298, 1677, 1730, 1580, 513, - /* 1230 */ 514, 500, 1726, 1690, 509, 1788, 132, 1662, 511, 1664, - /* 1240 */ 1665, 507, 306, 528, 508, 1579, 219, 1808, 1631, 492, - /* 1250 */ 1711, 518, 519, 611, 222, 232, 520, 234, 247, 69, - /* 1260 */ 499, 1492, 71, 1661, 531, 1690, 224, 243, 82, 1662, - /* 1270 */ 511, 1664, 1665, 507, 1464, 528, 250, 241, 1730, 105, - /* 1280 */ 490, 1806, 607, 1727, 134, 600, 596, 592, 588, 242, - /* 1290 */ 256, 1677, 263, 257, 48, 293, 252, 254, 1625, 509, - /* 1300 */ 1624, 321, 1621, 323, 324, 1164, 1165, 151, 328, 508, - /* 1310 */ 1619, 1661, 330, 1631, 78, 331, 468, 237, 332, 1618, - /* 1320 */ 334, 1617, 336, 1616, 338, 1601, 152, 341, 342, 1142, - /* 1330 */ 1690, 1141, 1595, 271, 1662, 511, 1664, 1665, 507, 1677, - /* 1340 */ 528, 1594, 1593, 347, 348, 1592, 1564, 509, 1108, 1563, - /* 1350 */ 1562, 521, 1561, 1560, 1559, 1558, 1557, 508, 1556, 1661, - /* 1360 */ 1555, 1631, 1554, 1553, 1552, 1551, 1550, 1549, 1661, 1548, - /* 1370 */ 1547, 115, 1546, 1545, 1544, 1543, 466, 1542, 1690, 198, - /* 1380 */ 1541, 266, 1662, 511, 1664, 1665, 507, 1677, 528, 1540, - /* 1390 */ 1110, 1539, 1538, 1537, 1421, 509, 1677, 160, 106, 1147, - /* 1400 */ 1389, 193, 939, 388, 509, 508, 1388, 1609, 1603, 1631, - /* 1410 */ 938, 1587, 138, 1586, 508, 168, 161, 1577, 1631, 481, - /* 1420 */ 390, 301, 1661, 107, 166, 1470, 1690, 171, 1420, 132, - /* 1430 */ 1662, 511, 1664, 1665, 507, 1690, 528, 1661, 271, 1662, - /* 1440 */ 511, 1664, 1665, 507, 967, 528, 1418, 407, 406, 408, - /* 1450 */ 1677, 1416, 410, 412, 411, 1414, 416, 414, 506, 415, - /* 1460 */ 1412, 420, 418, 419, 1401, 1677, 1400, 1387, 508, 1472, - /* 1470 */ 1661, 45, 1631, 509, 1807, 1074, 1075, 1471, 1000, 999, - /* 1480 */ 998, 997, 575, 508, 577, 1661, 178, 1631, 1410, 1690, - /* 1490 */ 303, 994, 270, 1662, 511, 1664, 1665, 507, 1677, 528, - /* 1500 */ 288, 1703, 1405, 993, 1690, 992, 509, 271, 1662, 511, - /* 1510 */ 1664, 1665, 507, 1677, 528, 1403, 508, 289, 443, 290, - /* 1520 */ 1631, 509, 446, 305, 1386, 1661, 448, 1385, 450, 83, - /* 1530 */ 1608, 508, 1149, 1602, 457, 1631, 1585, 1690, 196, 1584, - /* 1540 */ 271, 1662, 511, 1664, 1665, 507, 1576, 528, 126, 49, - /* 1550 */ 458, 199, 1690, 1677, 65, 258, 1662, 511, 1664, 1665, - /* 1560 */ 507, 509, 528, 201, 4, 204, 37, 43, 1317, 1310, - /* 1570 */ 133, 508, 208, 22, 10, 1631, 209, 1661, 210, 66, - /* 1580 */ 29, 1651, 1289, 23, 216, 1288, 42, 136, 17, 1346, - /* 1590 */ 1335, 1341, 1690, 19, 15, 265, 1662, 511, 1664, 1665, - /* 1600 */ 507, 1340, 528, 299, 1345, 1677, 1344, 300, 1252, 137, - /* 1610 */ 1231, 1230, 12, 509, 16, 149, 1216, 1575, 510, 20, - /* 1620 */ 516, 233, 235, 508, 1650, 1661, 238, 1631, 965, 41, - /* 1630 */ 21, 1186, 227, 1315, 532, 313, 13, 536, 539, 229, - /* 1640 */ 1661, 1038, 231, 67, 1690, 68, 72, 267, 1662, 511, - /* 1650 */ 1664, 1665, 507, 1677, 528, 1693, 552, 1233, 527, 44, - /* 1660 */ 530, 509, 542, 1061, 534, 545, 1066, 1058, 1677, 1070, - /* 1670 */ 537, 508, 1053, 1661, 1055, 1631, 509, 540, 1052, 1049, - /* 1680 */ 543, 1051, 1047, 546, 1050, 73, 508, 1067, 74, 75, - /* 1690 */ 1631, 561, 1690, 989, 1007, 259, 1662, 511, 1664, 1665, - /* 1700 */ 507, 1677, 528, 564, 240, 987, 986, 1690, 985, 509, - /* 1710 */ 268, 1662, 511, 1664, 1665, 507, 982, 528, 984, 508, - /* 1720 */ 983, 981, 980, 1631, 1068, 1002, 1004, 1661, 977, 976, - /* 1730 */ 975, 972, 971, 970, 1417, 585, 1661, 586, 587, 1415, - /* 1740 */ 1690, 590, 589, 260, 1662, 511, 1664, 1665, 507, 591, - /* 1750 */ 528, 1413, 593, 594, 595, 1677, 597, 599, 598, 1399, - /* 1760 */ 1398, 601, 602, 509, 1677, 1411, 1384, 605, 606, 1359, - /* 1770 */ 1172, 251, 509, 508, 609, 610, 1359, 1631, 1359, 1359, - /* 1780 */ 1359, 1359, 508, 1359, 1661, 1359, 1631, 1359, 1359, 1359, - /* 1790 */ 1359, 1359, 1359, 1359, 1690, 1359, 1661, 269, 1662, 511, - /* 1800 */ 1664, 1665, 507, 1690, 528, 1359, 261, 1662, 511, 1664, - /* 1810 */ 1665, 507, 1677, 528, 1359, 1359, 1359, 1359, 1359, 1359, - /* 1820 */ 509, 1359, 1359, 1359, 1677, 1359, 1359, 1359, 1359, 1359, - /* 1830 */ 508, 1359, 509, 1359, 1631, 1359, 1661, 1359, 1359, 1359, - /* 1840 */ 1359, 1359, 508, 1359, 1359, 1359, 1631, 1359, 1359, 1661, - /* 1850 */ 1359, 1690, 1359, 1359, 1673, 1662, 511, 1664, 1665, 507, - /* 1860 */ 1359, 528, 1359, 1690, 1677, 1359, 1672, 1662, 511, 1664, - /* 1870 */ 1665, 507, 509, 528, 1359, 1359, 1359, 1677, 1359, 1359, - /* 1880 */ 1359, 1359, 508, 1359, 1359, 509, 1631, 1359, 1359, 1359, - /* 1890 */ 1359, 1359, 1359, 1359, 1359, 508, 1359, 1661, 1359, 1631, - /* 1900 */ 1359, 1359, 1359, 1690, 1359, 1359, 1671, 1662, 511, 1664, - /* 1910 */ 1665, 507, 1661, 528, 1359, 1359, 1690, 1359, 1359, 280, - /* 1920 */ 1662, 511, 1664, 1665, 507, 1677, 528, 1359, 1359, 1359, - /* 1930 */ 1359, 1359, 1359, 509, 1359, 1359, 1359, 1359, 1359, 1359, - /* 1940 */ 1677, 1359, 1359, 508, 1359, 1661, 1359, 1631, 509, 1359, - /* 1950 */ 1359, 1359, 1359, 311, 310, 1359, 1359, 1359, 508, 1359, - /* 1960 */ 1359, 1359, 1631, 1184, 1690, 1359, 1359, 279, 1662, 511, - /* 1970 */ 1664, 1665, 507, 1677, 528, 1359, 1359, 1359, 1359, 1690, - /* 1980 */ 1359, 509, 281, 1662, 511, 1664, 1665, 507, 1177, 528, - /* 1990 */ 1359, 508, 1359, 1359, 1359, 1631, 1359, 1359, 1359, 1661, - /* 2000 */ 1359, 1359, 1359, 1359, 1359, 1176, 1359, 1359, 1359, 1359, - /* 2010 */ 1359, 1359, 1690, 1359, 1359, 278, 1662, 511, 1664, 1665, - /* 2020 */ 507, 1359, 528, 1359, 1359, 1359, 1359, 1677, 1359, 1359, - /* 2030 */ 1359, 1359, 1359, 1359, 1359, 509, 1359, 1359, 1359, 1359, - /* 2040 */ 1359, 1359, 1359, 1359, 529, 508, 1359, 1359, 1359, 1631, - /* 2050 */ 1359, 1359, 1359, 1359, 1359, 1180, 1359, 1359, 1359, 1359, - /* 2060 */ 1359, 1359, 1359, 1359, 1359, 1359, 1690, 1359, 1359, 264, - /* 2070 */ 1662, 511, 1664, 1665, 507, 1359, 528, 1359, 1359, 1359, - /* 2080 */ 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, - /* 2090 */ 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, - /* 2100 */ 1185, 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, - /* 2110 */ 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, 1359, - /* 2120 */ 1359, 1359, 1188, 1359, 1359, 1359, 1359, 1359, 1359, 1359, - /* 2130 */ 1359, 1359, 1359, 526, 1236, 1237, + /* 0 */ 386, 1644, 387, 1389, 295, 394, 525, 387, 1389, 1740, + /* 10 */ 62, 930, 35, 33, 28, 226, 1477, 1657, 104, 1479, + /* 20 */ 304, 1641, 1167, 108, 1532, 425, 36, 34, 32, 31, + /* 30 */ 30, 294, 1483, 1737, 1355, 1488, 1530, 1637, 1643, 1641, + /* 40 */ 36, 34, 32, 31, 30, 1673, 524, 1165, 528, 934, + /* 50 */ 935, 524, 77, 509, 485, 1637, 1643, 947, 14, 946, + /* 60 */ 35, 33, 1294, 508, 1173, 113, 528, 1627, 304, 524, + /* 70 */ 1167, 352, 277, 1480, 36, 34, 32, 31, 30, 512, + /* 80 */ 404, 1, 307, 112, 1686, 1577, 948, 82, 1658, 511, + /* 90 */ 1660, 1661, 507, 320, 528, 1165, 1205, 1726, 1657, 1380, + /* 100 */ 1191, 1725, 1722, 607, 1256, 274, 14, 39, 35, 33, + /* 110 */ 603, 602, 1173, 1166, 385, 1788, 304, 389, 1167, 1644, + /* 120 */ 277, 110, 312, 1673, 55, 999, 1673, 1645, 1787, 2, + /* 130 */ 38, 478, 1785, 1788, 509, 487, 142, 1733, 1734, 1641, + /* 140 */ 1738, 55, 1001, 1165, 508, 56, 145, 1641, 1627, 1627, + /* 150 */ 1785, 607, 1256, 1257, 14, 1637, 1643, 62, 1168, 1465, + /* 160 */ 1173, 1166, 479, 1637, 1643, 1686, 528, 477, 256, 1658, + /* 170 */ 511, 1660, 1661, 507, 528, 528, 1262, 2, 1350, 1484, + /* 180 */ 1171, 1172, 376, 1218, 1219, 1221, 1222, 1223, 1224, 1225, + /* 190 */ 504, 526, 1233, 1234, 1235, 1236, 1237, 1238, 1192, 607, + /* 200 */ 345, 1257, 344, 64, 292, 1379, 1168, 191, 429, 1166, + /* 210 */ 148, 1189, 27, 302, 1251, 1252, 1253, 1254, 1255, 1259, + /* 220 */ 1260, 1261, 55, 130, 1262, 1369, 158, 157, 1171, 1172, + /* 230 */ 428, 1218, 1219, 1221, 1222, 1223, 1224, 1225, 504, 526, + /* 240 */ 1233, 1234, 1235, 1236, 1237, 1238, 1416, 36, 34, 32, + /* 250 */ 31, 30, 559, 148, 1168, 1627, 1406, 1318, 1349, 148, + /* 260 */ 27, 302, 1251, 1252, 1253, 1254, 1255, 1259, 1260, 1261, + /* 270 */ 148, 558, 55, 557, 556, 555, 1171, 1172, 440, 1218, + /* 280 */ 1219, 1221, 1222, 1223, 1224, 1225, 504, 526, 1233, 1234, + /* 290 */ 1235, 1236, 1237, 1238, 35, 33, 471, 1316, 1317, 1319, + /* 300 */ 1320, 131, 304, 154, 1167, 1445, 583, 582, 581, 319, + /* 310 */ 561, 580, 579, 578, 114, 573, 572, 571, 570, 569, + /* 320 */ 568, 567, 566, 121, 562, 1193, 559, 1466, 60, 1165, + /* 330 */ 94, 59, 1657, 93, 92, 91, 90, 89, 88, 87, + /* 340 */ 86, 85, 35, 33, 1239, 558, 1173, 557, 556, 555, + /* 350 */ 304, 148, 1167, 439, 438, 32, 31, 30, 437, 554, + /* 360 */ 1673, 109, 434, 8, 1301, 433, 432, 431, 509, 140, + /* 370 */ 1191, 36, 34, 32, 31, 30, 1788, 1165, 508, 1788, + /* 380 */ 127, 1526, 1627, 393, 404, 607, 389, 1190, 474, 146, + /* 390 */ 35, 33, 1786, 1785, 1173, 1166, 1785, 451, 304, 1686, + /* 400 */ 1167, 148, 132, 1658, 511, 1660, 1661, 507, 1740, 528, + /* 410 */ 449, 9, 436, 435, 1037, 551, 550, 549, 1041, 548, + /* 420 */ 1043, 1044, 547, 1046, 544, 1165, 1052, 541, 1054, 1055, + /* 430 */ 538, 535, 1736, 607, 1419, 36, 34, 32, 31, 30, + /* 440 */ 1168, 1308, 1173, 1166, 24, 316, 490, 1802, 249, 461, + /* 450 */ 217, 1518, 1568, 1570, 36, 34, 32, 31, 30, 9, + /* 460 */ 480, 475, 1171, 1172, 485, 1218, 1219, 1221, 1222, 1223, + /* 470 */ 1224, 1225, 504, 526, 1233, 1234, 1235, 1236, 1237, 1238, + /* 480 */ 1378, 607, 36, 34, 32, 31, 30, 1473, 1168, 1532, + /* 490 */ 1565, 1166, 148, 112, 439, 438, 309, 156, 462, 437, + /* 500 */ 346, 1530, 109, 434, 1463, 1205, 433, 432, 431, 1194, + /* 510 */ 1171, 1172, 485, 1218, 1219, 1221, 1222, 1223, 1224, 1225, + /* 520 */ 504, 526, 1233, 1234, 1235, 1236, 1237, 1238, 11, 10, + /* 530 */ 1627, 110, 1532, 1258, 1220, 946, 1168, 308, 1788, 315, + /* 540 */ 1788, 112, 577, 575, 1530, 128, 143, 1733, 1734, 1377, + /* 550 */ 1738, 145, 286, 145, 1490, 1785, 1263, 1785, 1171, 1172, + /* 560 */ 423, 1218, 1219, 1221, 1222, 1223, 1224, 1225, 504, 526, + /* 570 */ 1233, 1234, 1235, 1236, 1237, 1238, 35, 33, 273, 110, + /* 580 */ 1189, 1128, 1569, 1570, 304, 1657, 1167, 369, 525, 1130, + /* 590 */ 381, 1740, 25, 525, 144, 1733, 1734, 559, 1738, 1627, + /* 600 */ 104, 287, 7, 285, 284, 350, 427, 430, 382, 1270, + /* 610 */ 429, 1165, 1358, 1673, 1376, 1735, 558, 1488, 557, 556, + /* 620 */ 555, 509, 1488, 1244, 512, 1375, 337, 1475, 1173, 1191, + /* 630 */ 1578, 508, 428, 94, 202, 1627, 93, 92, 91, 90, + /* 640 */ 89, 88, 87, 86, 85, 2, 339, 335, 391, 1464, + /* 650 */ 1129, 70, 1686, 1191, 1189, 81, 1658, 511, 1660, 1661, + /* 660 */ 507, 453, 528, 564, 1627, 1726, 565, 607, 1460, 297, + /* 670 */ 1722, 1801, 1481, 1374, 1471, 1627, 54, 1166, 380, 493, + /* 680 */ 1760, 375, 374, 373, 372, 371, 368, 367, 366, 365, + /* 690 */ 364, 360, 359, 358, 357, 356, 355, 354, 353, 26, + /* 700 */ 1167, 1788, 576, 610, 525, 501, 561, 314, 1532, 36, + /* 710 */ 34, 32, 31, 30, 145, 128, 351, 243, 1785, 1373, + /* 720 */ 1531, 128, 1168, 1627, 1490, 1165, 1372, 1293, 1371, 105, + /* 730 */ 1491, 194, 1368, 1488, 1657, 599, 595, 591, 587, 242, + /* 740 */ 934, 935, 1173, 340, 1171, 1172, 503, 1218, 1219, 1221, + /* 750 */ 1222, 1223, 1224, 1225, 504, 526, 1233, 1234, 1235, 1236, + /* 760 */ 1237, 1238, 1673, 525, 78, 525, 496, 237, 1616, 1627, + /* 770 */ 509, 317, 1370, 525, 1289, 361, 1627, 362, 1627, 128, + /* 780 */ 508, 607, 1627, 1367, 1627, 403, 485, 525, 1490, 1366, + /* 790 */ 489, 1166, 1488, 1220, 1488, 1365, 1745, 1289, 460, 522, + /* 800 */ 521, 1686, 1488, 118, 80, 1658, 511, 1660, 1661, 507, + /* 810 */ 1657, 528, 525, 327, 1726, 112, 1488, 1220, 276, 1722, + /* 820 */ 525, 76, 525, 1364, 1485, 466, 182, 1248, 198, 180, + /* 830 */ 1788, 72, 1607, 1627, 523, 489, 1168, 184, 1673, 1627, + /* 840 */ 183, 1488, 1401, 147, 463, 1627, 509, 1785, 1144, 1488, + /* 850 */ 193, 1488, 1363, 110, 186, 553, 508, 185, 1171, 1172, + /* 860 */ 1627, 1362, 1361, 1360, 442, 494, 489, 525, 215, 1733, + /* 870 */ 484, 1657, 483, 1627, 444, 1788, 1446, 1686, 221, 239, + /* 880 */ 80, 1658, 511, 1660, 1661, 507, 1399, 528, 147, 452, + /* 890 */ 1726, 472, 1785, 525, 276, 1722, 1488, 188, 491, 1673, + /* 900 */ 187, 47, 1627, 190, 275, 318, 1788, 488, 445, 129, + /* 910 */ 454, 1627, 1627, 1627, 255, 447, 971, 508, 212, 145, + /* 920 */ 441, 1627, 1488, 1785, 46, 189, 253, 53, 1152, 1153, + /* 930 */ 52, 1390, 1657, 972, 1292, 1176, 205, 1674, 1686, 1352, + /* 940 */ 1353, 81, 1658, 511, 1660, 1661, 507, 159, 528, 422, + /* 950 */ 51, 1726, 1527, 50, 497, 297, 1722, 141, 11, 10, + /* 960 */ 1673, 1357, 1175, 1756, 486, 1315, 220, 223, 488, 218, + /* 970 */ 37, 3, 55, 1189, 37, 467, 1753, 207, 508, 225, + /* 980 */ 322, 37, 1627, 1647, 228, 103, 102, 101, 100, 99, + /* 990 */ 98, 97, 96, 95, 326, 116, 282, 117, 999, 1686, + /* 1000 */ 485, 1179, 81, 1658, 511, 1660, 1661, 507, 79, 528, + /* 1010 */ 283, 1264, 1726, 244, 1136, 1226, 297, 1722, 141, 118, + /* 1020 */ 1649, 363, 1122, 46, 533, 230, 1567, 155, 1178, 112, + /* 1030 */ 117, 370, 118, 119, 117, 378, 517, 1754, 236, 377, + /* 1040 */ 383, 58, 57, 349, 1657, 379, 153, 1195, 384, 489, + /* 1050 */ 392, 343, 1198, 395, 162, 396, 1197, 164, 1199, 397, + /* 1060 */ 1030, 167, 400, 272, 248, 1058, 333, 110, 329, 325, + /* 1070 */ 150, 1062, 1673, 1068, 1066, 120, 169, 398, 1196, 401, + /* 1080 */ 509, 402, 215, 1733, 484, 172, 483, 61, 405, 1788, + /* 1090 */ 508, 175, 424, 426, 1627, 1478, 179, 1474, 181, 1657, + /* 1100 */ 122, 148, 145, 84, 123, 1476, 1785, 291, 1472, 1173, + /* 1110 */ 124, 1686, 1611, 125, 81, 1658, 511, 1660, 1661, 507, + /* 1120 */ 245, 528, 456, 192, 1726, 455, 195, 1673, 297, 1722, + /* 1130 */ 1801, 197, 459, 464, 465, 509, 200, 246, 1194, 1783, + /* 1140 */ 1757, 473, 1767, 515, 203, 508, 1766, 482, 470, 1627, + /* 1150 */ 1657, 6, 206, 296, 476, 1747, 135, 211, 469, 5, + /* 1160 */ 111, 1289, 1657, 1193, 40, 213, 1686, 495, 219, 81, + /* 1170 */ 1658, 511, 1660, 1661, 507, 1741, 528, 298, 1673, 1726, + /* 1180 */ 1804, 214, 18, 297, 1722, 1801, 509, 498, 518, 222, + /* 1190 */ 1673, 1707, 1576, 513, 1744, 514, 508, 1575, 509, 224, + /* 1200 */ 1627, 1784, 306, 492, 499, 520, 489, 519, 508, 232, + /* 1210 */ 234, 71, 1627, 1489, 247, 1657, 69, 1686, 489, 250, + /* 1220 */ 260, 1658, 511, 1660, 1661, 507, 241, 528, 1461, 1686, + /* 1230 */ 606, 48, 260, 1658, 511, 1660, 1661, 507, 254, 528, + /* 1240 */ 531, 134, 1621, 1673, 261, 271, 1788, 293, 1657, 262, + /* 1250 */ 252, 509, 1620, 321, 1617, 323, 324, 1161, 1788, 147, + /* 1260 */ 1162, 508, 151, 1785, 328, 1627, 1615, 330, 331, 332, + /* 1270 */ 1614, 145, 334, 1613, 336, 1785, 1673, 1612, 338, 1597, + /* 1280 */ 152, 341, 1686, 342, 506, 82, 1658, 511, 1660, 1661, + /* 1290 */ 507, 1139, 528, 1138, 508, 1726, 1591, 1590, 1627, 500, + /* 1300 */ 1722, 347, 348, 1589, 1588, 1105, 1657, 1560, 1559, 1558, + /* 1310 */ 1557, 1556, 1555, 1554, 1553, 1686, 115, 1542, 269, 1658, + /* 1320 */ 511, 1660, 1661, 507, 505, 528, 502, 1698, 1552, 1551, + /* 1330 */ 1550, 1549, 1548, 1547, 1673, 1546, 1545, 1544, 1543, 1541, + /* 1340 */ 1540, 1539, 509, 1538, 1537, 1107, 1536, 1535, 1534, 1533, + /* 1350 */ 1418, 1386, 508, 1385, 1657, 160, 1627, 106, 1605, 138, + /* 1360 */ 161, 107, 1599, 388, 1583, 390, 937, 1657, 1582, 936, + /* 1370 */ 168, 166, 1573, 1686, 1467, 1417, 82, 1658, 511, 1660, + /* 1380 */ 1661, 507, 1673, 528, 965, 1415, 1726, 1413, 1411, 406, + /* 1390 */ 509, 1723, 410, 171, 408, 1673, 412, 1409, 1398, 407, + /* 1400 */ 508, 1397, 1384, 509, 1627, 411, 416, 468, 414, 1469, + /* 1410 */ 415, 419, 1071, 508, 418, 1657, 45, 1627, 420, 1468, + /* 1420 */ 1072, 1686, 1407, 998, 270, 1658, 511, 1660, 1661, 507, + /* 1430 */ 997, 528, 574, 996, 1686, 576, 995, 265, 1658, 511, + /* 1440 */ 1660, 1661, 507, 1673, 528, 288, 992, 991, 1402, 289, + /* 1450 */ 990, 509, 443, 1400, 446, 290, 1383, 448, 178, 1382, + /* 1460 */ 450, 508, 83, 1604, 1146, 1627, 1657, 1598, 126, 457, + /* 1470 */ 1581, 1580, 49, 1572, 65, 481, 199, 1657, 4, 15, + /* 1480 */ 210, 37, 1686, 16, 43, 132, 1658, 511, 1660, 1661, + /* 1490 */ 507, 133, 528, 204, 1673, 1314, 208, 22, 209, 1647, + /* 1500 */ 1307, 66, 509, 23, 216, 1673, 1286, 1285, 458, 41, + /* 1510 */ 42, 201, 508, 506, 13, 1338, 1627, 17, 136, 301, + /* 1520 */ 196, 10, 1337, 508, 299, 1657, 1343, 1627, 1332, 1342, + /* 1530 */ 1803, 1341, 300, 1686, 19, 29, 270, 1658, 511, 1660, + /* 1540 */ 1661, 507, 137, 528, 1686, 149, 1228, 269, 1658, 511, + /* 1550 */ 1660, 1661, 507, 1673, 528, 1213, 1699, 1249, 1657, 1571, + /* 1560 */ 1227, 509, 12, 233, 510, 1646, 238, 20, 21, 516, + /* 1570 */ 227, 508, 1312, 229, 235, 1627, 231, 67, 303, 1230, + /* 1580 */ 68, 1689, 72, 527, 1183, 44, 1673, 1059, 532, 313, + /* 1590 */ 1056, 534, 1686, 536, 509, 270, 1658, 511, 1660, 1661, + /* 1600 */ 507, 530, 528, 539, 508, 537, 1036, 1053, 1627, 540, + /* 1610 */ 542, 305, 1047, 543, 545, 1067, 1045, 546, 73, 1051, + /* 1620 */ 1050, 1657, 1049, 1048, 552, 1686, 177, 560, 270, 1658, + /* 1630 */ 511, 1660, 1661, 507, 1657, 528, 74, 1064, 139, 75, + /* 1640 */ 1065, 963, 987, 1005, 421, 417, 413, 409, 176, 1673, + /* 1650 */ 563, 240, 980, 985, 984, 983, 982, 509, 981, 979, + /* 1660 */ 978, 1002, 1673, 1000, 975, 974, 973, 508, 970, 969, + /* 1670 */ 509, 1627, 968, 63, 1657, 1414, 174, 585, 584, 586, + /* 1680 */ 508, 1412, 588, 589, 1627, 590, 1410, 592, 1686, 593, + /* 1690 */ 594, 264, 1658, 511, 1660, 1661, 507, 1408, 528, 596, + /* 1700 */ 597, 1686, 1673, 598, 266, 1658, 511, 1660, 1661, 507, + /* 1710 */ 509, 528, 1396, 1395, 600, 601, 1381, 604, 1169, 605, + /* 1720 */ 508, 251, 608, 609, 1627, 1657, 1356, 1356, 1356, 1356, + /* 1730 */ 1356, 1356, 1356, 173, 1356, 165, 1356, 170, 1356, 399, + /* 1740 */ 1356, 1686, 1356, 1356, 257, 1658, 511, 1660, 1661, 507, + /* 1750 */ 1356, 528, 1356, 1673, 1356, 1657, 1356, 1356, 1356, 163, + /* 1760 */ 1356, 509, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, + /* 1770 */ 1356, 508, 1356, 1356, 1356, 1627, 1356, 1356, 1356, 1356, + /* 1780 */ 1356, 1356, 1356, 1673, 1356, 1356, 1356, 1657, 1356, 1356, + /* 1790 */ 1356, 509, 1686, 1356, 1356, 267, 1658, 511, 1660, 1661, + /* 1800 */ 507, 508, 528, 1356, 1356, 1627, 1356, 1356, 1356, 1356, + /* 1810 */ 1356, 1356, 1356, 1356, 1356, 1673, 1356, 1356, 1356, 1356, + /* 1820 */ 1356, 1356, 1686, 509, 1356, 258, 1658, 511, 1660, 1661, + /* 1830 */ 507, 1356, 528, 508, 1356, 1356, 1356, 1627, 1657, 1356, + /* 1840 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1657, 1356, 1356, + /* 1850 */ 1356, 1356, 1356, 1356, 1686, 1356, 1356, 268, 1658, 511, + /* 1860 */ 1660, 1661, 507, 1356, 528, 1356, 1673, 1356, 1356, 1356, + /* 1870 */ 1356, 1356, 1356, 1356, 509, 1673, 1356, 1356, 1356, 1356, + /* 1880 */ 1356, 1356, 1356, 509, 508, 1356, 1356, 1356, 1627, 1356, + /* 1890 */ 1356, 1356, 1356, 508, 1356, 1356, 1356, 1627, 1356, 1356, + /* 1900 */ 1657, 1356, 1356, 1356, 1356, 1686, 1356, 1356, 259, 1658, + /* 1910 */ 511, 1660, 1661, 507, 1686, 528, 1657, 1669, 1658, 511, + /* 1920 */ 1660, 1661, 507, 1356, 528, 1356, 1356, 1356, 1673, 1356, + /* 1930 */ 1356, 1356, 1356, 1356, 1356, 1356, 509, 1356, 1356, 1356, + /* 1940 */ 1356, 1356, 1356, 1356, 1673, 1356, 508, 1356, 1657, 1356, + /* 1950 */ 1627, 1356, 509, 1356, 1356, 1356, 1356, 1356, 1356, 1356, + /* 1960 */ 1356, 1356, 508, 1356, 1356, 1356, 1627, 1686, 1356, 1356, + /* 1970 */ 1668, 1658, 511, 1660, 1661, 507, 1673, 528, 1657, 1356, + /* 1980 */ 1356, 1356, 1356, 1686, 509, 1356, 1667, 1658, 511, 1660, + /* 1990 */ 1661, 507, 1356, 528, 508, 1356, 1356, 1356, 1627, 1356, + /* 2000 */ 1356, 1356, 1356, 1356, 1356, 1356, 1673, 1356, 1356, 1356, + /* 2010 */ 1356, 1356, 1356, 1356, 509, 1686, 1356, 1356, 280, 1658, + /* 2020 */ 511, 1660, 1661, 507, 508, 528, 1657, 1356, 1627, 1356, + /* 2030 */ 1356, 311, 310, 1356, 1356, 1657, 1356, 1356, 1356, 1356, + /* 2040 */ 1356, 1181, 1356, 1356, 1356, 1686, 1356, 1356, 279, 1658, + /* 2050 */ 511, 1660, 1661, 507, 1673, 528, 1356, 1356, 1356, 1356, + /* 2060 */ 1356, 1356, 509, 1673, 1356, 1356, 1174, 1356, 1356, 1356, + /* 2070 */ 1356, 509, 508, 1356, 1356, 1356, 1627, 1356, 1356, 1356, + /* 2080 */ 1356, 508, 1356, 1173, 1356, 1627, 1356, 1356, 1356, 1356, + /* 2090 */ 1657, 1356, 1356, 1686, 1356, 1356, 281, 1658, 511, 1660, + /* 2100 */ 1661, 507, 1686, 528, 1356, 278, 1658, 511, 1660, 1661, + /* 2110 */ 507, 1356, 528, 1356, 1356, 1356, 1356, 1356, 1673, 1356, + /* 2120 */ 1356, 1356, 529, 1356, 1356, 1356, 509, 1356, 1356, 1356, + /* 2130 */ 1356, 1356, 1177, 1356, 1356, 1356, 508, 1356, 1356, 1356, + /* 2140 */ 1627, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, + /* 2150 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1686, 1356, 1356, + /* 2160 */ 263, 1658, 511, 1660, 1661, 507, 1356, 528, 1356, 1356, + /* 2170 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1182, 1356, 1356, + /* 2180 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, + /* 2190 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1185, + /* 2200 */ 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, + /* 2210 */ 526, 1233, 1234, }; static const YYCODETYPE yy_lookahead[] = { - /* 0 */ 303, 273, 271, 273, 276, 246, 276, 248, 249, 278, - /* 10 */ 324, 325, 12, 13, 283, 2, 243, 243, 4, 272, - /* 20 */ 20, 293, 22, 293, 270, 12, 13, 14, 15, 16, - /* 30 */ 12, 13, 14, 15, 16, 273, 282, 309, 310, 309, - /* 40 */ 310, 246, 0, 248, 249, 271, 20, 47, 320, 242, - /* 50 */ 320, 244, 339, 279, 250, 293, 42, 43, 58, 20, - /* 60 */ 12, 13, 14, 289, 64, 352, 293, 293, 20, 356, - /* 70 */ 22, 309, 310, 299, 12, 13, 14, 15, 16, 251, - /* 80 */ 252, 81, 320, 279, 310, 80, 250, 313, 314, 315, - /* 90 */ 316, 317, 318, 88, 320, 47, 243, 323, 262, 57, - /* 100 */ 82, 327, 328, 103, 311, 269, 58, 81, 12, 13, - /* 110 */ 339, 273, 64, 339, 114, 279, 20, 311, 22, 289, - /* 120 */ 58, 317, 292, 352, 271, 295, 352, 356, 335, 81, - /* 130 */ 356, 293, 279, 14, 75, 331, 332, 333, 334, 20, - /* 140 */ 336, 335, 289, 47, 82, 81, 293, 309, 310, 250, - /* 150 */ 4, 103, 90, 256, 58, 150, 271, 260, 320, 159, - /* 160 */ 64, 262, 114, 310, 279, 57, 313, 314, 315, 316, - /* 170 */ 317, 318, 319, 320, 321, 322, 243, 81, 279, 120, - /* 180 */ 121, 181, 182, 20, 184, 185, 186, 187, 188, 189, - /* 190 */ 190, 191, 192, 193, 194, 195, 196, 197, 198, 103, - /* 200 */ 315, 255, 140, 55, 168, 169, 4, 159, 172, 21, - /* 210 */ 114, 211, 24, 25, 26, 27, 28, 29, 30, 31, - /* 220 */ 32, 243, 158, 277, 160, 163, 293, 81, 80, 181, - /* 230 */ 182, 83, 184, 185, 186, 187, 188, 189, 190, 191, - /* 240 */ 192, 193, 194, 195, 196, 197, 198, 0, 35, 20, - /* 250 */ 12, 13, 14, 15, 16, 159, 12, 13, 14, 15, - /* 260 */ 16, 199, 200, 201, 202, 203, 204, 205, 206, 207, - /* 270 */ 208, 293, 81, 240, 311, 211, 247, 181, 182, 250, + /* 0 */ 245, 272, 247, 248, 275, 245, 249, 247, 248, 310, + /* 10 */ 254, 4, 12, 13, 323, 324, 271, 242, 261, 272, + /* 20 */ 20, 292, 22, 267, 270, 268, 12, 13, 14, 15, + /* 30 */ 16, 277, 276, 334, 239, 278, 282, 308, 309, 292, + /* 40 */ 12, 13, 14, 15, 16, 270, 20, 47, 319, 42, + /* 50 */ 43, 20, 252, 278, 249, 308, 309, 20, 58, 22, + /* 60 */ 12, 13, 14, 288, 64, 265, 319, 292, 20, 20, + /* 70 */ 22, 249, 58, 273, 12, 13, 14, 15, 16, 288, + /* 80 */ 57, 81, 291, 278, 309, 294, 49, 312, 313, 314, + /* 90 */ 315, 316, 317, 298, 319, 47, 82, 322, 242, 242, + /* 100 */ 20, 326, 327, 103, 90, 283, 58, 81, 12, 13, + /* 110 */ 250, 251, 64, 113, 246, 338, 20, 249, 22, 272, + /* 120 */ 58, 316, 275, 270, 81, 47, 270, 272, 351, 81, + /* 130 */ 81, 278, 355, 338, 278, 330, 331, 332, 333, 292, + /* 140 */ 335, 81, 64, 47, 288, 4, 351, 292, 292, 292, + /* 150 */ 355, 103, 90, 139, 58, 308, 309, 254, 158, 0, + /* 160 */ 64, 113, 20, 308, 309, 309, 319, 314, 312, 313, + /* 170 */ 314, 315, 316, 317, 319, 319, 162, 81, 150, 276, + /* 180 */ 180, 181, 75, 183, 184, 185, 186, 187, 188, 189, + /* 190 */ 190, 191, 192, 193, 194, 195, 196, 197, 20, 103, + /* 200 */ 157, 139, 159, 167, 168, 242, 158, 171, 93, 113, + /* 210 */ 210, 20, 198, 199, 200, 201, 202, 203, 204, 205, + /* 220 */ 206, 207, 81, 241, 162, 243, 119, 120, 180, 181, + /* 230 */ 115, 183, 184, 185, 186, 187, 188, 189, 190, 191, + /* 240 */ 192, 193, 194, 195, 196, 197, 0, 12, 13, 14, + /* 250 */ 15, 16, 93, 210, 158, 292, 0, 180, 230, 210, + /* 260 */ 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + /* 270 */ 210, 112, 81, 114, 115, 116, 180, 181, 22, 183, /* 280 */ 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - /* 290 */ 194, 195, 196, 197, 198, 12, 13, 84, 335, 86, - /* 300 */ 87, 20, 89, 20, 185, 22, 93, 60, 61, 62, - /* 310 */ 63, 0, 65, 66, 67, 68, 69, 70, 71, 72, - /* 320 */ 73, 74, 75, 76, 77, 78, 60, 61, 255, 116, - /* 330 */ 47, 65, 299, 243, 68, 69, 93, 299, 72, 73, - /* 340 */ 74, 268, 250, 12, 13, 14, 14, 64, 20, 22, - /* 350 */ 277, 20, 20, 22, 262, 112, 113, 211, 115, 116, - /* 360 */ 117, 271, 81, 339, 81, 263, 243, 144, 57, 279, - /* 370 */ 140, 279, 339, 271, 47, 299, 352, 339, 47, 289, - /* 380 */ 356, 181, 280, 293, 146, 352, 103, 257, 258, 356, - /* 390 */ 352, 12, 13, 163, 356, 64, 20, 114, 22, 20, - /* 400 */ 310, 22, 211, 313, 314, 315, 316, 317, 318, 81, - /* 410 */ 320, 243, 81, 323, 212, 339, 293, 327, 328, 329, - /* 420 */ 220, 221, 222, 223, 224, 49, 47, 0, 352, 199, - /* 430 */ 289, 341, 356, 263, 103, 0, 295, 347, 348, 216, - /* 440 */ 217, 271, 159, 64, 0, 114, 247, 243, 21, 250, - /* 450 */ 280, 24, 25, 26, 27, 28, 29, 30, 31, 32, - /* 460 */ 81, 293, 257, 258, 181, 182, 22, 184, 185, 186, - /* 470 */ 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - /* 480 */ 197, 198, 103, 12, 13, 14, 15, 16, 0, 253, - /* 490 */ 159, 279, 211, 114, 211, 60, 61, 293, 286, 271, - /* 500 */ 65, 37, 250, 68, 69, 20, 278, 72, 73, 74, - /* 510 */ 274, 283, 181, 182, 262, 184, 185, 186, 187, 188, - /* 520 */ 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - /* 530 */ 41, 279, 12, 13, 14, 15, 16, 20, 159, 211, - /* 540 */ 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - /* 550 */ 104, 281, 106, 107, 108, 109, 110, 111, 288, 289, - /* 560 */ 181, 182, 243, 184, 185, 186, 187, 188, 189, 190, - /* 570 */ 191, 192, 193, 194, 195, 196, 197, 198, 12, 13, - /* 580 */ 18, 93, 20, 2, 1, 2, 20, 243, 22, 27, - /* 590 */ 3, 47, 30, 12, 13, 14, 15, 16, 288, 289, - /* 600 */ 112, 113, 82, 115, 116, 117, 33, 250, 64, 271, - /* 610 */ 48, 14, 293, 47, 0, 271, 278, 20, 45, 262, - /* 620 */ 250, 283, 151, 279, 51, 52, 53, 54, 55, 243, - /* 630 */ 64, 154, 262, 289, 42, 43, 279, 293, 24, 25, - /* 640 */ 26, 27, 28, 29, 30, 31, 32, 81, 250, 279, - /* 650 */ 20, 174, 175, 80, 310, 253, 83, 313, 314, 315, - /* 660 */ 316, 317, 318, 146, 320, 82, 271, 323, 266, 103, - /* 670 */ 250, 327, 328, 329, 210, 280, 274, 279, 250, 293, - /* 680 */ 114, 119, 338, 243, 122, 123, 124, 125, 126, 127, - /* 690 */ 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - /* 700 */ 138, 139, 231, 264, 284, 18, 267, 250, 92, 250, - /* 710 */ 23, 14, 15, 16, 141, 317, 143, 228, 145, 262, - /* 720 */ 147, 262, 35, 36, 57, 159, 39, 299, 269, 64, - /* 730 */ 332, 333, 334, 293, 336, 20, 279, 243, 279, 85, - /* 740 */ 167, 0, 88, 56, 243, 41, 243, 181, 182, 20, - /* 750 */ 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - /* 760 */ 194, 195, 196, 197, 198, 271, 243, 339, 81, 250, - /* 770 */ 259, 263, 261, 279, 12, 13, 14, 15, 16, 271, - /* 780 */ 352, 262, 185, 289, 356, 209, 210, 293, 280, 250, - /* 790 */ 250, 243, 0, 299, 293, 250, 293, 243, 279, 272, - /* 800 */ 93, 262, 262, 250, 310, 118, 250, 313, 314, 315, - /* 810 */ 316, 317, 318, 226, 320, 262, 293, 323, 279, 279, - /* 820 */ 58, 327, 328, 116, 279, 243, 170, 171, 85, 0, - /* 830 */ 250, 88, 279, 339, 93, 279, 243, 45, 151, 152, - /* 840 */ 153, 293, 262, 156, 299, 22, 352, 293, 161, 243, - /* 850 */ 356, 22, 90, 112, 113, 243, 115, 116, 117, 279, - /* 860 */ 173, 146, 317, 176, 271, 178, 179, 180, 243, 243, - /* 870 */ 47, 58, 279, 317, 41, 293, 272, 332, 333, 334, - /* 880 */ 85, 336, 289, 88, 339, 81, 293, 64, 332, 333, - /* 890 */ 334, 146, 336, 85, 149, 91, 88, 352, 211, 293, - /* 900 */ 271, 356, 140, 310, 243, 293, 313, 314, 315, 316, - /* 910 */ 317, 318, 283, 320, 185, 82, 323, 0, 293, 293, - /* 920 */ 327, 328, 329, 21, 250, 163, 103, 1, 2, 196, - /* 930 */ 197, 41, 271, 244, 230, 47, 34, 114, 272, 22, - /* 940 */ 279, 348, 41, 44, 41, 47, 260, 272, 272, 272, - /* 950 */ 289, 41, 41, 279, 293, 41, 41, 41, 359, 41, - /* 960 */ 41, 199, 200, 201, 202, 203, 204, 205, 206, 207, - /* 970 */ 208, 310, 82, 299, 313, 314, 315, 316, 317, 318, - /* 980 */ 81, 320, 159, 82, 323, 82, 41, 243, 327, 328, - /* 990 */ 329, 317, 82, 82, 181, 41, 82, 82, 82, 338, - /* 1000 */ 82, 82, 114, 41, 181, 182, 332, 333, 334, 41, - /* 1010 */ 336, 41, 114, 339, 47, 271, 307, 344, 350, 243, - /* 1020 */ 271, 249, 41, 279, 251, 312, 352, 82, 282, 337, - /* 1030 */ 356, 64, 353, 289, 353, 353, 82, 293, 340, 20, - /* 1040 */ 250, 45, 308, 257, 82, 47, 157, 271, 301, 243, - /* 1050 */ 82, 250, 82, 250, 310, 279, 40, 313, 314, 315, - /* 1060 */ 316, 317, 318, 82, 320, 289, 287, 323, 140, 293, - /* 1070 */ 285, 327, 328, 329, 285, 299, 250, 271, 20, 245, - /* 1080 */ 245, 20, 338, 305, 20, 279, 310, 255, 289, 313, - /* 1090 */ 314, 315, 316, 317, 318, 289, 320, 255, 20, 293, - /* 1100 */ 300, 255, 297, 255, 297, 299, 279, 243, 20, 290, - /* 1110 */ 4, 255, 255, 250, 255, 339, 310, 245, 271, 313, - /* 1120 */ 314, 315, 316, 317, 318, 19, 320, 250, 352, 271, - /* 1130 */ 245, 271, 356, 271, 64, 271, 271, 271, 271, 33, - /* 1140 */ 271, 271, 271, 279, 271, 339, 293, 243, 305, 253, - /* 1150 */ 166, 45, 297, 289, 304, 279, 50, 293, 352, 253, - /* 1160 */ 253, 55, 356, 289, 20, 290, 243, 219, 218, 349, - /* 1170 */ 349, 225, 293, 253, 310, 271, 294, 313, 314, 315, - /* 1180 */ 316, 317, 318, 279, 320, 294, 80, 323, 293, 83, - /* 1190 */ 312, 327, 328, 289, 271, 346, 148, 293, 243, 345, - /* 1200 */ 214, 293, 279, 213, 343, 210, 279, 20, 311, 40, - /* 1210 */ 342, 330, 289, 81, 310, 227, 293, 313, 314, 315, - /* 1220 */ 316, 317, 318, 229, 320, 232, 271, 323, 294, 293, - /* 1230 */ 293, 327, 328, 310, 279, 355, 313, 314, 315, 316, - /* 1240 */ 317, 318, 293, 320, 289, 294, 354, 360, 293, 355, - /* 1250 */ 326, 143, 291, 19, 354, 279, 290, 253, 267, 253, - /* 1260 */ 355, 279, 81, 243, 275, 310, 354, 33, 313, 314, - /* 1270 */ 315, 316, 317, 318, 261, 320, 250, 253, 323, 45, - /* 1280 */ 357, 358, 245, 328, 306, 51, 52, 53, 54, 55, - /* 1290 */ 265, 271, 265, 265, 302, 298, 254, 241, 0, 279, - /* 1300 */ 0, 72, 0, 47, 177, 47, 47, 47, 177, 289, - /* 1310 */ 0, 243, 47, 293, 80, 47, 296, 83, 177, 0, - /* 1320 */ 47, 0, 47, 0, 47, 0, 81, 163, 162, 114, - /* 1330 */ 310, 159, 0, 313, 314, 315, 316, 317, 318, 271, - /* 1340 */ 320, 0, 0, 155, 154, 0, 0, 279, 44, 0, - /* 1350 */ 0, 117, 0, 0, 0, 0, 0, 289, 0, 243, - /* 1360 */ 0, 293, 0, 0, 0, 0, 0, 0, 243, 0, - /* 1370 */ 0, 40, 0, 0, 0, 0, 142, 0, 310, 145, - /* 1380 */ 0, 313, 314, 315, 316, 317, 318, 271, 320, 0, - /* 1390 */ 22, 0, 0, 0, 0, 279, 271, 40, 37, 165, - /* 1400 */ 0, 167, 14, 44, 279, 289, 0, 0, 0, 293, - /* 1410 */ 14, 0, 41, 0, 289, 148, 38, 0, 293, 351, - /* 1420 */ 44, 296, 243, 37, 37, 0, 310, 37, 0, 313, - /* 1430 */ 314, 315, 316, 317, 318, 310, 320, 243, 313, 314, - /* 1440 */ 315, 316, 317, 318, 59, 320, 0, 45, 47, 37, - /* 1450 */ 271, 0, 47, 37, 45, 0, 37, 47, 279, 45, - /* 1460 */ 0, 37, 47, 45, 0, 271, 0, 0, 289, 0, - /* 1470 */ 243, 90, 293, 279, 358, 22, 47, 0, 47, 47, - /* 1480 */ 47, 47, 41, 289, 41, 243, 88, 293, 0, 310, - /* 1490 */ 296, 47, 313, 314, 315, 316, 317, 318, 271, 320, - /* 1500 */ 22, 322, 0, 47, 310, 47, 279, 313, 314, 315, - /* 1510 */ 316, 317, 318, 271, 320, 0, 289, 22, 48, 22, - /* 1520 */ 293, 279, 47, 296, 0, 243, 22, 0, 22, 20, - /* 1530 */ 0, 289, 47, 0, 22, 293, 0, 310, 143, 0, - /* 1540 */ 313, 314, 315, 316, 317, 318, 0, 320, 164, 146, - /* 1550 */ 146, 37, 310, 271, 81, 313, 314, 315, 316, 317, - /* 1560 */ 318, 279, 320, 141, 41, 82, 41, 41, 82, 82, - /* 1570 */ 81, 289, 81, 81, 2, 293, 41, 243, 44, 81, - /* 1580 */ 81, 44, 82, 41, 44, 82, 41, 44, 41, 82, - /* 1590 */ 82, 47, 310, 41, 215, 313, 314, 315, 316, 317, - /* 1600 */ 318, 47, 320, 47, 47, 271, 47, 47, 181, 44, - /* 1610 */ 82, 82, 81, 279, 215, 44, 22, 0, 183, 81, - /* 1620 */ 144, 37, 141, 289, 44, 243, 44, 293, 59, 209, - /* 1630 */ 81, 22, 82, 82, 47, 47, 215, 47, 47, 81, - /* 1640 */ 243, 22, 81, 81, 310, 81, 91, 313, 314, 315, - /* 1650 */ 316, 317, 318, 271, 320, 81, 93, 82, 81, 81, - /* 1660 */ 92, 279, 47, 82, 81, 47, 22, 82, 271, 47, - /* 1670 */ 81, 289, 105, 243, 82, 293, 279, 81, 105, 82, - /* 1680 */ 81, 105, 82, 81, 105, 81, 289, 47, 81, 81, - /* 1690 */ 293, 58, 310, 47, 64, 313, 314, 315, 316, 317, - /* 1700 */ 318, 271, 320, 79, 41, 47, 47, 310, 47, 279, - /* 1710 */ 313, 314, 315, 316, 317, 318, 22, 320, 47, 289, - /* 1720 */ 47, 47, 47, 293, 114, 47, 64, 243, 47, 47, - /* 1730 */ 47, 47, 47, 47, 0, 47, 243, 45, 37, 0, - /* 1740 */ 310, 45, 47, 313, 314, 315, 316, 317, 318, 37, - /* 1750 */ 320, 0, 47, 45, 37, 271, 47, 37, 45, 0, - /* 1760 */ 0, 47, 46, 279, 271, 0, 0, 22, 21, 361, - /* 1770 */ 22, 22, 279, 289, 21, 20, 361, 293, 361, 361, - /* 1780 */ 361, 361, 289, 361, 243, 361, 293, 361, 361, 361, - /* 1790 */ 361, 361, 361, 361, 310, 361, 243, 313, 314, 315, - /* 1800 */ 316, 317, 318, 310, 320, 361, 313, 314, 315, 316, - /* 1810 */ 317, 318, 271, 320, 361, 361, 361, 361, 361, 361, - /* 1820 */ 279, 361, 361, 361, 271, 361, 361, 361, 361, 361, - /* 1830 */ 289, 361, 279, 361, 293, 361, 243, 361, 361, 361, - /* 1840 */ 361, 361, 289, 361, 361, 361, 293, 361, 361, 243, - /* 1850 */ 361, 310, 361, 361, 313, 314, 315, 316, 317, 318, - /* 1860 */ 361, 320, 361, 310, 271, 361, 313, 314, 315, 316, - /* 1870 */ 317, 318, 279, 320, 361, 361, 361, 271, 361, 361, - /* 1880 */ 361, 361, 289, 361, 361, 279, 293, 361, 361, 361, - /* 1890 */ 361, 361, 361, 361, 361, 289, 361, 243, 361, 293, - /* 1900 */ 361, 361, 361, 310, 361, 361, 313, 314, 315, 316, - /* 1910 */ 317, 318, 243, 320, 361, 361, 310, 361, 361, 313, - /* 1920 */ 314, 315, 316, 317, 318, 271, 320, 361, 361, 361, - /* 1930 */ 361, 361, 361, 279, 361, 361, 361, 361, 361, 361, - /* 1940 */ 271, 361, 361, 289, 361, 243, 361, 293, 279, 361, - /* 1950 */ 361, 361, 361, 12, 13, 361, 361, 361, 289, 361, - /* 1960 */ 361, 361, 293, 22, 310, 361, 361, 313, 314, 315, - /* 1970 */ 316, 317, 318, 271, 320, 361, 361, 361, 361, 310, - /* 1980 */ 361, 279, 313, 314, 315, 316, 317, 318, 47, 320, - /* 1990 */ 361, 289, 361, 361, 361, 293, 361, 361, 361, 243, - /* 2000 */ 361, 361, 361, 361, 361, 64, 361, 361, 361, 361, - /* 2010 */ 361, 361, 310, 361, 361, 313, 314, 315, 316, 317, - /* 2020 */ 318, 361, 320, 361, 361, 361, 361, 271, 361, 361, - /* 2030 */ 361, 361, 361, 361, 361, 279, 361, 361, 361, 361, - /* 2040 */ 361, 361, 361, 361, 103, 289, 361, 361, 361, 293, - /* 2050 */ 361, 361, 361, 361, 361, 114, 361, 361, 361, 361, - /* 2060 */ 361, 361, 361, 361, 361, 361, 310, 361, 361, 313, - /* 2070 */ 314, 315, 316, 317, 318, 361, 320, 361, 361, 361, - /* 2080 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, - /* 2090 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, - /* 2100 */ 159, 361, 361, 361, 361, 361, 361, 361, 361, 361, - /* 2110 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, - /* 2120 */ 361, 361, 181, 361, 361, 361, 361, 361, 361, 361, - /* 2130 */ 361, 361, 361, 192, 193, 194, 361, 361, 361, 361, - /* 2140 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, - /* 2150 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, - /* 2160 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, - /* 2170 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, - /* 2180 */ 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, - /* 2190 */ 361, 361, 361, 361, + /* 290 */ 194, 195, 196, 197, 12, 13, 219, 220, 221, 222, + /* 300 */ 223, 255, 20, 55, 22, 259, 60, 61, 62, 63, + /* 310 */ 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, + /* 320 */ 74, 75, 76, 77, 78, 20, 93, 0, 80, 47, + /* 330 */ 21, 83, 242, 24, 25, 26, 27, 28, 29, 30, + /* 340 */ 31, 32, 12, 13, 14, 112, 64, 114, 115, 116, + /* 350 */ 20, 210, 22, 60, 61, 14, 15, 16, 65, 92, + /* 360 */ 270, 68, 69, 81, 14, 72, 73, 74, 278, 269, + /* 370 */ 20, 12, 13, 14, 15, 16, 338, 47, 288, 338, + /* 380 */ 145, 281, 292, 246, 57, 103, 249, 20, 143, 351, + /* 390 */ 12, 13, 351, 355, 64, 113, 355, 21, 20, 309, + /* 400 */ 22, 210, 312, 313, 314, 315, 316, 317, 310, 319, + /* 410 */ 34, 81, 256, 257, 94, 95, 96, 97, 98, 99, + /* 420 */ 100, 101, 102, 103, 104, 47, 106, 107, 108, 109, + /* 430 */ 110, 111, 334, 103, 0, 12, 13, 14, 15, 16, + /* 440 */ 158, 82, 64, 113, 2, 280, 356, 357, 263, 249, + /* 450 */ 145, 266, 287, 288, 12, 13, 14, 15, 16, 81, + /* 460 */ 215, 216, 180, 181, 249, 183, 184, 185, 186, 187, + /* 470 */ 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + /* 480 */ 242, 103, 12, 13, 14, 15, 16, 271, 158, 270, + /* 490 */ 278, 113, 210, 278, 60, 61, 277, 285, 298, 65, + /* 500 */ 298, 282, 68, 69, 0, 82, 72, 73, 74, 20, + /* 510 */ 180, 181, 249, 183, 184, 185, 186, 187, 188, 189, + /* 520 */ 190, 191, 192, 193, 194, 195, 196, 197, 1, 2, + /* 530 */ 292, 316, 270, 139, 184, 22, 158, 262, 338, 277, + /* 540 */ 338, 278, 256, 257, 282, 270, 331, 332, 333, 242, + /* 550 */ 335, 351, 35, 351, 279, 355, 162, 355, 180, 181, + /* 560 */ 47, 183, 184, 185, 186, 187, 188, 189, 190, 191, + /* 570 */ 192, 193, 194, 195, 196, 197, 12, 13, 18, 316, + /* 580 */ 20, 80, 287, 288, 20, 242, 22, 27, 249, 88, + /* 590 */ 30, 310, 198, 249, 331, 332, 333, 93, 335, 292, + /* 600 */ 261, 84, 37, 86, 87, 261, 89, 268, 48, 82, + /* 610 */ 93, 47, 0, 270, 242, 334, 112, 278, 114, 115, + /* 620 */ 116, 278, 278, 14, 288, 242, 153, 271, 64, 20, + /* 630 */ 294, 288, 115, 21, 145, 292, 24, 25, 26, 27, + /* 640 */ 28, 29, 30, 31, 32, 81, 173, 174, 14, 0, + /* 650 */ 149, 252, 309, 20, 20, 312, 313, 314, 315, 316, + /* 660 */ 317, 298, 319, 64, 292, 322, 258, 103, 260, 326, + /* 670 */ 327, 328, 273, 242, 271, 292, 3, 113, 118, 41, + /* 680 */ 337, 121, 122, 123, 124, 125, 126, 127, 128, 129, + /* 690 */ 130, 131, 132, 133, 134, 135, 136, 137, 138, 2, + /* 700 */ 22, 338, 41, 19, 249, 58, 57, 262, 270, 12, + /* 710 */ 13, 14, 15, 16, 351, 270, 261, 33, 355, 242, + /* 720 */ 282, 270, 158, 292, 279, 47, 242, 4, 242, 45, + /* 730 */ 279, 271, 242, 278, 242, 51, 52, 53, 54, 55, + /* 740 */ 42, 43, 64, 82, 180, 181, 271, 183, 184, 185, + /* 750 */ 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + /* 760 */ 196, 197, 270, 249, 80, 249, 41, 83, 0, 292, + /* 770 */ 278, 262, 243, 249, 209, 261, 292, 261, 292, 270, + /* 780 */ 288, 103, 292, 242, 292, 261, 249, 249, 279, 242, + /* 790 */ 298, 113, 278, 184, 278, 242, 208, 209, 302, 261, + /* 800 */ 116, 309, 278, 41, 312, 313, 314, 315, 316, 317, + /* 810 */ 242, 319, 249, 45, 322, 278, 278, 184, 326, 327, + /* 820 */ 249, 81, 249, 242, 261, 141, 85, 180, 144, 88, + /* 830 */ 338, 91, 261, 292, 261, 298, 158, 85, 270, 292, + /* 840 */ 88, 278, 0, 351, 82, 292, 278, 355, 164, 278, + /* 850 */ 166, 278, 242, 316, 85, 271, 288, 88, 180, 181, + /* 860 */ 292, 242, 242, 242, 22, 227, 298, 249, 331, 332, + /* 870 */ 333, 242, 335, 292, 4, 338, 259, 309, 358, 261, + /* 880 */ 312, 313, 314, 315, 316, 317, 0, 319, 351, 19, + /* 890 */ 322, 349, 355, 249, 326, 327, 278, 85, 225, 270, + /* 900 */ 88, 145, 292, 33, 148, 261, 338, 278, 22, 18, + /* 910 */ 306, 292, 292, 292, 23, 45, 47, 288, 343, 351, + /* 920 */ 50, 292, 278, 355, 41, 55, 35, 36, 169, 170, + /* 930 */ 39, 248, 242, 64, 211, 47, 41, 270, 309, 195, + /* 940 */ 196, 312, 313, 314, 315, 316, 317, 56, 319, 250, + /* 950 */ 80, 322, 281, 83, 229, 326, 327, 328, 1, 2, + /* 960 */ 270, 0, 47, 311, 336, 82, 352, 352, 278, 340, + /* 970 */ 41, 339, 81, 20, 41, 346, 347, 82, 288, 352, + /* 980 */ 249, 41, 292, 44, 41, 24, 25, 26, 27, 28, + /* 990 */ 29, 30, 31, 32, 45, 41, 307, 41, 47, 309, + /* 1000 */ 249, 113, 312, 313, 314, 315, 316, 317, 117, 319, + /* 1010 */ 256, 82, 322, 300, 156, 82, 326, 327, 328, 41, + /* 1020 */ 81, 249, 82, 41, 41, 82, 249, 40, 113, 278, + /* 1030 */ 41, 286, 41, 41, 41, 139, 82, 347, 82, 284, + /* 1040 */ 249, 150, 151, 152, 242, 284, 155, 20, 244, 298, + /* 1050 */ 244, 160, 20, 304, 254, 288, 20, 254, 20, 296, + /* 1060 */ 82, 254, 296, 172, 82, 82, 175, 316, 177, 178, + /* 1070 */ 179, 82, 270, 82, 82, 82, 254, 299, 20, 278, + /* 1080 */ 278, 289, 331, 332, 333, 254, 335, 254, 249, 338, + /* 1090 */ 288, 254, 244, 270, 292, 270, 270, 270, 270, 242, + /* 1100 */ 270, 210, 351, 249, 270, 270, 355, 244, 270, 64, + /* 1110 */ 270, 309, 292, 270, 312, 313, 314, 315, 316, 317, + /* 1120 */ 304, 319, 303, 252, 322, 165, 252, 270, 326, 327, + /* 1130 */ 328, 252, 288, 278, 289, 278, 252, 296, 20, 337, + /* 1140 */ 311, 218, 348, 217, 293, 288, 348, 147, 292, 292, + /* 1150 */ 242, 224, 293, 292, 292, 345, 342, 344, 213, 212, + /* 1160 */ 278, 209, 242, 20, 40, 341, 309, 226, 353, 312, + /* 1170 */ 313, 314, 315, 316, 317, 310, 319, 231, 270, 322, + /* 1180 */ 359, 329, 81, 326, 327, 328, 278, 228, 142, 353, + /* 1190 */ 270, 325, 293, 292, 337, 292, 288, 293, 278, 353, + /* 1200 */ 292, 354, 292, 354, 354, 289, 298, 290, 288, 278, + /* 1210 */ 252, 81, 292, 278, 266, 242, 252, 309, 298, 249, + /* 1220 */ 312, 313, 314, 315, 316, 317, 252, 319, 260, 309, + /* 1230 */ 244, 301, 312, 313, 314, 315, 316, 317, 240, 319, + /* 1240 */ 274, 305, 0, 270, 264, 264, 338, 297, 242, 264, + /* 1250 */ 253, 278, 0, 72, 0, 47, 176, 47, 338, 351, + /* 1260 */ 47, 288, 47, 355, 176, 292, 0, 47, 47, 176, + /* 1270 */ 0, 351, 47, 0, 47, 355, 270, 0, 47, 0, + /* 1280 */ 81, 162, 309, 161, 278, 312, 313, 314, 315, 316, + /* 1290 */ 317, 113, 319, 158, 288, 322, 0, 0, 292, 326, + /* 1300 */ 327, 154, 153, 0, 0, 44, 242, 0, 0, 0, + /* 1310 */ 0, 0, 0, 0, 0, 309, 40, 0, 312, 313, + /* 1320 */ 314, 315, 316, 317, 318, 319, 320, 321, 0, 0, + /* 1330 */ 0, 0, 0, 0, 270, 0, 0, 0, 0, 0, + /* 1340 */ 0, 0, 278, 0, 0, 22, 0, 0, 0, 0, + /* 1350 */ 0, 0, 288, 0, 242, 40, 292, 37, 0, 41, + /* 1360 */ 38, 37, 0, 44, 0, 44, 14, 242, 0, 14, + /* 1370 */ 147, 37, 0, 309, 0, 0, 312, 313, 314, 315, + /* 1380 */ 316, 317, 270, 319, 59, 0, 322, 0, 0, 47, + /* 1390 */ 278, 327, 47, 37, 37, 270, 37, 0, 0, 45, + /* 1400 */ 288, 0, 0, 278, 292, 45, 37, 295, 47, 0, + /* 1410 */ 45, 45, 22, 288, 47, 242, 90, 292, 37, 0, + /* 1420 */ 47, 309, 0, 47, 312, 313, 314, 315, 316, 317, + /* 1430 */ 47, 319, 41, 47, 309, 41, 47, 312, 313, 314, + /* 1440 */ 315, 316, 317, 270, 319, 22, 47, 47, 0, 22, + /* 1450 */ 47, 278, 48, 0, 47, 22, 0, 22, 88, 0, + /* 1460 */ 22, 288, 20, 0, 47, 292, 242, 0, 163, 22, + /* 1470 */ 0, 0, 145, 0, 81, 350, 37, 242, 41, 214, + /* 1480 */ 44, 41, 309, 214, 41, 312, 313, 314, 315, 316, + /* 1490 */ 317, 81, 319, 82, 270, 82, 81, 81, 41, 44, + /* 1500 */ 82, 81, 278, 41, 44, 270, 82, 82, 145, 208, + /* 1510 */ 41, 140, 288, 278, 214, 47, 292, 41, 44, 295, + /* 1520 */ 142, 2, 47, 288, 47, 242, 82, 292, 82, 47, + /* 1530 */ 357, 47, 47, 309, 41, 81, 312, 313, 314, 315, + /* 1540 */ 316, 317, 44, 319, 309, 44, 82, 312, 313, 314, + /* 1550 */ 315, 316, 317, 270, 319, 22, 321, 180, 242, 0, + /* 1560 */ 82, 278, 81, 37, 182, 44, 44, 81, 81, 143, + /* 1570 */ 82, 288, 82, 81, 140, 292, 81, 81, 295, 82, + /* 1580 */ 81, 81, 91, 81, 22, 81, 270, 82, 47, 47, + /* 1590 */ 82, 81, 309, 47, 278, 312, 313, 314, 315, 316, + /* 1600 */ 317, 92, 319, 47, 288, 81, 22, 82, 292, 81, + /* 1610 */ 47, 295, 82, 81, 47, 47, 82, 81, 81, 105, + /* 1620 */ 105, 242, 105, 105, 93, 309, 33, 58, 312, 313, + /* 1630 */ 314, 315, 316, 317, 242, 319, 81, 22, 45, 81, + /* 1640 */ 113, 59, 47, 64, 51, 52, 53, 54, 55, 270, + /* 1650 */ 79, 41, 22, 47, 47, 47, 47, 278, 47, 47, + /* 1660 */ 47, 64, 270, 47, 47, 47, 47, 288, 47, 47, + /* 1670 */ 278, 292, 47, 80, 242, 0, 83, 45, 47, 37, + /* 1680 */ 288, 0, 47, 45, 292, 37, 0, 47, 309, 45, + /* 1690 */ 37, 312, 313, 314, 315, 316, 317, 0, 319, 47, + /* 1700 */ 45, 309, 270, 37, 312, 313, 314, 315, 316, 317, + /* 1710 */ 278, 319, 0, 0, 47, 46, 0, 22, 22, 21, + /* 1720 */ 288, 22, 21, 20, 292, 242, 360, 360, 360, 360, + /* 1730 */ 360, 360, 360, 140, 360, 142, 360, 144, 360, 146, + /* 1740 */ 360, 309, 360, 360, 312, 313, 314, 315, 316, 317, + /* 1750 */ 360, 319, 360, 270, 360, 242, 360, 360, 360, 166, + /* 1760 */ 360, 278, 360, 360, 360, 360, 360, 360, 360, 360, + /* 1770 */ 360, 288, 360, 360, 360, 292, 360, 360, 360, 360, + /* 1780 */ 360, 360, 360, 270, 360, 360, 360, 242, 360, 360, + /* 1790 */ 360, 278, 309, 360, 360, 312, 313, 314, 315, 316, + /* 1800 */ 317, 288, 319, 360, 360, 292, 360, 360, 360, 360, + /* 1810 */ 360, 360, 360, 360, 360, 270, 360, 360, 360, 360, + /* 1820 */ 360, 360, 309, 278, 360, 312, 313, 314, 315, 316, + /* 1830 */ 317, 360, 319, 288, 360, 360, 360, 292, 242, 360, + /* 1840 */ 360, 360, 360, 360, 360, 360, 360, 242, 360, 360, + /* 1850 */ 360, 360, 360, 360, 309, 360, 360, 312, 313, 314, + /* 1860 */ 315, 316, 317, 360, 319, 360, 270, 360, 360, 360, + /* 1870 */ 360, 360, 360, 360, 278, 270, 360, 360, 360, 360, + /* 1880 */ 360, 360, 360, 278, 288, 360, 360, 360, 292, 360, + /* 1890 */ 360, 360, 360, 288, 360, 360, 360, 292, 360, 360, + /* 1900 */ 242, 360, 360, 360, 360, 309, 360, 360, 312, 313, + /* 1910 */ 314, 315, 316, 317, 309, 319, 242, 312, 313, 314, + /* 1920 */ 315, 316, 317, 360, 319, 360, 360, 360, 270, 360, + /* 1930 */ 360, 360, 360, 360, 360, 360, 278, 360, 360, 360, + /* 1940 */ 360, 360, 360, 360, 270, 360, 288, 360, 242, 360, + /* 1950 */ 292, 360, 278, 360, 360, 360, 360, 360, 360, 360, + /* 1960 */ 360, 360, 288, 360, 360, 360, 292, 309, 360, 360, + /* 1970 */ 312, 313, 314, 315, 316, 317, 270, 319, 242, 360, + /* 1980 */ 360, 360, 360, 309, 278, 360, 312, 313, 314, 315, + /* 1990 */ 316, 317, 360, 319, 288, 360, 360, 360, 292, 360, + /* 2000 */ 360, 360, 360, 360, 360, 360, 270, 360, 360, 360, + /* 2010 */ 360, 360, 360, 360, 278, 309, 360, 360, 312, 313, + /* 2020 */ 314, 315, 316, 317, 288, 319, 242, 360, 292, 360, + /* 2030 */ 360, 12, 13, 360, 360, 242, 360, 360, 360, 360, + /* 2040 */ 360, 22, 360, 360, 360, 309, 360, 360, 312, 313, + /* 2050 */ 314, 315, 316, 317, 270, 319, 360, 360, 360, 360, + /* 2060 */ 360, 360, 278, 270, 360, 360, 47, 360, 360, 360, + /* 2070 */ 360, 278, 288, 360, 360, 360, 292, 360, 360, 360, + /* 2080 */ 360, 288, 360, 64, 360, 292, 360, 360, 360, 360, + /* 2090 */ 242, 360, 360, 309, 360, 360, 312, 313, 314, 315, + /* 2100 */ 316, 317, 309, 319, 360, 312, 313, 314, 315, 316, + /* 2110 */ 317, 360, 319, 360, 360, 360, 360, 360, 270, 360, + /* 2120 */ 360, 360, 103, 360, 360, 360, 278, 360, 360, 360, + /* 2130 */ 360, 360, 113, 360, 360, 360, 288, 360, 360, 360, + /* 2140 */ 292, 360, 360, 360, 360, 360, 360, 360, 360, 360, + /* 2150 */ 360, 360, 360, 360, 360, 360, 360, 309, 360, 360, + /* 2160 */ 312, 313, 314, 315, 316, 317, 360, 319, 360, 360, + /* 2170 */ 360, 360, 360, 360, 360, 360, 360, 158, 360, 360, + /* 2180 */ 360, 360, 360, 360, 360, 360, 360, 360, 360, 360, + /* 2190 */ 360, 360, 360, 360, 360, 360, 360, 360, 360, 180, + /* 2200 */ 360, 360, 360, 360, 360, 360, 360, 360, 360, 360, + /* 2210 */ 191, 192, 193, 360, 360, 360, 360, 360, 360, 360, + /* 2220 */ 360, 360, 360, 360, 360, 360, 360, 360, 360, 360, + /* 2230 */ 360, 360, 360, 360, 360, 360, 360, 360, 360, 360, + /* 2240 */ 360, 360, 360, 360, 360, 360, 360, 360, 360, 360, + /* 2250 */ 360, 360, 360, 360, 360, 360, 360, 360, 360, 360, + /* 2260 */ 360, 360, 360, 360, 360, 360, 360, 360, 360, 360, + /* 2270 */ 360, }; -#define YY_SHIFT_COUNT (611) +#define YY_SHIFT_COUNT (610) #define YY_SHIFT_MIN (0) -#define YY_SHIFT_MAX (1941) +#define YY_SHIFT_MAX (2019) static const unsigned short int yy_shift_ofst[] = { - /* 0 */ 687, 0, 0, 48, 96, 96, 96, 96, 283, 283, - /* 10 */ 96, 96, 331, 379, 566, 379, 379, 379, 379, 379, - /* 20 */ 379, 379, 379, 379, 379, 379, 379, 379, 379, 379, - /* 30 */ 379, 379, 379, 379, 379, 379, 379, 379, 281, 281, - /* 40 */ 26, 26, 26, 1941, 1941, 1941, 1941, 328, 64, 191, - /* 50 */ 39, 39, 14, 14, 146, 191, 191, 39, 39, 39, - /* 60 */ 39, 39, 39, 108, 39, 163, 229, 485, 163, 39, - /* 70 */ 39, 163, 39, 163, 163, 485, 163, 39, 667, 562, - /* 80 */ 62, 762, 762, 188, 266, 823, 823, 823, 823, 823, - /* 90 */ 823, 823, 823, 823, 823, 823, 823, 823, 823, 823, - /* 100 */ 823, 823, 823, 823, 213, 376, 332, 332, 42, 544, - /* 110 */ 517, 517, 517, 311, 544, 630, 485, 163, 163, 485, - /* 120 */ 616, 665, 446, 446, 446, 446, 446, 446, 446, 1234, - /* 130 */ 427, 435, 471, 200, 36, 223, 119, 597, 592, 327, - /* 140 */ 707, 715, 576, 464, 576, 587, 587, 587, 202, 729, - /* 150 */ 1019, 996, 998, 889, 1019, 1019, 1016, 928, 928, 1019, - /* 160 */ 1058, 1058, 1061, 108, 485, 108, 1064, 1078, 108, 1064, - /* 170 */ 108, 630, 1088, 108, 108, 1019, 108, 1058, 163, 163, - /* 180 */ 163, 163, 163, 163, 163, 163, 163, 163, 163, 1019, - /* 190 */ 1058, 1070, 1061, 667, 984, 485, 667, 1064, 667, 630, - /* 200 */ 1088, 667, 1144, 948, 950, 1070, 948, 950, 1070, 1070, - /* 210 */ 163, 946, 1048, 986, 990, 995, 630, 1187, 1169, 994, - /* 220 */ 988, 993, 994, 988, 994, 988, 1132, 950, 1070, 1070, - /* 230 */ 950, 1070, 1108, 630, 1088, 667, 616, 667, 630, 1181, - /* 240 */ 665, 1019, 667, 1058, 2136, 2136, 2136, 2136, 2136, 2136, - /* 250 */ 2136, 2136, 247, 573, 614, 1106, 488, 741, 18, 13, - /* 260 */ 581, 238, 520, 243, 244, 244, 244, 244, 244, 244, - /* 270 */ 244, 244, 477, 148, 59, 5, 583, 230, 697, 697, - /* 280 */ 697, 697, 792, 833, 654, 743, 795, 808, 444, 829, - /* 290 */ 917, 902, 656, 745, 890, 901, 903, 926, 733, 489, - /* 300 */ 704, 910, 813, 911, 899, 914, 915, 916, 918, 919, - /* 310 */ 888, 898, 945, 954, 962, 968, 970, 981, 804, 967, - /* 320 */ 1298, 1300, 1229, 1302, 1256, 1127, 1258, 1259, 1260, 1131, - /* 330 */ 1310, 1265, 1268, 1141, 1319, 1273, 1321, 1275, 1323, 1277, - /* 340 */ 1325, 1245, 1164, 1166, 1215, 1172, 1332, 1341, 1188, 1190, - /* 350 */ 1342, 1345, 1304, 1346, 1349, 1350, 1352, 1353, 1354, 1355, - /* 360 */ 1356, 1358, 1360, 1362, 1363, 1364, 1365, 1366, 1367, 1369, - /* 370 */ 1370, 1331, 1372, 1373, 1374, 1375, 1377, 1380, 1368, 1389, - /* 380 */ 1391, 1392, 1393, 1394, 1400, 1357, 1361, 1371, 1388, 1359, - /* 390 */ 1396, 1376, 1406, 1378, 1386, 1407, 1408, 1411, 1387, 1267, - /* 400 */ 1413, 1417, 1390, 1425, 1385, 1428, 1446, 1401, 1402, 1412, - /* 410 */ 1451, 1405, 1409, 1416, 1455, 1410, 1414, 1419, 1460, 1415, - /* 420 */ 1418, 1424, 1464, 1466, 1467, 1469, 1381, 1398, 1429, 1453, - /* 430 */ 1477, 1431, 1432, 1433, 1434, 1441, 1443, 1444, 1456, 1458, - /* 440 */ 1488, 1478, 1502, 1495, 1470, 1515, 1497, 1475, 1524, 1504, - /* 450 */ 1527, 1506, 1509, 1530, 1403, 1485, 1533, 1384, 1512, 1404, - /* 460 */ 1395, 1536, 1539, 1546, 1473, 1514, 1422, 1523, 1525, 1379, - /* 470 */ 1483, 1526, 1486, 1489, 1491, 1492, 1487, 1535, 1534, 1537, - /* 480 */ 1498, 1542, 1399, 1500, 1503, 1540, 1420, 1545, 1543, 1507, - /* 490 */ 1547, 1421, 1508, 1544, 1554, 1556, 1557, 1559, 1560, 1508, - /* 500 */ 1572, 1427, 1552, 1528, 1499, 1529, 1565, 1531, 1538, 1571, - /* 510 */ 1594, 1435, 1549, 1550, 1551, 1558, 1561, 1476, 1562, 1617, - /* 520 */ 1584, 1481, 1564, 1555, 1580, 1582, 1574, 1575, 1577, 1609, - /* 530 */ 1578, 1568, 1581, 1587, 1588, 1583, 1585, 1590, 1589, 1592, - /* 540 */ 1591, 1596, 1597, 1615, 1599, 1600, 1618, 1602, 1567, 1573, - /* 550 */ 1576, 1579, 1619, 1563, 1604, 1607, 1622, 1608, 1610, 1640, - /* 560 */ 1644, 1569, 1633, 1646, 1630, 1624, 1663, 1658, 1659, 1661, - /* 570 */ 1671, 1673, 1694, 1674, 1675, 1662, 1441, 1678, 1443, 1681, - /* 580 */ 1682, 1683, 1684, 1685, 1686, 1734, 1688, 1692, 1701, 1739, - /* 590 */ 1695, 1696, 1712, 1751, 1705, 1708, 1717, 1765, 1709, 1713, - /* 600 */ 1720, 1759, 1714, 1716, 1760, 1766, 1745, 1747, 1748, 1749, - /* 610 */ 1753, 1755, + /* 0 */ 891, 0, 0, 48, 96, 96, 96, 96, 282, 282, + /* 10 */ 96, 96, 330, 378, 564, 378, 378, 378, 378, 378, + /* 20 */ 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, + /* 30 */ 378, 378, 378, 378, 378, 378, 378, 378, 49, 49, + /* 40 */ 26, 26, 26, 2019, 2019, 2019, 2019, 191, 43, 60, + /* 50 */ 31, 31, 7, 7, 141, 60, 60, 31, 31, 31, + /* 60 */ 31, 31, 31, 23, 31, 80, 142, 178, 80, 31, + /* 70 */ 31, 80, 31, 80, 80, 178, 80, 31, 253, 560, + /* 80 */ 14, 62, 62, 309, 293, 678, 678, 678, 678, 678, + /* 90 */ 678, 678, 678, 678, 678, 678, 678, 678, 678, 678, + /* 100 */ 678, 678, 678, 678, 517, 37, 634, 634, 327, 78, + /* 110 */ 305, 305, 305, 649, 78, 367, 178, 80, 80, 178, + /* 120 */ 267, 599, 320, 320, 320, 320, 320, 320, 320, 684, + /* 130 */ 612, 434, 28, 77, 36, 245, 350, 609, 698, 513, + /* 140 */ 115, 489, 588, 565, 588, 673, 673, 673, 723, 633, + /* 150 */ 953, 949, 951, 858, 953, 953, 987, 896, 896, 953, + /* 160 */ 1027, 1027, 1032, 23, 178, 23, 1036, 1038, 23, 1036, + /* 170 */ 23, 367, 1058, 23, 23, 953, 23, 1027, 80, 80, + /* 180 */ 80, 80, 80, 80, 80, 80, 80, 80, 80, 953, + /* 190 */ 1027, 1045, 1032, 253, 960, 178, 253, 1036, 253, 367, + /* 200 */ 1058, 253, 1118, 923, 926, 1045, 923, 926, 1045, 1045, + /* 210 */ 80, 927, 1000, 945, 947, 952, 367, 1143, 1124, 959, + /* 220 */ 941, 946, 959, 941, 959, 941, 1101, 926, 1045, 1045, + /* 230 */ 926, 1045, 1046, 367, 1058, 253, 267, 253, 367, 1130, + /* 240 */ 599, 953, 253, 1027, 2213, 2213, 2213, 2213, 2213, 2213, + /* 250 */ 2213, 2213, 246, 1593, 961, 870, 359, 442, 697, 235, + /* 260 */ 423, 159, 504, 470, 470, 470, 470, 470, 470, 470, + /* 270 */ 470, 233, 473, 248, 107, 501, 527, 394, 341, 341, + /* 280 */ 341, 341, 768, 661, 741, 752, 769, 812, 256, 842, + /* 290 */ 886, 376, 759, 756, 762, 883, 895, 957, 744, 638, + /* 300 */ 725, 929, 647, 933, 939, 940, 943, 954, 956, 978, + /* 310 */ 888, 915, 982, 983, 989, 991, 992, 993, 740, 869, + /* 320 */ 1242, 1252, 1181, 1254, 1208, 1080, 1210, 1213, 1215, 1088, + /* 330 */ 1266, 1220, 1221, 1093, 1270, 1225, 1273, 1227, 1277, 1231, + /* 340 */ 1279, 1199, 1119, 1122, 1178, 1135, 1296, 1297, 1147, 1149, + /* 350 */ 1303, 1304, 1261, 1307, 1308, 1309, 1310, 1311, 1312, 1313, + /* 360 */ 1314, 1328, 1329, 1330, 1331, 1332, 1333, 1335, 1336, 1337, + /* 370 */ 1338, 1276, 1317, 1339, 1340, 1341, 1343, 1344, 1323, 1346, + /* 380 */ 1347, 1348, 1349, 1350, 1351, 1315, 1320, 1318, 1352, 1319, + /* 390 */ 1355, 1321, 1353, 1322, 1324, 1358, 1362, 1364, 1334, 1223, + /* 400 */ 1368, 1372, 1356, 1374, 1325, 1375, 1385, 1342, 1354, 1357, + /* 410 */ 1387, 1345, 1360, 1359, 1388, 1361, 1365, 1369, 1397, 1367, + /* 420 */ 1366, 1381, 1398, 1401, 1402, 1409, 1326, 1370, 1373, 1390, + /* 430 */ 1419, 1376, 1383, 1386, 1389, 1391, 1394, 1399, 1400, 1403, + /* 440 */ 1422, 1423, 1448, 1427, 1404, 1453, 1433, 1407, 1456, 1435, + /* 450 */ 1459, 1438, 1442, 1463, 1327, 1417, 1467, 1305, 1447, 1363, + /* 460 */ 1378, 1470, 1471, 1473, 1393, 1439, 1371, 1437, 1440, 1265, + /* 470 */ 1411, 1443, 1413, 1410, 1415, 1416, 1418, 1457, 1436, 1455, + /* 480 */ 1420, 1462, 1269, 1424, 1425, 1460, 1301, 1469, 1474, 1444, + /* 490 */ 1476, 1300, 1446, 1468, 1475, 1477, 1482, 1484, 1485, 1446, + /* 500 */ 1519, 1377, 1493, 1464, 1454, 1478, 1498, 1481, 1486, 1501, + /* 510 */ 1533, 1382, 1487, 1488, 1490, 1492, 1495, 1426, 1496, 1559, + /* 520 */ 1526, 1434, 1499, 1491, 1521, 1522, 1500, 1497, 1502, 1562, + /* 530 */ 1504, 1509, 1505, 1541, 1542, 1510, 1508, 1546, 1524, 1525, + /* 540 */ 1556, 1528, 1530, 1563, 1532, 1534, 1567, 1536, 1514, 1515, + /* 550 */ 1517, 1518, 1584, 1531, 1537, 1555, 1568, 1558, 1527, 1615, + /* 560 */ 1582, 1569, 1595, 1579, 1571, 1610, 1606, 1607, 1608, 1609, + /* 570 */ 1611, 1630, 1612, 1613, 1597, 1391, 1616, 1394, 1617, 1618, + /* 580 */ 1619, 1621, 1622, 1625, 1675, 1631, 1632, 1642, 1681, 1635, + /* 590 */ 1638, 1648, 1686, 1640, 1644, 1653, 1697, 1652, 1655, 1666, + /* 600 */ 1712, 1667, 1669, 1713, 1716, 1695, 1698, 1696, 1699, 1701, + /* 610 */ 1703, }; #define YY_REDUCE_COUNT (251) -#define YY_REDUCE_MIN (-314) -#define YY_REDUCE_MAX (1756) +#define YY_REDUCE_MIN (-309) +#define YY_REDUCE_MAX (1848) static const short yy_reduce_ofst[] = { - /* 0 */ 33, -226, 494, 90, 593, 344, 661, 744, 776, 806, - /* 10 */ 864, 904, -147, 923, 955, 1020, 1068, 1116, 1125, 1179, - /* 20 */ 1194, 1227, 1242, 1282, 1334, 1382, 1397, 1430, 1484, 1493, - /* 30 */ 1541, 1553, 1593, 1606, 1654, 1669, 1702, 1756, 545, 674, - /* 40 */ -196, 398, 556, -272, -270, -238, -162, 428, 38, 76, - /* 50 */ -164, 459, -241, -205, -287, -229, 24, -101, 92, 252, - /* 60 */ 357, 370, 457, 73, 519, -269, -115, -170, 102, 539, - /* 70 */ 540, 228, 553, 170, 338, 270, 508, 580, 402, 420, - /* 80 */ -314, -314, -314, -193, -103, -227, -67, -22, 123, 168, - /* 90 */ 204, 319, 386, 440, 501, 503, 523, 548, 554, 582, - /* 100 */ 606, 612, 625, 626, -246, -172, 29, 199, -54, 130, - /* 110 */ -207, -194, -37, 236, 205, 212, 141, 395, 629, 310, - /* 120 */ 439, 511, -253, 527, 604, 666, 675, 676, 677, -303, - /* 130 */ 689, 686, 599, 668, 709, 673, 749, 749, 772, 773, - /* 140 */ 746, 713, 692, 692, 692, 679, 681, 682, 698, 749, - /* 150 */ 790, 734, 786, 747, 801, 803, 779, 785, 789, 826, - /* 160 */ 834, 835, 778, 832, 799, 842, 805, 800, 846, 807, - /* 170 */ 848, 827, 819, 856, 857, 863, 859, 872, 847, 858, - /* 180 */ 860, 862, 865, 866, 867, 869, 870, 871, 873, 877, - /* 190 */ 885, 853, 843, 896, 850, 874, 906, 855, 907, 876, - /* 200 */ 875, 920, 878, 820, 882, 879, 821, 891, 895, 908, - /* 210 */ 749, 849, 854, 861, 868, 692, 927, 897, 881, 880, - /* 220 */ 892, 887, 894, 900, 905, 912, 924, 934, 936, 937, - /* 230 */ 951, 949, 961, 976, 966, 1004, 991, 1006, 982, 989, - /* 240 */ 1013, 1026, 1024, 1037, 992, 978, 997, 1025, 1027, 1028, - /* 250 */ 1042, 1056, + /* 0 */ -205, 492, 568, 629, 690, 343, 802, 857, 908, 920, + /* 10 */ -225, 973, 1006, 90, 1064, 1112, 1125, 1173, 1224, 1235, + /* 20 */ 1283, 1316, -144, 1379, 1392, 1432, 1483, 1513, 1545, 1596, + /* 30 */ 1605, 1658, 1674, 1706, 1736, 1784, 1793, 1848, 537, 751, + /* 40 */ -195, 215, 263, -271, -153, -253, -145, 200, 202, 363, + /* 50 */ -243, 339, -245, -240, -223, 38, 41, 344, 455, 514, + /* 60 */ 516, 524, 563, -244, 571, -246, -147, -209, 275, 538, + /* 70 */ 573, 219, 618, 445, 262, 165, 509, 644, -200, -178, + /* 80 */ -309, -309, -309, -18, 46, -143, -37, 238, 307, 372, + /* 90 */ 383, 431, 477, 484, 486, 490, 541, 547, 553, 581, + /* 100 */ 610, 619, 620, 621, 100, -140, -132, 137, -97, 156, + /* 110 */ -301, 98, 281, 399, 286, 212, 336, 451, 438, 295, + /* 120 */ 185, 408, -255, 216, 356, 403, 460, 475, 584, 496, + /* 130 */ 529, 617, 520, 542, 604, 575, 667, 667, 683, 699, + /* 140 */ 671, 652, 628, 628, 628, 614, 615, 627, 632, 667, + /* 150 */ 731, 689, 754, 713, 772, 777, 745, 755, 761, 791, + /* 160 */ 804, 806, 749, 800, 767, 803, 763, 778, 807, 766, + /* 170 */ 822, 801, 792, 831, 833, 839, 837, 848, 823, 825, + /* 180 */ 826, 827, 828, 830, 834, 835, 838, 840, 843, 854, + /* 190 */ 863, 820, 816, 871, 819, 844, 874, 841, 879, 855, + /* 200 */ 845, 884, 829, 794, 851, 856, 798, 859, 861, 862, + /* 210 */ 667, 810, 813, 814, 824, 628, 882, 865, 852, 847, + /* 220 */ 815, 821, 849, 836, 850, 846, 866, 899, 901, 903, + /* 230 */ 904, 910, 917, 931, 916, 958, 948, 964, 935, 966, + /* 240 */ 968, 970, 974, 986, 930, 936, 950, 980, 981, 985, + /* 250 */ 997, 998, }; static const YYACTIONTYPE yy_default[] = { - /* 0 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 10 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 20 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 30 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 40 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 50 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 60 */ 1357, 1357, 1357, 1426, 1357, 1357, 1357, 1357, 1357, 1357, - /* 70 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1424, 1565, - /* 80 */ 1357, 1732, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 90 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 100 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1426, 1357, - /* 110 */ 1743, 1743, 1743, 1424, 1357, 1357, 1357, 1357, 1357, 1357, - /* 120 */ 1520, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1604, - /* 130 */ 1357, 1357, 1809, 1357, 1610, 1767, 1357, 1357, 1357, 1357, - /* 140 */ 1473, 1759, 1735, 1749, 1736, 1794, 1794, 1794, 1752, 1357, - /* 150 */ 1357, 1357, 1357, 1596, 1357, 1357, 1570, 1567, 1567, 1357, - /* 160 */ 1357, 1357, 1357, 1426, 1357, 1426, 1357, 1357, 1426, 1357, - /* 170 */ 1426, 1357, 1357, 1426, 1426, 1357, 1426, 1357, 1357, 1357, - /* 180 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 190 */ 1357, 1357, 1357, 1424, 1606, 1357, 1424, 1357, 1424, 1357, - /* 200 */ 1357, 1424, 1357, 1774, 1772, 1357, 1774, 1772, 1357, 1357, - /* 210 */ 1357, 1786, 1782, 1765, 1763, 1749, 1357, 1357, 1357, 1800, - /* 220 */ 1796, 1812, 1800, 1796, 1800, 1796, 1357, 1772, 1357, 1357, - /* 230 */ 1772, 1357, 1578, 1357, 1357, 1424, 1357, 1424, 1357, 1489, - /* 240 */ 1357, 1357, 1424, 1357, 1598, 1612, 1588, 1523, 1523, 1523, - /* 250 */ 1427, 1362, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 260 */ 1357, 1357, 1357, 1485, 1676, 1785, 1784, 1708, 1707, 1706, - /* 270 */ 1704, 1675, 1357, 1357, 1357, 1357, 1357, 1357, 1669, 1670, - /* 280 */ 1668, 1667, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 290 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1733, 1357, 1797, - /* 300 */ 1801, 1357, 1357, 1357, 1652, 1357, 1357, 1357, 1357, 1357, - /* 310 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 320 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 330 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 340 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 350 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 360 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 370 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 380 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1391, 1357, 1357, - /* 390 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 400 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 410 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 420 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 430 */ 1357, 1357, 1357, 1357, 1357, 1454, 1453, 1357, 1357, 1357, - /* 440 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 450 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 460 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1756, 1766, 1357, - /* 470 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1652, - /* 480 */ 1357, 1783, 1357, 1742, 1738, 1357, 1357, 1734, 1357, 1357, - /* 490 */ 1795, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 500 */ 1728, 1357, 1701, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 510 */ 1357, 1663, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 520 */ 1357, 1357, 1357, 1357, 1651, 1357, 1692, 1357, 1357, 1357, - /* 530 */ 1357, 1357, 1357, 1357, 1357, 1517, 1357, 1357, 1357, 1357, - /* 540 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1502, 1500, - /* 550 */ 1499, 1498, 1357, 1495, 1357, 1357, 1357, 1357, 1357, 1357, - /* 560 */ 1357, 1357, 1357, 1357, 1357, 1357, 1446, 1357, 1357, 1357, - /* 570 */ 1357, 1357, 1357, 1357, 1357, 1357, 1437, 1357, 1436, 1357, - /* 580 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 590 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 600 */ 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, - /* 610 */ 1357, 1357, + /* 0 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 10 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 20 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 30 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 40 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 50 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 60 */ 1354, 1354, 1354, 1423, 1354, 1354, 1354, 1354, 1354, 1354, + /* 70 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1421, 1561, + /* 80 */ 1354, 1728, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 90 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 100 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1423, 1354, + /* 110 */ 1739, 1739, 1739, 1421, 1354, 1354, 1354, 1354, 1354, 1354, + /* 120 */ 1517, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1600, + /* 130 */ 1354, 1354, 1805, 1354, 1606, 1763, 1354, 1354, 1354, 1354, + /* 140 */ 1470, 1755, 1731, 1745, 1732, 1790, 1790, 1790, 1748, 1354, + /* 150 */ 1354, 1354, 1354, 1592, 1354, 1354, 1566, 1563, 1563, 1354, + /* 160 */ 1354, 1354, 1354, 1423, 1354, 1423, 1354, 1354, 1423, 1354, + /* 170 */ 1423, 1354, 1354, 1423, 1423, 1354, 1423, 1354, 1354, 1354, + /* 180 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 190 */ 1354, 1354, 1354, 1421, 1602, 1354, 1421, 1354, 1421, 1354, + /* 200 */ 1354, 1421, 1354, 1770, 1768, 1354, 1770, 1768, 1354, 1354, + /* 210 */ 1354, 1782, 1778, 1761, 1759, 1745, 1354, 1354, 1354, 1796, + /* 220 */ 1792, 1808, 1796, 1792, 1796, 1792, 1354, 1768, 1354, 1354, + /* 230 */ 1768, 1354, 1574, 1354, 1354, 1421, 1354, 1421, 1354, 1486, + /* 240 */ 1354, 1354, 1421, 1354, 1594, 1608, 1584, 1520, 1520, 1520, + /* 250 */ 1424, 1359, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 260 */ 1354, 1354, 1354, 1672, 1781, 1780, 1704, 1703, 1702, 1700, + /* 270 */ 1671, 1482, 1354, 1354, 1354, 1354, 1354, 1354, 1665, 1666, + /* 280 */ 1664, 1663, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 290 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1729, 1354, 1793, + /* 300 */ 1797, 1354, 1354, 1354, 1648, 1354, 1354, 1354, 1354, 1354, + /* 310 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 320 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 330 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 340 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 350 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 360 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 370 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 380 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1388, 1354, 1354, + /* 390 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 400 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 410 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 420 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 430 */ 1354, 1354, 1354, 1354, 1354, 1451, 1450, 1354, 1354, 1354, + /* 440 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 450 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 460 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1752, 1762, 1354, + /* 470 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1648, + /* 480 */ 1354, 1779, 1354, 1738, 1734, 1354, 1354, 1730, 1354, 1354, + /* 490 */ 1791, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 500 */ 1724, 1354, 1697, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 510 */ 1354, 1659, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 520 */ 1354, 1354, 1354, 1354, 1647, 1354, 1688, 1354, 1354, 1354, + /* 530 */ 1354, 1354, 1354, 1354, 1354, 1514, 1354, 1354, 1354, 1354, + /* 540 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1499, 1497, + /* 550 */ 1496, 1495, 1354, 1492, 1354, 1354, 1354, 1354, 1354, 1354, + /* 560 */ 1354, 1354, 1354, 1354, 1354, 1443, 1354, 1354, 1354, 1354, + /* 570 */ 1354, 1354, 1354, 1354, 1354, 1434, 1354, 1433, 1354, 1354, + /* 580 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 590 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 600 */ 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, + /* 610 */ 1354, }; /********** End of lemon-generated parsing tables *****************************/ @@ -942,7 +958,6 @@ static const YYCODETYPE yyFallback[] = { 0, /* BLOB => nothing */ 0, /* VARBINARY => nothing */ 0, /* DECIMAL => nothing */ - 0, /* DELAY => nothing */ 0, /* FILE_FACTOR => nothing */ 0, /* NK_FLOAT => nothing */ 0, /* ROLLUP => nothing */ @@ -1064,12 +1079,12 @@ static const YYCODETYPE yyFallback[] = { 0, /* ASC => nothing */ 0, /* NULLS => nothing */ 0, /* ID => nothing */ - 233, /* NK_BITNOT => ID */ - 233, /* INSERT => ID */ - 233, /* VALUES => ID */ - 233, /* IMPORT => ID */ - 233, /* NK_SEMI => ID */ - 233, /* FILE => ID */ + 232, /* NK_BITNOT => ID */ + 232, /* INSERT => ID */ + 232, /* VALUES => ID */ + 232, /* IMPORT => ID */ + 232, /* NK_SEMI => ID */ + 232, /* FILE => ID */ }; #endif /* YYFALLBACK */ @@ -1269,255 +1284,254 @@ static const char *const yyTokenName[] = { /* 109 */ "BLOB", /* 110 */ "VARBINARY", /* 111 */ "DECIMAL", - /* 112 */ "DELAY", - /* 113 */ "FILE_FACTOR", - /* 114 */ "NK_FLOAT", - /* 115 */ "ROLLUP", - /* 116 */ "TTL", - /* 117 */ "SMA", - /* 118 */ "SHOW", - /* 119 */ "DATABASES", - /* 120 */ "TABLES", - /* 121 */ "STABLES", - /* 122 */ "MNODES", - /* 123 */ "MODULES", - /* 124 */ "QNODES", - /* 125 */ "FUNCTIONS", - /* 126 */ "INDEXES", - /* 127 */ "ACCOUNTS", - /* 128 */ "APPS", - /* 129 */ "CONNECTIONS", - /* 130 */ "LICENCE", - /* 131 */ "GRANTS", - /* 132 */ "QUERIES", - /* 133 */ "SCORES", - /* 134 */ "TOPICS", - /* 135 */ "VARIABLES", - /* 136 */ "BNODES", - /* 137 */ "SNODES", - /* 138 */ "CLUSTER", - /* 139 */ "TRANSACTIONS", - /* 140 */ "LIKE", - /* 141 */ "INDEX", - /* 142 */ "FULLTEXT", - /* 143 */ "FUNCTION", - /* 144 */ "INTERVAL", - /* 145 */ "TOPIC", - /* 146 */ "AS", - /* 147 */ "CONSUMER", - /* 148 */ "GROUP", - /* 149 */ "WITH", - /* 150 */ "SCHEMA", - /* 151 */ "DESC", - /* 152 */ "DESCRIBE", - /* 153 */ "RESET", - /* 154 */ "QUERY", - /* 155 */ "CACHE", - /* 156 */ "EXPLAIN", - /* 157 */ "ANALYZE", - /* 158 */ "VERBOSE", - /* 159 */ "NK_BOOL", - /* 160 */ "RATIO", - /* 161 */ "COMPACT", - /* 162 */ "VNODES", - /* 163 */ "IN", - /* 164 */ "OUTPUTTYPE", - /* 165 */ "AGGREGATE", - /* 166 */ "BUFSIZE", - /* 167 */ "STREAM", - /* 168 */ "INTO", - /* 169 */ "TRIGGER", - /* 170 */ "AT_ONCE", - /* 171 */ "WINDOW_CLOSE", - /* 172 */ "WATERMARK", - /* 173 */ "KILL", - /* 174 */ "CONNECTION", - /* 175 */ "TRANSACTION", - /* 176 */ "MERGE", - /* 177 */ "VGROUP", - /* 178 */ "REDISTRIBUTE", - /* 179 */ "SPLIT", - /* 180 */ "SYNCDB", - /* 181 */ "NULL", - /* 182 */ "NK_QUESTION", - /* 183 */ "NK_ARROW", - /* 184 */ "ROWTS", - /* 185 */ "TBNAME", - /* 186 */ "QSTARTTS", - /* 187 */ "QENDTS", - /* 188 */ "WSTARTTS", - /* 189 */ "WENDTS", - /* 190 */ "WDURATION", - /* 191 */ "CAST", - /* 192 */ "NOW", - /* 193 */ "TODAY", - /* 194 */ "TIMEZONE", - /* 195 */ "COUNT", - /* 196 */ "FIRST", - /* 197 */ "LAST", - /* 198 */ "LAST_ROW", - /* 199 */ "BETWEEN", - /* 200 */ "IS", - /* 201 */ "NK_LT", - /* 202 */ "NK_GT", - /* 203 */ "NK_LE", - /* 204 */ "NK_GE", - /* 205 */ "NK_NE", - /* 206 */ "MATCH", - /* 207 */ "NMATCH", - /* 208 */ "CONTAINS", - /* 209 */ "JOIN", - /* 210 */ "INNER", - /* 211 */ "SELECT", - /* 212 */ "DISTINCT", - /* 213 */ "WHERE", - /* 214 */ "PARTITION", - /* 215 */ "BY", - /* 216 */ "SESSION", - /* 217 */ "STATE_WINDOW", - /* 218 */ "SLIDING", - /* 219 */ "FILL", - /* 220 */ "VALUE", - /* 221 */ "NONE", - /* 222 */ "PREV", - /* 223 */ "LINEAR", - /* 224 */ "NEXT", - /* 225 */ "HAVING", - /* 226 */ "ORDER", - /* 227 */ "SLIMIT", - /* 228 */ "SOFFSET", - /* 229 */ "LIMIT", - /* 230 */ "OFFSET", - /* 231 */ "ASC", - /* 232 */ "NULLS", - /* 233 */ "ID", - /* 234 */ "NK_BITNOT", - /* 235 */ "INSERT", - /* 236 */ "VALUES", - /* 237 */ "IMPORT", - /* 238 */ "NK_SEMI", - /* 239 */ "FILE", - /* 240 */ "cmd", - /* 241 */ "account_options", - /* 242 */ "alter_account_options", - /* 243 */ "literal", - /* 244 */ "alter_account_option", - /* 245 */ "user_name", - /* 246 */ "privileges", - /* 247 */ "priv_level", - /* 248 */ "priv_type_list", - /* 249 */ "priv_type", - /* 250 */ "db_name", - /* 251 */ "dnode_endpoint", - /* 252 */ "dnode_host_name", - /* 253 */ "not_exists_opt", - /* 254 */ "db_options", - /* 255 */ "exists_opt", - /* 256 */ "alter_db_options", - /* 257 */ "integer_list", - /* 258 */ "variable_list", - /* 259 */ "retention_list", - /* 260 */ "alter_db_option", - /* 261 */ "retention", - /* 262 */ "full_table_name", - /* 263 */ "column_def_list", - /* 264 */ "tags_def_opt", - /* 265 */ "table_options", - /* 266 */ "multi_create_clause", - /* 267 */ "tags_def", - /* 268 */ "multi_drop_clause", - /* 269 */ "alter_table_clause", - /* 270 */ "alter_table_options", - /* 271 */ "column_name", - /* 272 */ "type_name", - /* 273 */ "signed_literal", - /* 274 */ "create_subtable_clause", - /* 275 */ "specific_tags_opt", - /* 276 */ "literal_list", - /* 277 */ "drop_table_clause", - /* 278 */ "col_name_list", - /* 279 */ "table_name", - /* 280 */ "column_def", - /* 281 */ "func_name_list", - /* 282 */ "alter_table_option", - /* 283 */ "col_name", - /* 284 */ "db_name_cond_opt", - /* 285 */ "like_pattern_opt", - /* 286 */ "table_name_cond", - /* 287 */ "from_db_opt", - /* 288 */ "func_name", - /* 289 */ "function_name", - /* 290 */ "index_name", - /* 291 */ "index_options", - /* 292 */ "func_list", - /* 293 */ "duration_literal", - /* 294 */ "sliding_opt", - /* 295 */ "func", - /* 296 */ "expression_list", - /* 297 */ "topic_name", - /* 298 */ "topic_options", - /* 299 */ "query_expression", - /* 300 */ "cgroup_name", - /* 301 */ "analyze_opt", - /* 302 */ "explain_options", - /* 303 */ "agg_func_opt", - /* 304 */ "bufsize_opt", - /* 305 */ "stream_name", - /* 306 */ "stream_options", - /* 307 */ "into_opt", - /* 308 */ "dnode_list", - /* 309 */ "signed", - /* 310 */ "literal_func", - /* 311 */ "table_alias", - /* 312 */ "column_alias", - /* 313 */ "expression", - /* 314 */ "pseudo_column", - /* 315 */ "column_reference", - /* 316 */ "function_expression", - /* 317 */ "subquery", - /* 318 */ "star_func", - /* 319 */ "star_func_para_list", - /* 320 */ "noarg_func", - /* 321 */ "other_para_list", - /* 322 */ "star_func_para", - /* 323 */ "predicate", - /* 324 */ "compare_op", - /* 325 */ "in_op", - /* 326 */ "in_predicate_value", - /* 327 */ "boolean_value_expression", - /* 328 */ "boolean_primary", - /* 329 */ "common_expression", - /* 330 */ "from_clause", - /* 331 */ "table_reference_list", - /* 332 */ "table_reference", - /* 333 */ "table_primary", - /* 334 */ "joined_table", - /* 335 */ "alias_opt", - /* 336 */ "parenthesized_joined_table", - /* 337 */ "join_type", - /* 338 */ "search_condition", - /* 339 */ "query_specification", - /* 340 */ "set_quantifier_opt", - /* 341 */ "select_list", - /* 342 */ "where_clause_opt", - /* 343 */ "partition_by_clause_opt", - /* 344 */ "twindow_clause_opt", - /* 345 */ "group_by_clause_opt", - /* 346 */ "having_clause_opt", - /* 347 */ "select_sublist", - /* 348 */ "select_item", - /* 349 */ "fill_opt", - /* 350 */ "fill_mode", - /* 351 */ "group_by_list", - /* 352 */ "query_expression_body", - /* 353 */ "order_by_clause_opt", - /* 354 */ "slimit_clause_opt", - /* 355 */ "limit_clause_opt", - /* 356 */ "query_primary", - /* 357 */ "sort_specification_list", - /* 358 */ "sort_specification", - /* 359 */ "ordering_specification_opt", - /* 360 */ "null_ordering_opt", + /* 112 */ "FILE_FACTOR", + /* 113 */ "NK_FLOAT", + /* 114 */ "ROLLUP", + /* 115 */ "TTL", + /* 116 */ "SMA", + /* 117 */ "SHOW", + /* 118 */ "DATABASES", + /* 119 */ "TABLES", + /* 120 */ "STABLES", + /* 121 */ "MNODES", + /* 122 */ "MODULES", + /* 123 */ "QNODES", + /* 124 */ "FUNCTIONS", + /* 125 */ "INDEXES", + /* 126 */ "ACCOUNTS", + /* 127 */ "APPS", + /* 128 */ "CONNECTIONS", + /* 129 */ "LICENCE", + /* 130 */ "GRANTS", + /* 131 */ "QUERIES", + /* 132 */ "SCORES", + /* 133 */ "TOPICS", + /* 134 */ "VARIABLES", + /* 135 */ "BNODES", + /* 136 */ "SNODES", + /* 137 */ "CLUSTER", + /* 138 */ "TRANSACTIONS", + /* 139 */ "LIKE", + /* 140 */ "INDEX", + /* 141 */ "FULLTEXT", + /* 142 */ "FUNCTION", + /* 143 */ "INTERVAL", + /* 144 */ "TOPIC", + /* 145 */ "AS", + /* 146 */ "CONSUMER", + /* 147 */ "GROUP", + /* 148 */ "WITH", + /* 149 */ "SCHEMA", + /* 150 */ "DESC", + /* 151 */ "DESCRIBE", + /* 152 */ "RESET", + /* 153 */ "QUERY", + /* 154 */ "CACHE", + /* 155 */ "EXPLAIN", + /* 156 */ "ANALYZE", + /* 157 */ "VERBOSE", + /* 158 */ "NK_BOOL", + /* 159 */ "RATIO", + /* 160 */ "COMPACT", + /* 161 */ "VNODES", + /* 162 */ "IN", + /* 163 */ "OUTPUTTYPE", + /* 164 */ "AGGREGATE", + /* 165 */ "BUFSIZE", + /* 166 */ "STREAM", + /* 167 */ "INTO", + /* 168 */ "TRIGGER", + /* 169 */ "AT_ONCE", + /* 170 */ "WINDOW_CLOSE", + /* 171 */ "WATERMARK", + /* 172 */ "KILL", + /* 173 */ "CONNECTION", + /* 174 */ "TRANSACTION", + /* 175 */ "MERGE", + /* 176 */ "VGROUP", + /* 177 */ "REDISTRIBUTE", + /* 178 */ "SPLIT", + /* 179 */ "SYNCDB", + /* 180 */ "NULL", + /* 181 */ "NK_QUESTION", + /* 182 */ "NK_ARROW", + /* 183 */ "ROWTS", + /* 184 */ "TBNAME", + /* 185 */ "QSTARTTS", + /* 186 */ "QENDTS", + /* 187 */ "WSTARTTS", + /* 188 */ "WENDTS", + /* 189 */ "WDURATION", + /* 190 */ "CAST", + /* 191 */ "NOW", + /* 192 */ "TODAY", + /* 193 */ "TIMEZONE", + /* 194 */ "COUNT", + /* 195 */ "FIRST", + /* 196 */ "LAST", + /* 197 */ "LAST_ROW", + /* 198 */ "BETWEEN", + /* 199 */ "IS", + /* 200 */ "NK_LT", + /* 201 */ "NK_GT", + /* 202 */ "NK_LE", + /* 203 */ "NK_GE", + /* 204 */ "NK_NE", + /* 205 */ "MATCH", + /* 206 */ "NMATCH", + /* 207 */ "CONTAINS", + /* 208 */ "JOIN", + /* 209 */ "INNER", + /* 210 */ "SELECT", + /* 211 */ "DISTINCT", + /* 212 */ "WHERE", + /* 213 */ "PARTITION", + /* 214 */ "BY", + /* 215 */ "SESSION", + /* 216 */ "STATE_WINDOW", + /* 217 */ "SLIDING", + /* 218 */ "FILL", + /* 219 */ "VALUE", + /* 220 */ "NONE", + /* 221 */ "PREV", + /* 222 */ "LINEAR", + /* 223 */ "NEXT", + /* 224 */ "HAVING", + /* 225 */ "ORDER", + /* 226 */ "SLIMIT", + /* 227 */ "SOFFSET", + /* 228 */ "LIMIT", + /* 229 */ "OFFSET", + /* 230 */ "ASC", + /* 231 */ "NULLS", + /* 232 */ "ID", + /* 233 */ "NK_BITNOT", + /* 234 */ "INSERT", + /* 235 */ "VALUES", + /* 236 */ "IMPORT", + /* 237 */ "NK_SEMI", + /* 238 */ "FILE", + /* 239 */ "cmd", + /* 240 */ "account_options", + /* 241 */ "alter_account_options", + /* 242 */ "literal", + /* 243 */ "alter_account_option", + /* 244 */ "user_name", + /* 245 */ "privileges", + /* 246 */ "priv_level", + /* 247 */ "priv_type_list", + /* 248 */ "priv_type", + /* 249 */ "db_name", + /* 250 */ "dnode_endpoint", + /* 251 */ "dnode_host_name", + /* 252 */ "not_exists_opt", + /* 253 */ "db_options", + /* 254 */ "exists_opt", + /* 255 */ "alter_db_options", + /* 256 */ "integer_list", + /* 257 */ "variable_list", + /* 258 */ "retention_list", + /* 259 */ "alter_db_option", + /* 260 */ "retention", + /* 261 */ "full_table_name", + /* 262 */ "column_def_list", + /* 263 */ "tags_def_opt", + /* 264 */ "table_options", + /* 265 */ "multi_create_clause", + /* 266 */ "tags_def", + /* 267 */ "multi_drop_clause", + /* 268 */ "alter_table_clause", + /* 269 */ "alter_table_options", + /* 270 */ "column_name", + /* 271 */ "type_name", + /* 272 */ "signed_literal", + /* 273 */ "create_subtable_clause", + /* 274 */ "specific_tags_opt", + /* 275 */ "literal_list", + /* 276 */ "drop_table_clause", + /* 277 */ "col_name_list", + /* 278 */ "table_name", + /* 279 */ "column_def", + /* 280 */ "func_name_list", + /* 281 */ "alter_table_option", + /* 282 */ "col_name", + /* 283 */ "db_name_cond_opt", + /* 284 */ "like_pattern_opt", + /* 285 */ "table_name_cond", + /* 286 */ "from_db_opt", + /* 287 */ "func_name", + /* 288 */ "function_name", + /* 289 */ "index_name", + /* 290 */ "index_options", + /* 291 */ "func_list", + /* 292 */ "duration_literal", + /* 293 */ "sliding_opt", + /* 294 */ "func", + /* 295 */ "expression_list", + /* 296 */ "topic_name", + /* 297 */ "topic_options", + /* 298 */ "query_expression", + /* 299 */ "cgroup_name", + /* 300 */ "analyze_opt", + /* 301 */ "explain_options", + /* 302 */ "agg_func_opt", + /* 303 */ "bufsize_opt", + /* 304 */ "stream_name", + /* 305 */ "stream_options", + /* 306 */ "into_opt", + /* 307 */ "dnode_list", + /* 308 */ "signed", + /* 309 */ "literal_func", + /* 310 */ "table_alias", + /* 311 */ "column_alias", + /* 312 */ "expression", + /* 313 */ "pseudo_column", + /* 314 */ "column_reference", + /* 315 */ "function_expression", + /* 316 */ "subquery", + /* 317 */ "star_func", + /* 318 */ "star_func_para_list", + /* 319 */ "noarg_func", + /* 320 */ "other_para_list", + /* 321 */ "star_func_para", + /* 322 */ "predicate", + /* 323 */ "compare_op", + /* 324 */ "in_op", + /* 325 */ "in_predicate_value", + /* 326 */ "boolean_value_expression", + /* 327 */ "boolean_primary", + /* 328 */ "common_expression", + /* 329 */ "from_clause", + /* 330 */ "table_reference_list", + /* 331 */ "table_reference", + /* 332 */ "table_primary", + /* 333 */ "joined_table", + /* 334 */ "alias_opt", + /* 335 */ "parenthesized_joined_table", + /* 336 */ "join_type", + /* 337 */ "search_condition", + /* 338 */ "query_specification", + /* 339 */ "set_quantifier_opt", + /* 340 */ "select_list", + /* 341 */ "where_clause_opt", + /* 342 */ "partition_by_clause_opt", + /* 343 */ "twindow_clause_opt", + /* 344 */ "group_by_clause_opt", + /* 345 */ "having_clause_opt", + /* 346 */ "select_sublist", + /* 347 */ "select_item", + /* 348 */ "fill_opt", + /* 349 */ "fill_mode", + /* 350 */ "group_by_list", + /* 351 */ "query_expression_body", + /* 352 */ "order_by_clause_opt", + /* 353 */ "slimit_clause_opt", + /* 354 */ "limit_clause_opt", + /* 355 */ "query_primary", + /* 356 */ "sort_specification_list", + /* 357 */ "sort_specification", + /* 358 */ "ordering_specification_opt", + /* 359 */ "null_ordering_opt", }; #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */ @@ -1690,296 +1704,295 @@ static const char *const yyRuleName[] = { /* 162 */ "tags_def ::= TAGS NK_LP column_def_list NK_RP", /* 163 */ "table_options ::=", /* 164 */ "table_options ::= table_options COMMENT NK_STRING", - /* 165 */ "table_options ::= table_options DELAY NK_INTEGER", - /* 166 */ "table_options ::= table_options FILE_FACTOR NK_FLOAT", - /* 167 */ "table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP", - /* 168 */ "table_options ::= table_options TTL NK_INTEGER", - /* 169 */ "table_options ::= table_options SMA NK_LP col_name_list NK_RP", - /* 170 */ "alter_table_options ::= alter_table_option", - /* 171 */ "alter_table_options ::= alter_table_options alter_table_option", - /* 172 */ "alter_table_option ::= COMMENT NK_STRING", - /* 173 */ "alter_table_option ::= TTL NK_INTEGER", - /* 174 */ "col_name_list ::= col_name", - /* 175 */ "col_name_list ::= col_name_list NK_COMMA col_name", - /* 176 */ "col_name ::= column_name", - /* 177 */ "cmd ::= SHOW DNODES", - /* 178 */ "cmd ::= SHOW USERS", - /* 179 */ "cmd ::= SHOW DATABASES", - /* 180 */ "cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt", - /* 181 */ "cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt", - /* 182 */ "cmd ::= SHOW db_name_cond_opt VGROUPS", - /* 183 */ "cmd ::= SHOW MNODES", - /* 184 */ "cmd ::= SHOW MODULES", - /* 185 */ "cmd ::= SHOW QNODES", - /* 186 */ "cmd ::= SHOW FUNCTIONS", - /* 187 */ "cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt", - /* 188 */ "cmd ::= SHOW STREAMS", - /* 189 */ "cmd ::= SHOW ACCOUNTS", - /* 190 */ "cmd ::= SHOW APPS", - /* 191 */ "cmd ::= SHOW CONNECTIONS", - /* 192 */ "cmd ::= SHOW LICENCE", - /* 193 */ "cmd ::= SHOW GRANTS", - /* 194 */ "cmd ::= SHOW CREATE DATABASE db_name", - /* 195 */ "cmd ::= SHOW CREATE TABLE full_table_name", - /* 196 */ "cmd ::= SHOW CREATE STABLE full_table_name", - /* 197 */ "cmd ::= SHOW QUERIES", - /* 198 */ "cmd ::= SHOW SCORES", - /* 199 */ "cmd ::= SHOW TOPICS", - /* 200 */ "cmd ::= SHOW VARIABLES", - /* 201 */ "cmd ::= SHOW BNODES", - /* 202 */ "cmd ::= SHOW SNODES", - /* 203 */ "cmd ::= SHOW CLUSTER", - /* 204 */ "cmd ::= SHOW TRANSACTIONS", - /* 205 */ "db_name_cond_opt ::=", - /* 206 */ "db_name_cond_opt ::= db_name NK_DOT", - /* 207 */ "like_pattern_opt ::=", - /* 208 */ "like_pattern_opt ::= LIKE NK_STRING", - /* 209 */ "table_name_cond ::= table_name", - /* 210 */ "from_db_opt ::=", - /* 211 */ "from_db_opt ::= FROM db_name", - /* 212 */ "func_name_list ::= func_name", - /* 213 */ "func_name_list ::= func_name_list NK_COMMA func_name", - /* 214 */ "func_name ::= function_name", - /* 215 */ "cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options", - /* 216 */ "cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP", - /* 217 */ "cmd ::= DROP INDEX exists_opt index_name ON table_name", - /* 218 */ "index_options ::=", - /* 219 */ "index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt", - /* 220 */ "index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt", - /* 221 */ "func_list ::= func", - /* 222 */ "func_list ::= func_list NK_COMMA func", - /* 223 */ "func ::= function_name NK_LP expression_list NK_RP", - /* 224 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS query_expression", - /* 225 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS db_name", - /* 226 */ "cmd ::= DROP TOPIC exists_opt topic_name", - /* 227 */ "cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name", - /* 228 */ "topic_options ::=", - /* 229 */ "topic_options ::= topic_options WITH TABLE", - /* 230 */ "topic_options ::= topic_options WITH SCHEMA", - /* 231 */ "topic_options ::= topic_options WITH TAG", - /* 232 */ "cmd ::= DESC full_table_name", - /* 233 */ "cmd ::= DESCRIBE full_table_name", - /* 234 */ "cmd ::= RESET QUERY CACHE", - /* 235 */ "cmd ::= EXPLAIN analyze_opt explain_options query_expression", - /* 236 */ "analyze_opt ::=", - /* 237 */ "analyze_opt ::= ANALYZE", - /* 238 */ "explain_options ::=", - /* 239 */ "explain_options ::= explain_options VERBOSE NK_BOOL", - /* 240 */ "explain_options ::= explain_options RATIO NK_FLOAT", - /* 241 */ "cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP", - /* 242 */ "cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt", - /* 243 */ "cmd ::= DROP FUNCTION exists_opt function_name", - /* 244 */ "agg_func_opt ::=", - /* 245 */ "agg_func_opt ::= AGGREGATE", - /* 246 */ "bufsize_opt ::=", - /* 247 */ "bufsize_opt ::= BUFSIZE NK_INTEGER", - /* 248 */ "cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression", - /* 249 */ "cmd ::= DROP STREAM exists_opt stream_name", - /* 250 */ "into_opt ::=", - /* 251 */ "into_opt ::= INTO full_table_name", - /* 252 */ "stream_options ::=", - /* 253 */ "stream_options ::= stream_options TRIGGER AT_ONCE", - /* 254 */ "stream_options ::= stream_options TRIGGER WINDOW_CLOSE", - /* 255 */ "stream_options ::= stream_options WATERMARK duration_literal", - /* 256 */ "cmd ::= KILL CONNECTION NK_INTEGER", - /* 257 */ "cmd ::= KILL QUERY NK_INTEGER", - /* 258 */ "cmd ::= KILL TRANSACTION NK_INTEGER", - /* 259 */ "cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER", - /* 260 */ "cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list", - /* 261 */ "cmd ::= SPLIT VGROUP NK_INTEGER", - /* 262 */ "dnode_list ::= DNODE NK_INTEGER", - /* 263 */ "dnode_list ::= dnode_list DNODE NK_INTEGER", - /* 264 */ "cmd ::= SYNCDB db_name REPLICA", - /* 265 */ "cmd ::= query_expression", - /* 266 */ "literal ::= NK_INTEGER", - /* 267 */ "literal ::= NK_FLOAT", - /* 268 */ "literal ::= NK_STRING", - /* 269 */ "literal ::= NK_BOOL", - /* 270 */ "literal ::= TIMESTAMP NK_STRING", - /* 271 */ "literal ::= duration_literal", - /* 272 */ "literal ::= NULL", - /* 273 */ "literal ::= NK_QUESTION", - /* 274 */ "duration_literal ::= NK_VARIABLE", - /* 275 */ "signed ::= NK_INTEGER", - /* 276 */ "signed ::= NK_PLUS NK_INTEGER", - /* 277 */ "signed ::= NK_MINUS NK_INTEGER", - /* 278 */ "signed ::= NK_FLOAT", - /* 279 */ "signed ::= NK_PLUS NK_FLOAT", - /* 280 */ "signed ::= NK_MINUS NK_FLOAT", - /* 281 */ "signed_literal ::= signed", - /* 282 */ "signed_literal ::= NK_STRING", - /* 283 */ "signed_literal ::= NK_BOOL", - /* 284 */ "signed_literal ::= TIMESTAMP NK_STRING", - /* 285 */ "signed_literal ::= duration_literal", - /* 286 */ "signed_literal ::= NULL", - /* 287 */ "signed_literal ::= literal_func", - /* 288 */ "literal_list ::= signed_literal", - /* 289 */ "literal_list ::= literal_list NK_COMMA signed_literal", - /* 290 */ "db_name ::= NK_ID", - /* 291 */ "table_name ::= NK_ID", - /* 292 */ "column_name ::= NK_ID", - /* 293 */ "function_name ::= NK_ID", - /* 294 */ "table_alias ::= NK_ID", - /* 295 */ "column_alias ::= NK_ID", - /* 296 */ "user_name ::= NK_ID", - /* 297 */ "index_name ::= NK_ID", - /* 298 */ "topic_name ::= NK_ID", - /* 299 */ "stream_name ::= NK_ID", - /* 300 */ "cgroup_name ::= NK_ID", - /* 301 */ "expression ::= literal", - /* 302 */ "expression ::= pseudo_column", - /* 303 */ "expression ::= column_reference", - /* 304 */ "expression ::= function_expression", - /* 305 */ "expression ::= subquery", - /* 306 */ "expression ::= NK_LP expression NK_RP", - /* 307 */ "expression ::= NK_PLUS expression", - /* 308 */ "expression ::= NK_MINUS expression", - /* 309 */ "expression ::= expression NK_PLUS expression", - /* 310 */ "expression ::= expression NK_MINUS expression", - /* 311 */ "expression ::= expression NK_STAR expression", - /* 312 */ "expression ::= expression NK_SLASH expression", - /* 313 */ "expression ::= expression NK_REM expression", - /* 314 */ "expression ::= column_reference NK_ARROW NK_STRING", - /* 315 */ "expression_list ::= expression", - /* 316 */ "expression_list ::= expression_list NK_COMMA expression", - /* 317 */ "column_reference ::= column_name", - /* 318 */ "column_reference ::= table_name NK_DOT column_name", - /* 319 */ "pseudo_column ::= ROWTS", - /* 320 */ "pseudo_column ::= TBNAME", - /* 321 */ "pseudo_column ::= table_name NK_DOT TBNAME", - /* 322 */ "pseudo_column ::= QSTARTTS", - /* 323 */ "pseudo_column ::= QENDTS", - /* 324 */ "pseudo_column ::= WSTARTTS", - /* 325 */ "pseudo_column ::= WENDTS", - /* 326 */ "pseudo_column ::= WDURATION", - /* 327 */ "function_expression ::= function_name NK_LP expression_list NK_RP", - /* 328 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP", - /* 329 */ "function_expression ::= CAST NK_LP expression AS type_name NK_RP", - /* 330 */ "function_expression ::= literal_func", - /* 331 */ "literal_func ::= noarg_func NK_LP NK_RP", - /* 332 */ "literal_func ::= NOW", - /* 333 */ "noarg_func ::= NOW", - /* 334 */ "noarg_func ::= TODAY", - /* 335 */ "noarg_func ::= TIMEZONE", - /* 336 */ "star_func ::= COUNT", - /* 337 */ "star_func ::= FIRST", - /* 338 */ "star_func ::= LAST", - /* 339 */ "star_func ::= LAST_ROW", - /* 340 */ "star_func_para_list ::= NK_STAR", - /* 341 */ "star_func_para_list ::= other_para_list", - /* 342 */ "other_para_list ::= star_func_para", - /* 343 */ "other_para_list ::= other_para_list NK_COMMA star_func_para", - /* 344 */ "star_func_para ::= expression", - /* 345 */ "star_func_para ::= table_name NK_DOT NK_STAR", - /* 346 */ "predicate ::= expression compare_op expression", - /* 347 */ "predicate ::= expression BETWEEN expression AND expression", - /* 348 */ "predicate ::= expression NOT BETWEEN expression AND expression", - /* 349 */ "predicate ::= expression IS NULL", - /* 350 */ "predicate ::= expression IS NOT NULL", - /* 351 */ "predicate ::= expression in_op in_predicate_value", - /* 352 */ "compare_op ::= NK_LT", - /* 353 */ "compare_op ::= NK_GT", - /* 354 */ "compare_op ::= NK_LE", - /* 355 */ "compare_op ::= NK_GE", - /* 356 */ "compare_op ::= NK_NE", - /* 357 */ "compare_op ::= NK_EQ", - /* 358 */ "compare_op ::= LIKE", - /* 359 */ "compare_op ::= NOT LIKE", - /* 360 */ "compare_op ::= MATCH", - /* 361 */ "compare_op ::= NMATCH", - /* 362 */ "compare_op ::= CONTAINS", - /* 363 */ "in_op ::= IN", - /* 364 */ "in_op ::= NOT IN", - /* 365 */ "in_predicate_value ::= NK_LP expression_list NK_RP", - /* 366 */ "boolean_value_expression ::= boolean_primary", - /* 367 */ "boolean_value_expression ::= NOT boolean_primary", - /* 368 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression", - /* 369 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression", - /* 370 */ "boolean_primary ::= predicate", - /* 371 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP", - /* 372 */ "common_expression ::= expression", - /* 373 */ "common_expression ::= boolean_value_expression", - /* 374 */ "from_clause ::= FROM table_reference_list", - /* 375 */ "table_reference_list ::= table_reference", - /* 376 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference", - /* 377 */ "table_reference ::= table_primary", - /* 378 */ "table_reference ::= joined_table", - /* 379 */ "table_primary ::= table_name alias_opt", - /* 380 */ "table_primary ::= db_name NK_DOT table_name alias_opt", - /* 381 */ "table_primary ::= subquery alias_opt", - /* 382 */ "table_primary ::= parenthesized_joined_table", - /* 383 */ "alias_opt ::=", - /* 384 */ "alias_opt ::= table_alias", - /* 385 */ "alias_opt ::= AS table_alias", - /* 386 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP", - /* 387 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP", - /* 388 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition", - /* 389 */ "join_type ::=", - /* 390 */ "join_type ::= INNER", - /* 391 */ "query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt", - /* 392 */ "set_quantifier_opt ::=", - /* 393 */ "set_quantifier_opt ::= DISTINCT", - /* 394 */ "set_quantifier_opt ::= ALL", - /* 395 */ "select_list ::= NK_STAR", - /* 396 */ "select_list ::= select_sublist", - /* 397 */ "select_sublist ::= select_item", - /* 398 */ "select_sublist ::= select_sublist NK_COMMA select_item", - /* 399 */ "select_item ::= common_expression", - /* 400 */ "select_item ::= common_expression column_alias", - /* 401 */ "select_item ::= common_expression AS column_alias", - /* 402 */ "select_item ::= table_name NK_DOT NK_STAR", - /* 403 */ "where_clause_opt ::=", - /* 404 */ "where_clause_opt ::= WHERE search_condition", - /* 405 */ "partition_by_clause_opt ::=", - /* 406 */ "partition_by_clause_opt ::= PARTITION BY expression_list", - /* 407 */ "twindow_clause_opt ::=", - /* 408 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP", - /* 409 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP", - /* 410 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt", - /* 411 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt", - /* 412 */ "sliding_opt ::=", - /* 413 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP", - /* 414 */ "fill_opt ::=", - /* 415 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", - /* 416 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP", - /* 417 */ "fill_mode ::= NONE", - /* 418 */ "fill_mode ::= PREV", - /* 419 */ "fill_mode ::= NULL", - /* 420 */ "fill_mode ::= LINEAR", - /* 421 */ "fill_mode ::= NEXT", - /* 422 */ "group_by_clause_opt ::=", - /* 423 */ "group_by_clause_opt ::= GROUP BY group_by_list", - /* 424 */ "group_by_list ::= expression", - /* 425 */ "group_by_list ::= group_by_list NK_COMMA expression", - /* 426 */ "having_clause_opt ::=", - /* 427 */ "having_clause_opt ::= HAVING search_condition", - /* 428 */ "query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt", - /* 429 */ "query_expression_body ::= query_primary", - /* 430 */ "query_expression_body ::= query_expression_body UNION ALL query_expression_body", - /* 431 */ "query_expression_body ::= query_expression_body UNION query_expression_body", - /* 432 */ "query_primary ::= query_specification", - /* 433 */ "query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP", - /* 434 */ "order_by_clause_opt ::=", - /* 435 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", - /* 436 */ "slimit_clause_opt ::=", - /* 437 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", - /* 438 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", - /* 439 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 440 */ "limit_clause_opt ::=", - /* 441 */ "limit_clause_opt ::= LIMIT NK_INTEGER", - /* 442 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", - /* 443 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 444 */ "subquery ::= NK_LP query_expression NK_RP", - /* 445 */ "search_condition ::= common_expression", - /* 446 */ "sort_specification_list ::= sort_specification", - /* 447 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", - /* 448 */ "sort_specification ::= expression ordering_specification_opt null_ordering_opt", - /* 449 */ "ordering_specification_opt ::=", - /* 450 */ "ordering_specification_opt ::= ASC", - /* 451 */ "ordering_specification_opt ::= DESC", - /* 452 */ "null_ordering_opt ::=", - /* 453 */ "null_ordering_opt ::= NULLS FIRST", - /* 454 */ "null_ordering_opt ::= NULLS LAST", + /* 165 */ "table_options ::= table_options FILE_FACTOR NK_FLOAT", + /* 166 */ "table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP", + /* 167 */ "table_options ::= table_options TTL NK_INTEGER", + /* 168 */ "table_options ::= table_options SMA NK_LP col_name_list NK_RP", + /* 169 */ "alter_table_options ::= alter_table_option", + /* 170 */ "alter_table_options ::= alter_table_options alter_table_option", + /* 171 */ "alter_table_option ::= COMMENT NK_STRING", + /* 172 */ "alter_table_option ::= TTL NK_INTEGER", + /* 173 */ "col_name_list ::= col_name", + /* 174 */ "col_name_list ::= col_name_list NK_COMMA col_name", + /* 175 */ "col_name ::= column_name", + /* 176 */ "cmd ::= SHOW DNODES", + /* 177 */ "cmd ::= SHOW USERS", + /* 178 */ "cmd ::= SHOW DATABASES", + /* 179 */ "cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt", + /* 180 */ "cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt", + /* 181 */ "cmd ::= SHOW db_name_cond_opt VGROUPS", + /* 182 */ "cmd ::= SHOW MNODES", + /* 183 */ "cmd ::= SHOW MODULES", + /* 184 */ "cmd ::= SHOW QNODES", + /* 185 */ "cmd ::= SHOW FUNCTIONS", + /* 186 */ "cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt", + /* 187 */ "cmd ::= SHOW STREAMS", + /* 188 */ "cmd ::= SHOW ACCOUNTS", + /* 189 */ "cmd ::= SHOW APPS", + /* 190 */ "cmd ::= SHOW CONNECTIONS", + /* 191 */ "cmd ::= SHOW LICENCE", + /* 192 */ "cmd ::= SHOW GRANTS", + /* 193 */ "cmd ::= SHOW CREATE DATABASE db_name", + /* 194 */ "cmd ::= SHOW CREATE TABLE full_table_name", + /* 195 */ "cmd ::= SHOW CREATE STABLE full_table_name", + /* 196 */ "cmd ::= SHOW QUERIES", + /* 197 */ "cmd ::= SHOW SCORES", + /* 198 */ "cmd ::= SHOW TOPICS", + /* 199 */ "cmd ::= SHOW VARIABLES", + /* 200 */ "cmd ::= SHOW BNODES", + /* 201 */ "cmd ::= SHOW SNODES", + /* 202 */ "cmd ::= SHOW CLUSTER", + /* 203 */ "cmd ::= SHOW TRANSACTIONS", + /* 204 */ "db_name_cond_opt ::=", + /* 205 */ "db_name_cond_opt ::= db_name NK_DOT", + /* 206 */ "like_pattern_opt ::=", + /* 207 */ "like_pattern_opt ::= LIKE NK_STRING", + /* 208 */ "table_name_cond ::= table_name", + /* 209 */ "from_db_opt ::=", + /* 210 */ "from_db_opt ::= FROM db_name", + /* 211 */ "func_name_list ::= func_name", + /* 212 */ "func_name_list ::= func_name_list NK_COMMA func_name", + /* 213 */ "func_name ::= function_name", + /* 214 */ "cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options", + /* 215 */ "cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP", + /* 216 */ "cmd ::= DROP INDEX exists_opt index_name ON table_name", + /* 217 */ "index_options ::=", + /* 218 */ "index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt", + /* 219 */ "index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt", + /* 220 */ "func_list ::= func", + /* 221 */ "func_list ::= func_list NK_COMMA func", + /* 222 */ "func ::= function_name NK_LP expression_list NK_RP", + /* 223 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS query_expression", + /* 224 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS db_name", + /* 225 */ "cmd ::= DROP TOPIC exists_opt topic_name", + /* 226 */ "cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name", + /* 227 */ "topic_options ::=", + /* 228 */ "topic_options ::= topic_options WITH TABLE", + /* 229 */ "topic_options ::= topic_options WITH SCHEMA", + /* 230 */ "topic_options ::= topic_options WITH TAG", + /* 231 */ "cmd ::= DESC full_table_name", + /* 232 */ "cmd ::= DESCRIBE full_table_name", + /* 233 */ "cmd ::= RESET QUERY CACHE", + /* 234 */ "cmd ::= EXPLAIN analyze_opt explain_options query_expression", + /* 235 */ "analyze_opt ::=", + /* 236 */ "analyze_opt ::= ANALYZE", + /* 237 */ "explain_options ::=", + /* 238 */ "explain_options ::= explain_options VERBOSE NK_BOOL", + /* 239 */ "explain_options ::= explain_options RATIO NK_FLOAT", + /* 240 */ "cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP", + /* 241 */ "cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt", + /* 242 */ "cmd ::= DROP FUNCTION exists_opt function_name", + /* 243 */ "agg_func_opt ::=", + /* 244 */ "agg_func_opt ::= AGGREGATE", + /* 245 */ "bufsize_opt ::=", + /* 246 */ "bufsize_opt ::= BUFSIZE NK_INTEGER", + /* 247 */ "cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression", + /* 248 */ "cmd ::= DROP STREAM exists_opt stream_name", + /* 249 */ "into_opt ::=", + /* 250 */ "into_opt ::= INTO full_table_name", + /* 251 */ "stream_options ::=", + /* 252 */ "stream_options ::= stream_options TRIGGER AT_ONCE", + /* 253 */ "stream_options ::= stream_options TRIGGER WINDOW_CLOSE", + /* 254 */ "stream_options ::= stream_options WATERMARK duration_literal", + /* 255 */ "cmd ::= KILL CONNECTION NK_INTEGER", + /* 256 */ "cmd ::= KILL QUERY NK_INTEGER", + /* 257 */ "cmd ::= KILL TRANSACTION NK_INTEGER", + /* 258 */ "cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER", + /* 259 */ "cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list", + /* 260 */ "cmd ::= SPLIT VGROUP NK_INTEGER", + /* 261 */ "dnode_list ::= DNODE NK_INTEGER", + /* 262 */ "dnode_list ::= dnode_list DNODE NK_INTEGER", + /* 263 */ "cmd ::= SYNCDB db_name REPLICA", + /* 264 */ "cmd ::= query_expression", + /* 265 */ "literal ::= NK_INTEGER", + /* 266 */ "literal ::= NK_FLOAT", + /* 267 */ "literal ::= NK_STRING", + /* 268 */ "literal ::= NK_BOOL", + /* 269 */ "literal ::= TIMESTAMP NK_STRING", + /* 270 */ "literal ::= duration_literal", + /* 271 */ "literal ::= NULL", + /* 272 */ "literal ::= NK_QUESTION", + /* 273 */ "duration_literal ::= NK_VARIABLE", + /* 274 */ "signed ::= NK_INTEGER", + /* 275 */ "signed ::= NK_PLUS NK_INTEGER", + /* 276 */ "signed ::= NK_MINUS NK_INTEGER", + /* 277 */ "signed ::= NK_FLOAT", + /* 278 */ "signed ::= NK_PLUS NK_FLOAT", + /* 279 */ "signed ::= NK_MINUS NK_FLOAT", + /* 280 */ "signed_literal ::= signed", + /* 281 */ "signed_literal ::= NK_STRING", + /* 282 */ "signed_literal ::= NK_BOOL", + /* 283 */ "signed_literal ::= TIMESTAMP NK_STRING", + /* 284 */ "signed_literal ::= duration_literal", + /* 285 */ "signed_literal ::= NULL", + /* 286 */ "signed_literal ::= literal_func", + /* 287 */ "literal_list ::= signed_literal", + /* 288 */ "literal_list ::= literal_list NK_COMMA signed_literal", + /* 289 */ "db_name ::= NK_ID", + /* 290 */ "table_name ::= NK_ID", + /* 291 */ "column_name ::= NK_ID", + /* 292 */ "function_name ::= NK_ID", + /* 293 */ "table_alias ::= NK_ID", + /* 294 */ "column_alias ::= NK_ID", + /* 295 */ "user_name ::= NK_ID", + /* 296 */ "index_name ::= NK_ID", + /* 297 */ "topic_name ::= NK_ID", + /* 298 */ "stream_name ::= NK_ID", + /* 299 */ "cgroup_name ::= NK_ID", + /* 300 */ "expression ::= literal", + /* 301 */ "expression ::= pseudo_column", + /* 302 */ "expression ::= column_reference", + /* 303 */ "expression ::= function_expression", + /* 304 */ "expression ::= subquery", + /* 305 */ "expression ::= NK_LP expression NK_RP", + /* 306 */ "expression ::= NK_PLUS expression", + /* 307 */ "expression ::= NK_MINUS expression", + /* 308 */ "expression ::= expression NK_PLUS expression", + /* 309 */ "expression ::= expression NK_MINUS expression", + /* 310 */ "expression ::= expression NK_STAR expression", + /* 311 */ "expression ::= expression NK_SLASH expression", + /* 312 */ "expression ::= expression NK_REM expression", + /* 313 */ "expression ::= column_reference NK_ARROW NK_STRING", + /* 314 */ "expression_list ::= expression", + /* 315 */ "expression_list ::= expression_list NK_COMMA expression", + /* 316 */ "column_reference ::= column_name", + /* 317 */ "column_reference ::= table_name NK_DOT column_name", + /* 318 */ "pseudo_column ::= ROWTS", + /* 319 */ "pseudo_column ::= TBNAME", + /* 320 */ "pseudo_column ::= table_name NK_DOT TBNAME", + /* 321 */ "pseudo_column ::= QSTARTTS", + /* 322 */ "pseudo_column ::= QENDTS", + /* 323 */ "pseudo_column ::= WSTARTTS", + /* 324 */ "pseudo_column ::= WENDTS", + /* 325 */ "pseudo_column ::= WDURATION", + /* 326 */ "function_expression ::= function_name NK_LP expression_list NK_RP", + /* 327 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP", + /* 328 */ "function_expression ::= CAST NK_LP expression AS type_name NK_RP", + /* 329 */ "function_expression ::= literal_func", + /* 330 */ "literal_func ::= noarg_func NK_LP NK_RP", + /* 331 */ "literal_func ::= NOW", + /* 332 */ "noarg_func ::= NOW", + /* 333 */ "noarg_func ::= TODAY", + /* 334 */ "noarg_func ::= TIMEZONE", + /* 335 */ "star_func ::= COUNT", + /* 336 */ "star_func ::= FIRST", + /* 337 */ "star_func ::= LAST", + /* 338 */ "star_func ::= LAST_ROW", + /* 339 */ "star_func_para_list ::= NK_STAR", + /* 340 */ "star_func_para_list ::= other_para_list", + /* 341 */ "other_para_list ::= star_func_para", + /* 342 */ "other_para_list ::= other_para_list NK_COMMA star_func_para", + /* 343 */ "star_func_para ::= expression", + /* 344 */ "star_func_para ::= table_name NK_DOT NK_STAR", + /* 345 */ "predicate ::= expression compare_op expression", + /* 346 */ "predicate ::= expression BETWEEN expression AND expression", + /* 347 */ "predicate ::= expression NOT BETWEEN expression AND expression", + /* 348 */ "predicate ::= expression IS NULL", + /* 349 */ "predicate ::= expression IS NOT NULL", + /* 350 */ "predicate ::= expression in_op in_predicate_value", + /* 351 */ "compare_op ::= NK_LT", + /* 352 */ "compare_op ::= NK_GT", + /* 353 */ "compare_op ::= NK_LE", + /* 354 */ "compare_op ::= NK_GE", + /* 355 */ "compare_op ::= NK_NE", + /* 356 */ "compare_op ::= NK_EQ", + /* 357 */ "compare_op ::= LIKE", + /* 358 */ "compare_op ::= NOT LIKE", + /* 359 */ "compare_op ::= MATCH", + /* 360 */ "compare_op ::= NMATCH", + /* 361 */ "compare_op ::= CONTAINS", + /* 362 */ "in_op ::= IN", + /* 363 */ "in_op ::= NOT IN", + /* 364 */ "in_predicate_value ::= NK_LP expression_list NK_RP", + /* 365 */ "boolean_value_expression ::= boolean_primary", + /* 366 */ "boolean_value_expression ::= NOT boolean_primary", + /* 367 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression", + /* 368 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression", + /* 369 */ "boolean_primary ::= predicate", + /* 370 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP", + /* 371 */ "common_expression ::= expression", + /* 372 */ "common_expression ::= boolean_value_expression", + /* 373 */ "from_clause ::= FROM table_reference_list", + /* 374 */ "table_reference_list ::= table_reference", + /* 375 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference", + /* 376 */ "table_reference ::= table_primary", + /* 377 */ "table_reference ::= joined_table", + /* 378 */ "table_primary ::= table_name alias_opt", + /* 379 */ "table_primary ::= db_name NK_DOT table_name alias_opt", + /* 380 */ "table_primary ::= subquery alias_opt", + /* 381 */ "table_primary ::= parenthesized_joined_table", + /* 382 */ "alias_opt ::=", + /* 383 */ "alias_opt ::= table_alias", + /* 384 */ "alias_opt ::= AS table_alias", + /* 385 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP", + /* 386 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP", + /* 387 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition", + /* 388 */ "join_type ::=", + /* 389 */ "join_type ::= INNER", + /* 390 */ "query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt", + /* 391 */ "set_quantifier_opt ::=", + /* 392 */ "set_quantifier_opt ::= DISTINCT", + /* 393 */ "set_quantifier_opt ::= ALL", + /* 394 */ "select_list ::= NK_STAR", + /* 395 */ "select_list ::= select_sublist", + /* 396 */ "select_sublist ::= select_item", + /* 397 */ "select_sublist ::= select_sublist NK_COMMA select_item", + /* 398 */ "select_item ::= common_expression", + /* 399 */ "select_item ::= common_expression column_alias", + /* 400 */ "select_item ::= common_expression AS column_alias", + /* 401 */ "select_item ::= table_name NK_DOT NK_STAR", + /* 402 */ "where_clause_opt ::=", + /* 403 */ "where_clause_opt ::= WHERE search_condition", + /* 404 */ "partition_by_clause_opt ::=", + /* 405 */ "partition_by_clause_opt ::= PARTITION BY expression_list", + /* 406 */ "twindow_clause_opt ::=", + /* 407 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP", + /* 408 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP", + /* 409 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt", + /* 410 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt", + /* 411 */ "sliding_opt ::=", + /* 412 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP", + /* 413 */ "fill_opt ::=", + /* 414 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", + /* 415 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP", + /* 416 */ "fill_mode ::= NONE", + /* 417 */ "fill_mode ::= PREV", + /* 418 */ "fill_mode ::= NULL", + /* 419 */ "fill_mode ::= LINEAR", + /* 420 */ "fill_mode ::= NEXT", + /* 421 */ "group_by_clause_opt ::=", + /* 422 */ "group_by_clause_opt ::= GROUP BY group_by_list", + /* 423 */ "group_by_list ::= expression", + /* 424 */ "group_by_list ::= group_by_list NK_COMMA expression", + /* 425 */ "having_clause_opt ::=", + /* 426 */ "having_clause_opt ::= HAVING search_condition", + /* 427 */ "query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt", + /* 428 */ "query_expression_body ::= query_primary", + /* 429 */ "query_expression_body ::= query_expression_body UNION ALL query_expression_body", + /* 430 */ "query_expression_body ::= query_expression_body UNION query_expression_body", + /* 431 */ "query_primary ::= query_specification", + /* 432 */ "query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP", + /* 433 */ "order_by_clause_opt ::=", + /* 434 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", + /* 435 */ "slimit_clause_opt ::=", + /* 436 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", + /* 437 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", + /* 438 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 439 */ "limit_clause_opt ::=", + /* 440 */ "limit_clause_opt ::= LIMIT NK_INTEGER", + /* 441 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", + /* 442 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 443 */ "subquery ::= NK_LP query_expression NK_RP", + /* 444 */ "search_condition ::= common_expression", + /* 445 */ "sort_specification_list ::= sort_specification", + /* 446 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", + /* 447 */ "sort_specification ::= expression ordering_specification_opt null_ordering_opt", + /* 448 */ "ordering_specification_opt ::=", + /* 449 */ "ordering_specification_opt ::= ASC", + /* 450 */ "ordering_specification_opt ::= DESC", + /* 451 */ "null_ordering_opt ::=", + /* 452 */ "null_ordering_opt ::= NULLS FIRST", + /* 453 */ "null_ordering_opt ::= NULLS LAST", }; #endif /* NDEBUG */ @@ -2106,175 +2119,175 @@ static void yy_destructor( */ /********* Begin destructor definitions ***************************************/ /* Default NON-TERMINAL Destructor */ - case 240: /* cmd */ - case 243: /* literal */ - case 254: /* db_options */ - case 256: /* alter_db_options */ - case 261: /* retention */ - case 262: /* full_table_name */ - case 265: /* table_options */ - case 269: /* alter_table_clause */ - case 270: /* alter_table_options */ - case 273: /* signed_literal */ - case 274: /* create_subtable_clause */ - case 277: /* drop_table_clause */ - case 280: /* column_def */ - case 283: /* col_name */ - case 284: /* db_name_cond_opt */ - case 285: /* like_pattern_opt */ - case 286: /* table_name_cond */ - case 287: /* from_db_opt */ - case 288: /* func_name */ - case 291: /* index_options */ - case 293: /* duration_literal */ - case 294: /* sliding_opt */ - case 295: /* func */ - case 298: /* topic_options */ - case 299: /* query_expression */ - case 302: /* explain_options */ - case 306: /* stream_options */ - case 307: /* into_opt */ - case 309: /* signed */ - case 310: /* literal_func */ - case 313: /* expression */ - case 314: /* pseudo_column */ - case 315: /* column_reference */ - case 316: /* function_expression */ - case 317: /* subquery */ - case 322: /* star_func_para */ - case 323: /* predicate */ - case 326: /* in_predicate_value */ - case 327: /* boolean_value_expression */ - case 328: /* boolean_primary */ - case 329: /* common_expression */ - case 330: /* from_clause */ - case 331: /* table_reference_list */ - case 332: /* table_reference */ - case 333: /* table_primary */ - case 334: /* joined_table */ - case 336: /* parenthesized_joined_table */ - case 338: /* search_condition */ - case 339: /* query_specification */ - case 342: /* where_clause_opt */ - case 344: /* twindow_clause_opt */ - case 346: /* having_clause_opt */ - case 348: /* select_item */ - case 349: /* fill_opt */ - case 352: /* query_expression_body */ - case 354: /* slimit_clause_opt */ - case 355: /* limit_clause_opt */ - case 356: /* query_primary */ - case 358: /* sort_specification */ + case 239: /* cmd */ + case 242: /* literal */ + case 253: /* db_options */ + case 255: /* alter_db_options */ + case 260: /* retention */ + case 261: /* full_table_name */ + case 264: /* table_options */ + case 268: /* alter_table_clause */ + case 269: /* alter_table_options */ + case 272: /* signed_literal */ + case 273: /* create_subtable_clause */ + case 276: /* drop_table_clause */ + case 279: /* column_def */ + case 282: /* col_name */ + case 283: /* db_name_cond_opt */ + case 284: /* like_pattern_opt */ + case 285: /* table_name_cond */ + case 286: /* from_db_opt */ + case 287: /* func_name */ + case 290: /* index_options */ + case 292: /* duration_literal */ + case 293: /* sliding_opt */ + case 294: /* func */ + case 297: /* topic_options */ + case 298: /* query_expression */ + case 301: /* explain_options */ + case 305: /* stream_options */ + case 306: /* into_opt */ + case 308: /* signed */ + case 309: /* literal_func */ + case 312: /* expression */ + case 313: /* pseudo_column */ + case 314: /* column_reference */ + case 315: /* function_expression */ + case 316: /* subquery */ + case 321: /* star_func_para */ + case 322: /* predicate */ + case 325: /* in_predicate_value */ + case 326: /* boolean_value_expression */ + case 327: /* boolean_primary */ + case 328: /* common_expression */ + case 329: /* from_clause */ + case 330: /* table_reference_list */ + case 331: /* table_reference */ + case 332: /* table_primary */ + case 333: /* joined_table */ + case 335: /* parenthesized_joined_table */ + case 337: /* search_condition */ + case 338: /* query_specification */ + case 341: /* where_clause_opt */ + case 343: /* twindow_clause_opt */ + case 345: /* having_clause_opt */ + case 347: /* select_item */ + case 348: /* fill_opt */ + case 351: /* query_expression_body */ + case 353: /* slimit_clause_opt */ + case 354: /* limit_clause_opt */ + case 355: /* query_primary */ + case 357: /* sort_specification */ { - nodesDestroyNode((yypminor->yy636)); + nodesDestroyNode((yypminor->yy632)); } break; - case 241: /* account_options */ - case 242: /* alter_account_options */ - case 244: /* alter_account_option */ - case 304: /* bufsize_opt */ + case 240: /* account_options */ + case 241: /* alter_account_options */ + case 243: /* alter_account_option */ + case 303: /* bufsize_opt */ { } break; - case 245: /* user_name */ - case 247: /* priv_level */ - case 250: /* db_name */ - case 251: /* dnode_endpoint */ - case 252: /* dnode_host_name */ - case 271: /* column_name */ - case 279: /* table_name */ - case 289: /* function_name */ - case 290: /* index_name */ - case 297: /* topic_name */ - case 300: /* cgroup_name */ - case 305: /* stream_name */ - case 311: /* table_alias */ - case 312: /* column_alias */ - case 318: /* star_func */ - case 320: /* noarg_func */ - case 335: /* alias_opt */ + case 244: /* user_name */ + case 246: /* priv_level */ + case 249: /* db_name */ + case 250: /* dnode_endpoint */ + case 251: /* dnode_host_name */ + case 270: /* column_name */ + case 278: /* table_name */ + case 288: /* function_name */ + case 289: /* index_name */ + case 296: /* topic_name */ + case 299: /* cgroup_name */ + case 304: /* stream_name */ + case 310: /* table_alias */ + case 311: /* column_alias */ + case 317: /* star_func */ + case 319: /* noarg_func */ + case 334: /* alias_opt */ { } break; - case 246: /* privileges */ - case 248: /* priv_type_list */ - case 249: /* priv_type */ + case 245: /* privileges */ + case 247: /* priv_type_list */ + case 248: /* priv_type */ { } break; - case 253: /* not_exists_opt */ - case 255: /* exists_opt */ - case 301: /* analyze_opt */ - case 303: /* agg_func_opt */ - case 340: /* set_quantifier_opt */ + case 252: /* not_exists_opt */ + case 254: /* exists_opt */ + case 300: /* analyze_opt */ + case 302: /* agg_func_opt */ + case 339: /* set_quantifier_opt */ { } break; - case 257: /* integer_list */ - case 258: /* variable_list */ - case 259: /* retention_list */ - case 263: /* column_def_list */ - case 264: /* tags_def_opt */ - case 266: /* multi_create_clause */ - case 267: /* tags_def */ - case 268: /* multi_drop_clause */ - case 275: /* specific_tags_opt */ - case 276: /* literal_list */ - case 278: /* col_name_list */ - case 281: /* func_name_list */ - case 292: /* func_list */ - case 296: /* expression_list */ - case 308: /* dnode_list */ - case 319: /* star_func_para_list */ - case 321: /* other_para_list */ - case 341: /* select_list */ - case 343: /* partition_by_clause_opt */ - case 345: /* group_by_clause_opt */ - case 347: /* select_sublist */ - case 351: /* group_by_list */ - case 353: /* order_by_clause_opt */ - case 357: /* sort_specification_list */ + case 256: /* integer_list */ + case 257: /* variable_list */ + case 258: /* retention_list */ + case 262: /* column_def_list */ + case 263: /* tags_def_opt */ + case 265: /* multi_create_clause */ + case 266: /* tags_def */ + case 267: /* multi_drop_clause */ + case 274: /* specific_tags_opt */ + case 275: /* literal_list */ + case 277: /* col_name_list */ + case 280: /* func_name_list */ + case 291: /* func_list */ + case 295: /* expression_list */ + case 307: /* dnode_list */ + case 318: /* star_func_para_list */ + case 320: /* other_para_list */ + case 340: /* select_list */ + case 342: /* partition_by_clause_opt */ + case 344: /* group_by_clause_opt */ + case 346: /* select_sublist */ + case 350: /* group_by_list */ + case 352: /* order_by_clause_opt */ + case 356: /* sort_specification_list */ { - nodesDestroyList((yypminor->yy236)); + nodesDestroyList((yypminor->yy424)); } break; - case 260: /* alter_db_option */ - case 282: /* alter_table_option */ + case 259: /* alter_db_option */ + case 281: /* alter_table_option */ { } break; - case 272: /* type_name */ + case 271: /* type_name */ { } break; - case 324: /* compare_op */ - case 325: /* in_op */ + case 323: /* compare_op */ + case 324: /* in_op */ { } break; - case 337: /* join_type */ + case 336: /* join_type */ { } break; - case 350: /* fill_mode */ + case 349: /* fill_mode */ { } break; - case 359: /* ordering_specification_opt */ + case 358: /* ordering_specification_opt */ { } break; - case 360: /* null_ordering_opt */ + case 359: /* null_ordering_opt */ { } @@ -2573,461 +2586,460 @@ static const struct { YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */ signed char nrhs; /* Negative of the number of RHS symbols in the rule */ } yyRuleInfo[] = { - { 240, -6 }, /* (0) cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */ - { 240, -4 }, /* (1) cmd ::= ALTER ACCOUNT NK_ID alter_account_options */ - { 241, 0 }, /* (2) account_options ::= */ - { 241, -3 }, /* (3) account_options ::= account_options PPS literal */ - { 241, -3 }, /* (4) account_options ::= account_options TSERIES literal */ - { 241, -3 }, /* (5) account_options ::= account_options STORAGE literal */ - { 241, -3 }, /* (6) account_options ::= account_options STREAMS literal */ - { 241, -3 }, /* (7) account_options ::= account_options QTIME literal */ - { 241, -3 }, /* (8) account_options ::= account_options DBS literal */ - { 241, -3 }, /* (9) account_options ::= account_options USERS literal */ - { 241, -3 }, /* (10) account_options ::= account_options CONNS literal */ - { 241, -3 }, /* (11) account_options ::= account_options STATE literal */ - { 242, -1 }, /* (12) alter_account_options ::= alter_account_option */ - { 242, -2 }, /* (13) alter_account_options ::= alter_account_options alter_account_option */ - { 244, -2 }, /* (14) alter_account_option ::= PASS literal */ - { 244, -2 }, /* (15) alter_account_option ::= PPS literal */ - { 244, -2 }, /* (16) alter_account_option ::= TSERIES literal */ - { 244, -2 }, /* (17) alter_account_option ::= STORAGE literal */ - { 244, -2 }, /* (18) alter_account_option ::= STREAMS literal */ - { 244, -2 }, /* (19) alter_account_option ::= QTIME literal */ - { 244, -2 }, /* (20) alter_account_option ::= DBS literal */ - { 244, -2 }, /* (21) alter_account_option ::= USERS literal */ - { 244, -2 }, /* (22) alter_account_option ::= CONNS literal */ - { 244, -2 }, /* (23) alter_account_option ::= STATE literal */ - { 240, -5 }, /* (24) cmd ::= CREATE USER user_name PASS NK_STRING */ - { 240, -5 }, /* (25) cmd ::= ALTER USER user_name PASS NK_STRING */ - { 240, -5 }, /* (26) cmd ::= ALTER USER user_name PRIVILEGE NK_STRING */ - { 240, -3 }, /* (27) cmd ::= DROP USER user_name */ - { 240, -6 }, /* (28) cmd ::= GRANT privileges ON priv_level TO user_name */ - { 240, -6 }, /* (29) cmd ::= REVOKE privileges ON priv_level FROM user_name */ - { 246, -1 }, /* (30) privileges ::= ALL */ - { 246, -1 }, /* (31) privileges ::= priv_type_list */ - { 248, -1 }, /* (32) priv_type_list ::= priv_type */ - { 248, -3 }, /* (33) priv_type_list ::= priv_type_list NK_COMMA priv_type */ - { 249, -1 }, /* (34) priv_type ::= READ */ - { 249, -1 }, /* (35) priv_type ::= WRITE */ - { 247, -3 }, /* (36) priv_level ::= NK_STAR NK_DOT NK_STAR */ - { 247, -3 }, /* (37) priv_level ::= db_name NK_DOT NK_STAR */ - { 240, -3 }, /* (38) cmd ::= CREATE DNODE dnode_endpoint */ - { 240, -5 }, /* (39) cmd ::= CREATE DNODE dnode_host_name PORT NK_INTEGER */ - { 240, -3 }, /* (40) cmd ::= DROP DNODE NK_INTEGER */ - { 240, -3 }, /* (41) cmd ::= DROP DNODE dnode_endpoint */ - { 240, -4 }, /* (42) cmd ::= ALTER DNODE NK_INTEGER NK_STRING */ - { 240, -5 }, /* (43) cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */ - { 240, -4 }, /* (44) cmd ::= ALTER ALL DNODES NK_STRING */ - { 240, -5 }, /* (45) cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */ - { 251, -1 }, /* (46) dnode_endpoint ::= NK_STRING */ - { 252, -1 }, /* (47) dnode_host_name ::= NK_ID */ - { 252, -1 }, /* (48) dnode_host_name ::= NK_IPTOKEN */ - { 240, -3 }, /* (49) cmd ::= ALTER LOCAL NK_STRING */ - { 240, -4 }, /* (50) cmd ::= ALTER LOCAL NK_STRING NK_STRING */ - { 240, -5 }, /* (51) cmd ::= CREATE QNODE ON DNODE NK_INTEGER */ - { 240, -5 }, /* (52) cmd ::= DROP QNODE ON DNODE NK_INTEGER */ - { 240, -5 }, /* (53) cmd ::= CREATE BNODE ON DNODE NK_INTEGER */ - { 240, -5 }, /* (54) cmd ::= DROP BNODE ON DNODE NK_INTEGER */ - { 240, -5 }, /* (55) cmd ::= CREATE SNODE ON DNODE NK_INTEGER */ - { 240, -5 }, /* (56) cmd ::= DROP SNODE ON DNODE NK_INTEGER */ - { 240, -5 }, /* (57) cmd ::= CREATE MNODE ON DNODE NK_INTEGER */ - { 240, -5 }, /* (58) cmd ::= DROP MNODE ON DNODE NK_INTEGER */ - { 240, -5 }, /* (59) cmd ::= CREATE DATABASE not_exists_opt db_name db_options */ - { 240, -4 }, /* (60) cmd ::= DROP DATABASE exists_opt db_name */ - { 240, -2 }, /* (61) cmd ::= USE db_name */ - { 240, -4 }, /* (62) cmd ::= ALTER DATABASE db_name alter_db_options */ - { 253, -3 }, /* (63) not_exists_opt ::= IF NOT EXISTS */ - { 253, 0 }, /* (64) not_exists_opt ::= */ - { 255, -2 }, /* (65) exists_opt ::= IF EXISTS */ - { 255, 0 }, /* (66) exists_opt ::= */ - { 254, 0 }, /* (67) db_options ::= */ - { 254, -3 }, /* (68) db_options ::= db_options BUFFER NK_INTEGER */ - { 254, -3 }, /* (69) db_options ::= db_options CACHELAST NK_INTEGER */ - { 254, -3 }, /* (70) db_options ::= db_options COMP NK_INTEGER */ - { 254, -3 }, /* (71) db_options ::= db_options DAYS NK_INTEGER */ - { 254, -3 }, /* (72) db_options ::= db_options DAYS NK_VARIABLE */ - { 254, -3 }, /* (73) db_options ::= db_options FSYNC NK_INTEGER */ - { 254, -3 }, /* (74) db_options ::= db_options MAXROWS NK_INTEGER */ - { 254, -3 }, /* (75) db_options ::= db_options MINROWS NK_INTEGER */ - { 254, -3 }, /* (76) db_options ::= db_options KEEP integer_list */ - { 254, -3 }, /* (77) db_options ::= db_options KEEP variable_list */ - { 254, -3 }, /* (78) db_options ::= db_options PAGES NK_INTEGER */ - { 254, -3 }, /* (79) db_options ::= db_options PAGESIZE NK_INTEGER */ - { 254, -3 }, /* (80) db_options ::= db_options PRECISION NK_STRING */ - { 254, -3 }, /* (81) db_options ::= db_options REPLICA NK_INTEGER */ - { 254, -3 }, /* (82) db_options ::= db_options STRICT NK_INTEGER */ - { 254, -3 }, /* (83) db_options ::= db_options WAL NK_INTEGER */ - { 254, -3 }, /* (84) db_options ::= db_options VGROUPS NK_INTEGER */ - { 254, -3 }, /* (85) db_options ::= db_options SINGLE_STABLE NK_INTEGER */ - { 254, -3 }, /* (86) db_options ::= db_options RETENTIONS retention_list */ - { 254, -3 }, /* (87) db_options ::= db_options SCHEMALESS NK_INTEGER */ - { 256, -1 }, /* (88) alter_db_options ::= alter_db_option */ - { 256, -2 }, /* (89) alter_db_options ::= alter_db_options alter_db_option */ - { 260, -2 }, /* (90) alter_db_option ::= BUFFER NK_INTEGER */ - { 260, -2 }, /* (91) alter_db_option ::= CACHELAST NK_INTEGER */ - { 260, -2 }, /* (92) alter_db_option ::= FSYNC NK_INTEGER */ - { 260, -2 }, /* (93) alter_db_option ::= KEEP integer_list */ - { 260, -2 }, /* (94) alter_db_option ::= KEEP variable_list */ - { 260, -2 }, /* (95) alter_db_option ::= PAGES NK_INTEGER */ - { 260, -2 }, /* (96) alter_db_option ::= REPLICA NK_INTEGER */ - { 260, -2 }, /* (97) alter_db_option ::= STRICT NK_INTEGER */ - { 260, -2 }, /* (98) alter_db_option ::= WAL NK_INTEGER */ - { 257, -1 }, /* (99) integer_list ::= NK_INTEGER */ - { 257, -3 }, /* (100) integer_list ::= integer_list NK_COMMA NK_INTEGER */ - { 258, -1 }, /* (101) variable_list ::= NK_VARIABLE */ - { 258, -3 }, /* (102) variable_list ::= variable_list NK_COMMA NK_VARIABLE */ - { 259, -1 }, /* (103) retention_list ::= retention */ - { 259, -3 }, /* (104) retention_list ::= retention_list NK_COMMA retention */ - { 261, -3 }, /* (105) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ - { 240, -9 }, /* (106) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ - { 240, -3 }, /* (107) cmd ::= CREATE TABLE multi_create_clause */ - { 240, -9 }, /* (108) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ - { 240, -3 }, /* (109) cmd ::= DROP TABLE multi_drop_clause */ - { 240, -4 }, /* (110) cmd ::= DROP STABLE exists_opt full_table_name */ - { 240, -3 }, /* (111) cmd ::= ALTER TABLE alter_table_clause */ - { 240, -3 }, /* (112) cmd ::= ALTER STABLE alter_table_clause */ - { 269, -2 }, /* (113) alter_table_clause ::= full_table_name alter_table_options */ - { 269, -5 }, /* (114) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ - { 269, -4 }, /* (115) alter_table_clause ::= full_table_name DROP COLUMN column_name */ - { 269, -5 }, /* (116) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ - { 269, -5 }, /* (117) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ - { 269, -5 }, /* (118) alter_table_clause ::= full_table_name ADD TAG column_name type_name */ - { 269, -4 }, /* (119) alter_table_clause ::= full_table_name DROP TAG column_name */ - { 269, -5 }, /* (120) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ - { 269, -5 }, /* (121) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ - { 269, -6 }, /* (122) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ - { 266, -1 }, /* (123) multi_create_clause ::= create_subtable_clause */ - { 266, -2 }, /* (124) multi_create_clause ::= multi_create_clause create_subtable_clause */ - { 274, -10 }, /* (125) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP literal_list NK_RP table_options */ - { 268, -1 }, /* (126) multi_drop_clause ::= drop_table_clause */ - { 268, -2 }, /* (127) multi_drop_clause ::= multi_drop_clause drop_table_clause */ - { 277, -2 }, /* (128) drop_table_clause ::= exists_opt full_table_name */ - { 275, 0 }, /* (129) specific_tags_opt ::= */ - { 275, -3 }, /* (130) specific_tags_opt ::= NK_LP col_name_list NK_RP */ - { 262, -1 }, /* (131) full_table_name ::= table_name */ - { 262, -3 }, /* (132) full_table_name ::= db_name NK_DOT table_name */ - { 263, -1 }, /* (133) column_def_list ::= column_def */ - { 263, -3 }, /* (134) column_def_list ::= column_def_list NK_COMMA column_def */ - { 280, -2 }, /* (135) column_def ::= column_name type_name */ - { 280, -4 }, /* (136) column_def ::= column_name type_name COMMENT NK_STRING */ - { 272, -1 }, /* (137) type_name ::= BOOL */ - { 272, -1 }, /* (138) type_name ::= TINYINT */ - { 272, -1 }, /* (139) type_name ::= SMALLINT */ - { 272, -1 }, /* (140) type_name ::= INT */ - { 272, -1 }, /* (141) type_name ::= INTEGER */ - { 272, -1 }, /* (142) type_name ::= BIGINT */ - { 272, -1 }, /* (143) type_name ::= FLOAT */ - { 272, -1 }, /* (144) type_name ::= DOUBLE */ - { 272, -4 }, /* (145) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ - { 272, -1 }, /* (146) type_name ::= TIMESTAMP */ - { 272, -4 }, /* (147) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ - { 272, -2 }, /* (148) type_name ::= TINYINT UNSIGNED */ - { 272, -2 }, /* (149) type_name ::= SMALLINT UNSIGNED */ - { 272, -2 }, /* (150) type_name ::= INT UNSIGNED */ - { 272, -2 }, /* (151) type_name ::= BIGINT UNSIGNED */ - { 272, -1 }, /* (152) type_name ::= JSON */ - { 272, -4 }, /* (153) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ - { 272, -1 }, /* (154) type_name ::= MEDIUMBLOB */ - { 272, -1 }, /* (155) type_name ::= BLOB */ - { 272, -4 }, /* (156) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ - { 272, -1 }, /* (157) type_name ::= DECIMAL */ - { 272, -4 }, /* (158) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ - { 272, -6 }, /* (159) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ - { 264, 0 }, /* (160) tags_def_opt ::= */ - { 264, -1 }, /* (161) tags_def_opt ::= tags_def */ - { 267, -4 }, /* (162) tags_def ::= TAGS NK_LP column_def_list NK_RP */ - { 265, 0 }, /* (163) table_options ::= */ - { 265, -3 }, /* (164) table_options ::= table_options COMMENT NK_STRING */ - { 265, -3 }, /* (165) table_options ::= table_options DELAY NK_INTEGER */ - { 265, -3 }, /* (166) table_options ::= table_options FILE_FACTOR NK_FLOAT */ - { 265, -5 }, /* (167) table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP */ - { 265, -3 }, /* (168) table_options ::= table_options TTL NK_INTEGER */ - { 265, -5 }, /* (169) table_options ::= table_options SMA NK_LP col_name_list NK_RP */ - { 270, -1 }, /* (170) alter_table_options ::= alter_table_option */ - { 270, -2 }, /* (171) alter_table_options ::= alter_table_options alter_table_option */ - { 282, -2 }, /* (172) alter_table_option ::= COMMENT NK_STRING */ - { 282, -2 }, /* (173) alter_table_option ::= TTL NK_INTEGER */ - { 278, -1 }, /* (174) col_name_list ::= col_name */ - { 278, -3 }, /* (175) col_name_list ::= col_name_list NK_COMMA col_name */ - { 283, -1 }, /* (176) col_name ::= column_name */ - { 240, -2 }, /* (177) cmd ::= SHOW DNODES */ - { 240, -2 }, /* (178) cmd ::= SHOW USERS */ - { 240, -2 }, /* (179) cmd ::= SHOW DATABASES */ - { 240, -4 }, /* (180) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */ - { 240, -4 }, /* (181) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ - { 240, -3 }, /* (182) cmd ::= SHOW db_name_cond_opt VGROUPS */ - { 240, -2 }, /* (183) cmd ::= SHOW MNODES */ - { 240, -2 }, /* (184) cmd ::= SHOW MODULES */ - { 240, -2 }, /* (185) cmd ::= SHOW QNODES */ - { 240, -2 }, /* (186) cmd ::= SHOW FUNCTIONS */ - { 240, -5 }, /* (187) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ - { 240, -2 }, /* (188) cmd ::= SHOW STREAMS */ - { 240, -2 }, /* (189) cmd ::= SHOW ACCOUNTS */ - { 240, -2 }, /* (190) cmd ::= SHOW APPS */ - { 240, -2 }, /* (191) cmd ::= SHOW CONNECTIONS */ - { 240, -2 }, /* (192) cmd ::= SHOW LICENCE */ - { 240, -2 }, /* (193) cmd ::= SHOW GRANTS */ - { 240, -4 }, /* (194) cmd ::= SHOW CREATE DATABASE db_name */ - { 240, -4 }, /* (195) cmd ::= SHOW CREATE TABLE full_table_name */ - { 240, -4 }, /* (196) cmd ::= SHOW CREATE STABLE full_table_name */ - { 240, -2 }, /* (197) cmd ::= SHOW QUERIES */ - { 240, -2 }, /* (198) cmd ::= SHOW SCORES */ - { 240, -2 }, /* (199) cmd ::= SHOW TOPICS */ - { 240, -2 }, /* (200) cmd ::= SHOW VARIABLES */ - { 240, -2 }, /* (201) cmd ::= SHOW BNODES */ - { 240, -2 }, /* (202) cmd ::= SHOW SNODES */ - { 240, -2 }, /* (203) cmd ::= SHOW CLUSTER */ - { 240, -2 }, /* (204) cmd ::= SHOW TRANSACTIONS */ - { 284, 0 }, /* (205) db_name_cond_opt ::= */ - { 284, -2 }, /* (206) db_name_cond_opt ::= db_name NK_DOT */ - { 285, 0 }, /* (207) like_pattern_opt ::= */ - { 285, -2 }, /* (208) like_pattern_opt ::= LIKE NK_STRING */ - { 286, -1 }, /* (209) table_name_cond ::= table_name */ - { 287, 0 }, /* (210) from_db_opt ::= */ - { 287, -2 }, /* (211) from_db_opt ::= FROM db_name */ - { 281, -1 }, /* (212) func_name_list ::= func_name */ - { 281, -3 }, /* (213) func_name_list ::= func_name_list NK_COMMA func_name */ - { 288, -1 }, /* (214) func_name ::= function_name */ - { 240, -8 }, /* (215) cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options */ - { 240, -10 }, /* (216) cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP */ - { 240, -6 }, /* (217) cmd ::= DROP INDEX exists_opt index_name ON table_name */ - { 291, 0 }, /* (218) index_options ::= */ - { 291, -9 }, /* (219) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt */ - { 291, -11 }, /* (220) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt */ - { 292, -1 }, /* (221) func_list ::= func */ - { 292, -3 }, /* (222) func_list ::= func_list NK_COMMA func */ - { 295, -4 }, /* (223) func ::= function_name NK_LP expression_list NK_RP */ - { 240, -7 }, /* (224) cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS query_expression */ - { 240, -7 }, /* (225) cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS db_name */ - { 240, -4 }, /* (226) cmd ::= DROP TOPIC exists_opt topic_name */ - { 240, -7 }, /* (227) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ - { 298, 0 }, /* (228) topic_options ::= */ - { 298, -3 }, /* (229) topic_options ::= topic_options WITH TABLE */ - { 298, -3 }, /* (230) topic_options ::= topic_options WITH SCHEMA */ - { 298, -3 }, /* (231) topic_options ::= topic_options WITH TAG */ - { 240, -2 }, /* (232) cmd ::= DESC full_table_name */ - { 240, -2 }, /* (233) cmd ::= DESCRIBE full_table_name */ - { 240, -3 }, /* (234) cmd ::= RESET QUERY CACHE */ - { 240, -4 }, /* (235) cmd ::= EXPLAIN analyze_opt explain_options query_expression */ - { 301, 0 }, /* (236) analyze_opt ::= */ - { 301, -1 }, /* (237) analyze_opt ::= ANALYZE */ - { 302, 0 }, /* (238) explain_options ::= */ - { 302, -3 }, /* (239) explain_options ::= explain_options VERBOSE NK_BOOL */ - { 302, -3 }, /* (240) explain_options ::= explain_options RATIO NK_FLOAT */ - { 240, -6 }, /* (241) cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP */ - { 240, -10 }, /* (242) cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */ - { 240, -4 }, /* (243) cmd ::= DROP FUNCTION exists_opt function_name */ - { 303, 0 }, /* (244) agg_func_opt ::= */ - { 303, -1 }, /* (245) agg_func_opt ::= AGGREGATE */ - { 304, 0 }, /* (246) bufsize_opt ::= */ - { 304, -2 }, /* (247) bufsize_opt ::= BUFSIZE NK_INTEGER */ - { 240, -8 }, /* (248) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression */ - { 240, -4 }, /* (249) cmd ::= DROP STREAM exists_opt stream_name */ - { 307, 0 }, /* (250) into_opt ::= */ - { 307, -2 }, /* (251) into_opt ::= INTO full_table_name */ - { 306, 0 }, /* (252) stream_options ::= */ - { 306, -3 }, /* (253) stream_options ::= stream_options TRIGGER AT_ONCE */ - { 306, -3 }, /* (254) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ - { 306, -3 }, /* (255) stream_options ::= stream_options WATERMARK duration_literal */ - { 240, -3 }, /* (256) cmd ::= KILL CONNECTION NK_INTEGER */ - { 240, -3 }, /* (257) cmd ::= KILL QUERY NK_INTEGER */ - { 240, -3 }, /* (258) cmd ::= KILL TRANSACTION NK_INTEGER */ - { 240, -4 }, /* (259) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ - { 240, -4 }, /* (260) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ - { 240, -3 }, /* (261) cmd ::= SPLIT VGROUP NK_INTEGER */ - { 308, -2 }, /* (262) dnode_list ::= DNODE NK_INTEGER */ - { 308, -3 }, /* (263) dnode_list ::= dnode_list DNODE NK_INTEGER */ - { 240, -3 }, /* (264) cmd ::= SYNCDB db_name REPLICA */ - { 240, -1 }, /* (265) cmd ::= query_expression */ - { 243, -1 }, /* (266) literal ::= NK_INTEGER */ - { 243, -1 }, /* (267) literal ::= NK_FLOAT */ - { 243, -1 }, /* (268) literal ::= NK_STRING */ - { 243, -1 }, /* (269) literal ::= NK_BOOL */ - { 243, -2 }, /* (270) literal ::= TIMESTAMP NK_STRING */ - { 243, -1 }, /* (271) literal ::= duration_literal */ - { 243, -1 }, /* (272) literal ::= NULL */ - { 243, -1 }, /* (273) literal ::= NK_QUESTION */ - { 293, -1 }, /* (274) duration_literal ::= NK_VARIABLE */ - { 309, -1 }, /* (275) signed ::= NK_INTEGER */ - { 309, -2 }, /* (276) signed ::= NK_PLUS NK_INTEGER */ - { 309, -2 }, /* (277) signed ::= NK_MINUS NK_INTEGER */ - { 309, -1 }, /* (278) signed ::= NK_FLOAT */ - { 309, -2 }, /* (279) signed ::= NK_PLUS NK_FLOAT */ - { 309, -2 }, /* (280) signed ::= NK_MINUS NK_FLOAT */ - { 273, -1 }, /* (281) signed_literal ::= signed */ - { 273, -1 }, /* (282) signed_literal ::= NK_STRING */ - { 273, -1 }, /* (283) signed_literal ::= NK_BOOL */ - { 273, -2 }, /* (284) signed_literal ::= TIMESTAMP NK_STRING */ - { 273, -1 }, /* (285) signed_literal ::= duration_literal */ - { 273, -1 }, /* (286) signed_literal ::= NULL */ - { 273, -1 }, /* (287) signed_literal ::= literal_func */ - { 276, -1 }, /* (288) literal_list ::= signed_literal */ - { 276, -3 }, /* (289) literal_list ::= literal_list NK_COMMA signed_literal */ - { 250, -1 }, /* (290) db_name ::= NK_ID */ - { 279, -1 }, /* (291) table_name ::= NK_ID */ - { 271, -1 }, /* (292) column_name ::= NK_ID */ - { 289, -1 }, /* (293) function_name ::= NK_ID */ - { 311, -1 }, /* (294) table_alias ::= NK_ID */ - { 312, -1 }, /* (295) column_alias ::= NK_ID */ - { 245, -1 }, /* (296) user_name ::= NK_ID */ - { 290, -1 }, /* (297) index_name ::= NK_ID */ - { 297, -1 }, /* (298) topic_name ::= NK_ID */ - { 305, -1 }, /* (299) stream_name ::= NK_ID */ - { 300, -1 }, /* (300) cgroup_name ::= NK_ID */ - { 313, -1 }, /* (301) expression ::= literal */ - { 313, -1 }, /* (302) expression ::= pseudo_column */ - { 313, -1 }, /* (303) expression ::= column_reference */ - { 313, -1 }, /* (304) expression ::= function_expression */ - { 313, -1 }, /* (305) expression ::= subquery */ - { 313, -3 }, /* (306) expression ::= NK_LP expression NK_RP */ - { 313, -2 }, /* (307) expression ::= NK_PLUS expression */ - { 313, -2 }, /* (308) expression ::= NK_MINUS expression */ - { 313, -3 }, /* (309) expression ::= expression NK_PLUS expression */ - { 313, -3 }, /* (310) expression ::= expression NK_MINUS expression */ - { 313, -3 }, /* (311) expression ::= expression NK_STAR expression */ - { 313, -3 }, /* (312) expression ::= expression NK_SLASH expression */ - { 313, -3 }, /* (313) expression ::= expression NK_REM expression */ - { 313, -3 }, /* (314) expression ::= column_reference NK_ARROW NK_STRING */ - { 296, -1 }, /* (315) expression_list ::= expression */ - { 296, -3 }, /* (316) expression_list ::= expression_list NK_COMMA expression */ - { 315, -1 }, /* (317) column_reference ::= column_name */ - { 315, -3 }, /* (318) column_reference ::= table_name NK_DOT column_name */ - { 314, -1 }, /* (319) pseudo_column ::= ROWTS */ - { 314, -1 }, /* (320) pseudo_column ::= TBNAME */ - { 314, -3 }, /* (321) pseudo_column ::= table_name NK_DOT TBNAME */ - { 314, -1 }, /* (322) pseudo_column ::= QSTARTTS */ - { 314, -1 }, /* (323) pseudo_column ::= QENDTS */ - { 314, -1 }, /* (324) pseudo_column ::= WSTARTTS */ - { 314, -1 }, /* (325) pseudo_column ::= WENDTS */ - { 314, -1 }, /* (326) pseudo_column ::= WDURATION */ - { 316, -4 }, /* (327) function_expression ::= function_name NK_LP expression_list NK_RP */ - { 316, -4 }, /* (328) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ - { 316, -6 }, /* (329) function_expression ::= CAST NK_LP expression AS type_name NK_RP */ - { 316, -1 }, /* (330) function_expression ::= literal_func */ - { 310, -3 }, /* (331) literal_func ::= noarg_func NK_LP NK_RP */ - { 310, -1 }, /* (332) literal_func ::= NOW */ - { 320, -1 }, /* (333) noarg_func ::= NOW */ - { 320, -1 }, /* (334) noarg_func ::= TODAY */ - { 320, -1 }, /* (335) noarg_func ::= TIMEZONE */ - { 318, -1 }, /* (336) star_func ::= COUNT */ - { 318, -1 }, /* (337) star_func ::= FIRST */ - { 318, -1 }, /* (338) star_func ::= LAST */ - { 318, -1 }, /* (339) star_func ::= LAST_ROW */ - { 319, -1 }, /* (340) star_func_para_list ::= NK_STAR */ - { 319, -1 }, /* (341) star_func_para_list ::= other_para_list */ - { 321, -1 }, /* (342) other_para_list ::= star_func_para */ - { 321, -3 }, /* (343) other_para_list ::= other_para_list NK_COMMA star_func_para */ - { 322, -1 }, /* (344) star_func_para ::= expression */ - { 322, -3 }, /* (345) star_func_para ::= table_name NK_DOT NK_STAR */ - { 323, -3 }, /* (346) predicate ::= expression compare_op expression */ - { 323, -5 }, /* (347) predicate ::= expression BETWEEN expression AND expression */ - { 323, -6 }, /* (348) predicate ::= expression NOT BETWEEN expression AND expression */ - { 323, -3 }, /* (349) predicate ::= expression IS NULL */ - { 323, -4 }, /* (350) predicate ::= expression IS NOT NULL */ - { 323, -3 }, /* (351) predicate ::= expression in_op in_predicate_value */ - { 324, -1 }, /* (352) compare_op ::= NK_LT */ - { 324, -1 }, /* (353) compare_op ::= NK_GT */ - { 324, -1 }, /* (354) compare_op ::= NK_LE */ - { 324, -1 }, /* (355) compare_op ::= NK_GE */ - { 324, -1 }, /* (356) compare_op ::= NK_NE */ - { 324, -1 }, /* (357) compare_op ::= NK_EQ */ - { 324, -1 }, /* (358) compare_op ::= LIKE */ - { 324, -2 }, /* (359) compare_op ::= NOT LIKE */ - { 324, -1 }, /* (360) compare_op ::= MATCH */ - { 324, -1 }, /* (361) compare_op ::= NMATCH */ - { 324, -1 }, /* (362) compare_op ::= CONTAINS */ - { 325, -1 }, /* (363) in_op ::= IN */ - { 325, -2 }, /* (364) in_op ::= NOT IN */ - { 326, -3 }, /* (365) in_predicate_value ::= NK_LP expression_list NK_RP */ - { 327, -1 }, /* (366) boolean_value_expression ::= boolean_primary */ - { 327, -2 }, /* (367) boolean_value_expression ::= NOT boolean_primary */ - { 327, -3 }, /* (368) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ - { 327, -3 }, /* (369) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ - { 328, -1 }, /* (370) boolean_primary ::= predicate */ - { 328, -3 }, /* (371) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ - { 329, -1 }, /* (372) common_expression ::= expression */ - { 329, -1 }, /* (373) common_expression ::= boolean_value_expression */ - { 330, -2 }, /* (374) from_clause ::= FROM table_reference_list */ - { 331, -1 }, /* (375) table_reference_list ::= table_reference */ - { 331, -3 }, /* (376) table_reference_list ::= table_reference_list NK_COMMA table_reference */ - { 332, -1 }, /* (377) table_reference ::= table_primary */ - { 332, -1 }, /* (378) table_reference ::= joined_table */ - { 333, -2 }, /* (379) table_primary ::= table_name alias_opt */ - { 333, -4 }, /* (380) table_primary ::= db_name NK_DOT table_name alias_opt */ - { 333, -2 }, /* (381) table_primary ::= subquery alias_opt */ - { 333, -1 }, /* (382) table_primary ::= parenthesized_joined_table */ - { 335, 0 }, /* (383) alias_opt ::= */ - { 335, -1 }, /* (384) alias_opt ::= table_alias */ - { 335, -2 }, /* (385) alias_opt ::= AS table_alias */ - { 336, -3 }, /* (386) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - { 336, -3 }, /* (387) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ - { 334, -6 }, /* (388) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ - { 337, 0 }, /* (389) join_type ::= */ - { 337, -1 }, /* (390) join_type ::= INNER */ - { 339, -9 }, /* (391) query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ - { 340, 0 }, /* (392) set_quantifier_opt ::= */ - { 340, -1 }, /* (393) set_quantifier_opt ::= DISTINCT */ - { 340, -1 }, /* (394) set_quantifier_opt ::= ALL */ - { 341, -1 }, /* (395) select_list ::= NK_STAR */ - { 341, -1 }, /* (396) select_list ::= select_sublist */ - { 347, -1 }, /* (397) select_sublist ::= select_item */ - { 347, -3 }, /* (398) select_sublist ::= select_sublist NK_COMMA select_item */ - { 348, -1 }, /* (399) select_item ::= common_expression */ - { 348, -2 }, /* (400) select_item ::= common_expression column_alias */ - { 348, -3 }, /* (401) select_item ::= common_expression AS column_alias */ - { 348, -3 }, /* (402) select_item ::= table_name NK_DOT NK_STAR */ - { 342, 0 }, /* (403) where_clause_opt ::= */ - { 342, -2 }, /* (404) where_clause_opt ::= WHERE search_condition */ - { 343, 0 }, /* (405) partition_by_clause_opt ::= */ - { 343, -3 }, /* (406) partition_by_clause_opt ::= PARTITION BY expression_list */ - { 344, 0 }, /* (407) twindow_clause_opt ::= */ - { 344, -6 }, /* (408) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ - { 344, -4 }, /* (409) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */ - { 344, -6 }, /* (410) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ - { 344, -8 }, /* (411) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ - { 294, 0 }, /* (412) sliding_opt ::= */ - { 294, -4 }, /* (413) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ - { 349, 0 }, /* (414) fill_opt ::= */ - { 349, -4 }, /* (415) fill_opt ::= FILL NK_LP fill_mode NK_RP */ - { 349, -6 }, /* (416) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ - { 350, -1 }, /* (417) fill_mode ::= NONE */ - { 350, -1 }, /* (418) fill_mode ::= PREV */ - { 350, -1 }, /* (419) fill_mode ::= NULL */ - { 350, -1 }, /* (420) fill_mode ::= LINEAR */ - { 350, -1 }, /* (421) fill_mode ::= NEXT */ - { 345, 0 }, /* (422) group_by_clause_opt ::= */ - { 345, -3 }, /* (423) group_by_clause_opt ::= GROUP BY group_by_list */ - { 351, -1 }, /* (424) group_by_list ::= expression */ - { 351, -3 }, /* (425) group_by_list ::= group_by_list NK_COMMA expression */ - { 346, 0 }, /* (426) having_clause_opt ::= */ - { 346, -2 }, /* (427) having_clause_opt ::= HAVING search_condition */ - { 299, -4 }, /* (428) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ - { 352, -1 }, /* (429) query_expression_body ::= query_primary */ - { 352, -4 }, /* (430) query_expression_body ::= query_expression_body UNION ALL query_expression_body */ - { 352, -3 }, /* (431) query_expression_body ::= query_expression_body UNION query_expression_body */ - { 356, -1 }, /* (432) query_primary ::= query_specification */ - { 356, -6 }, /* (433) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */ - { 353, 0 }, /* (434) order_by_clause_opt ::= */ - { 353, -3 }, /* (435) order_by_clause_opt ::= ORDER BY sort_specification_list */ - { 354, 0 }, /* (436) slimit_clause_opt ::= */ - { 354, -2 }, /* (437) slimit_clause_opt ::= SLIMIT NK_INTEGER */ - { 354, -4 }, /* (438) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - { 354, -4 }, /* (439) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - { 355, 0 }, /* (440) limit_clause_opt ::= */ - { 355, -2 }, /* (441) limit_clause_opt ::= LIMIT NK_INTEGER */ - { 355, -4 }, /* (442) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ - { 355, -4 }, /* (443) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - { 317, -3 }, /* (444) subquery ::= NK_LP query_expression NK_RP */ - { 338, -1 }, /* (445) search_condition ::= common_expression */ - { 357, -1 }, /* (446) sort_specification_list ::= sort_specification */ - { 357, -3 }, /* (447) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ - { 358, -3 }, /* (448) sort_specification ::= expression ordering_specification_opt null_ordering_opt */ - { 359, 0 }, /* (449) ordering_specification_opt ::= */ - { 359, -1 }, /* (450) ordering_specification_opt ::= ASC */ - { 359, -1 }, /* (451) ordering_specification_opt ::= DESC */ - { 360, 0 }, /* (452) null_ordering_opt ::= */ - { 360, -2 }, /* (453) null_ordering_opt ::= NULLS FIRST */ - { 360, -2 }, /* (454) null_ordering_opt ::= NULLS LAST */ + { 239, -6 }, /* (0) cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */ + { 239, -4 }, /* (1) cmd ::= ALTER ACCOUNT NK_ID alter_account_options */ + { 240, 0 }, /* (2) account_options ::= */ + { 240, -3 }, /* (3) account_options ::= account_options PPS literal */ + { 240, -3 }, /* (4) account_options ::= account_options TSERIES literal */ + { 240, -3 }, /* (5) account_options ::= account_options STORAGE literal */ + { 240, -3 }, /* (6) account_options ::= account_options STREAMS literal */ + { 240, -3 }, /* (7) account_options ::= account_options QTIME literal */ + { 240, -3 }, /* (8) account_options ::= account_options DBS literal */ + { 240, -3 }, /* (9) account_options ::= account_options USERS literal */ + { 240, -3 }, /* (10) account_options ::= account_options CONNS literal */ + { 240, -3 }, /* (11) account_options ::= account_options STATE literal */ + { 241, -1 }, /* (12) alter_account_options ::= alter_account_option */ + { 241, -2 }, /* (13) alter_account_options ::= alter_account_options alter_account_option */ + { 243, -2 }, /* (14) alter_account_option ::= PASS literal */ + { 243, -2 }, /* (15) alter_account_option ::= PPS literal */ + { 243, -2 }, /* (16) alter_account_option ::= TSERIES literal */ + { 243, -2 }, /* (17) alter_account_option ::= STORAGE literal */ + { 243, -2 }, /* (18) alter_account_option ::= STREAMS literal */ + { 243, -2 }, /* (19) alter_account_option ::= QTIME literal */ + { 243, -2 }, /* (20) alter_account_option ::= DBS literal */ + { 243, -2 }, /* (21) alter_account_option ::= USERS literal */ + { 243, -2 }, /* (22) alter_account_option ::= CONNS literal */ + { 243, -2 }, /* (23) alter_account_option ::= STATE literal */ + { 239, -5 }, /* (24) cmd ::= CREATE USER user_name PASS NK_STRING */ + { 239, -5 }, /* (25) cmd ::= ALTER USER user_name PASS NK_STRING */ + { 239, -5 }, /* (26) cmd ::= ALTER USER user_name PRIVILEGE NK_STRING */ + { 239, -3 }, /* (27) cmd ::= DROP USER user_name */ + { 239, -6 }, /* (28) cmd ::= GRANT privileges ON priv_level TO user_name */ + { 239, -6 }, /* (29) cmd ::= REVOKE privileges ON priv_level FROM user_name */ + { 245, -1 }, /* (30) privileges ::= ALL */ + { 245, -1 }, /* (31) privileges ::= priv_type_list */ + { 247, -1 }, /* (32) priv_type_list ::= priv_type */ + { 247, -3 }, /* (33) priv_type_list ::= priv_type_list NK_COMMA priv_type */ + { 248, -1 }, /* (34) priv_type ::= READ */ + { 248, -1 }, /* (35) priv_type ::= WRITE */ + { 246, -3 }, /* (36) priv_level ::= NK_STAR NK_DOT NK_STAR */ + { 246, -3 }, /* (37) priv_level ::= db_name NK_DOT NK_STAR */ + { 239, -3 }, /* (38) cmd ::= CREATE DNODE dnode_endpoint */ + { 239, -5 }, /* (39) cmd ::= CREATE DNODE dnode_host_name PORT NK_INTEGER */ + { 239, -3 }, /* (40) cmd ::= DROP DNODE NK_INTEGER */ + { 239, -3 }, /* (41) cmd ::= DROP DNODE dnode_endpoint */ + { 239, -4 }, /* (42) cmd ::= ALTER DNODE NK_INTEGER NK_STRING */ + { 239, -5 }, /* (43) cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */ + { 239, -4 }, /* (44) cmd ::= ALTER ALL DNODES NK_STRING */ + { 239, -5 }, /* (45) cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */ + { 250, -1 }, /* (46) dnode_endpoint ::= NK_STRING */ + { 251, -1 }, /* (47) dnode_host_name ::= NK_ID */ + { 251, -1 }, /* (48) dnode_host_name ::= NK_IPTOKEN */ + { 239, -3 }, /* (49) cmd ::= ALTER LOCAL NK_STRING */ + { 239, -4 }, /* (50) cmd ::= ALTER LOCAL NK_STRING NK_STRING */ + { 239, -5 }, /* (51) cmd ::= CREATE QNODE ON DNODE NK_INTEGER */ + { 239, -5 }, /* (52) cmd ::= DROP QNODE ON DNODE NK_INTEGER */ + { 239, -5 }, /* (53) cmd ::= CREATE BNODE ON DNODE NK_INTEGER */ + { 239, -5 }, /* (54) cmd ::= DROP BNODE ON DNODE NK_INTEGER */ + { 239, -5 }, /* (55) cmd ::= CREATE SNODE ON DNODE NK_INTEGER */ + { 239, -5 }, /* (56) cmd ::= DROP SNODE ON DNODE NK_INTEGER */ + { 239, -5 }, /* (57) cmd ::= CREATE MNODE ON DNODE NK_INTEGER */ + { 239, -5 }, /* (58) cmd ::= DROP MNODE ON DNODE NK_INTEGER */ + { 239, -5 }, /* (59) cmd ::= CREATE DATABASE not_exists_opt db_name db_options */ + { 239, -4 }, /* (60) cmd ::= DROP DATABASE exists_opt db_name */ + { 239, -2 }, /* (61) cmd ::= USE db_name */ + { 239, -4 }, /* (62) cmd ::= ALTER DATABASE db_name alter_db_options */ + { 252, -3 }, /* (63) not_exists_opt ::= IF NOT EXISTS */ + { 252, 0 }, /* (64) not_exists_opt ::= */ + { 254, -2 }, /* (65) exists_opt ::= IF EXISTS */ + { 254, 0 }, /* (66) exists_opt ::= */ + { 253, 0 }, /* (67) db_options ::= */ + { 253, -3 }, /* (68) db_options ::= db_options BUFFER NK_INTEGER */ + { 253, -3 }, /* (69) db_options ::= db_options CACHELAST NK_INTEGER */ + { 253, -3 }, /* (70) db_options ::= db_options COMP NK_INTEGER */ + { 253, -3 }, /* (71) db_options ::= db_options DAYS NK_INTEGER */ + { 253, -3 }, /* (72) db_options ::= db_options DAYS NK_VARIABLE */ + { 253, -3 }, /* (73) db_options ::= db_options FSYNC NK_INTEGER */ + { 253, -3 }, /* (74) db_options ::= db_options MAXROWS NK_INTEGER */ + { 253, -3 }, /* (75) db_options ::= db_options MINROWS NK_INTEGER */ + { 253, -3 }, /* (76) db_options ::= db_options KEEP integer_list */ + { 253, -3 }, /* (77) db_options ::= db_options KEEP variable_list */ + { 253, -3 }, /* (78) db_options ::= db_options PAGES NK_INTEGER */ + { 253, -3 }, /* (79) db_options ::= db_options PAGESIZE NK_INTEGER */ + { 253, -3 }, /* (80) db_options ::= db_options PRECISION NK_STRING */ + { 253, -3 }, /* (81) db_options ::= db_options REPLICA NK_INTEGER */ + { 253, -3 }, /* (82) db_options ::= db_options STRICT NK_INTEGER */ + { 253, -3 }, /* (83) db_options ::= db_options WAL NK_INTEGER */ + { 253, -3 }, /* (84) db_options ::= db_options VGROUPS NK_INTEGER */ + { 253, -3 }, /* (85) db_options ::= db_options SINGLE_STABLE NK_INTEGER */ + { 253, -3 }, /* (86) db_options ::= db_options RETENTIONS retention_list */ + { 253, -3 }, /* (87) db_options ::= db_options SCHEMALESS NK_INTEGER */ + { 255, -1 }, /* (88) alter_db_options ::= alter_db_option */ + { 255, -2 }, /* (89) alter_db_options ::= alter_db_options alter_db_option */ + { 259, -2 }, /* (90) alter_db_option ::= BUFFER NK_INTEGER */ + { 259, -2 }, /* (91) alter_db_option ::= CACHELAST NK_INTEGER */ + { 259, -2 }, /* (92) alter_db_option ::= FSYNC NK_INTEGER */ + { 259, -2 }, /* (93) alter_db_option ::= KEEP integer_list */ + { 259, -2 }, /* (94) alter_db_option ::= KEEP variable_list */ + { 259, -2 }, /* (95) alter_db_option ::= PAGES NK_INTEGER */ + { 259, -2 }, /* (96) alter_db_option ::= REPLICA NK_INTEGER */ + { 259, -2 }, /* (97) alter_db_option ::= STRICT NK_INTEGER */ + { 259, -2 }, /* (98) alter_db_option ::= WAL NK_INTEGER */ + { 256, -1 }, /* (99) integer_list ::= NK_INTEGER */ + { 256, -3 }, /* (100) integer_list ::= integer_list NK_COMMA NK_INTEGER */ + { 257, -1 }, /* (101) variable_list ::= NK_VARIABLE */ + { 257, -3 }, /* (102) variable_list ::= variable_list NK_COMMA NK_VARIABLE */ + { 258, -1 }, /* (103) retention_list ::= retention */ + { 258, -3 }, /* (104) retention_list ::= retention_list NK_COMMA retention */ + { 260, -3 }, /* (105) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ + { 239, -9 }, /* (106) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ + { 239, -3 }, /* (107) cmd ::= CREATE TABLE multi_create_clause */ + { 239, -9 }, /* (108) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ + { 239, -3 }, /* (109) cmd ::= DROP TABLE multi_drop_clause */ + { 239, -4 }, /* (110) cmd ::= DROP STABLE exists_opt full_table_name */ + { 239, -3 }, /* (111) cmd ::= ALTER TABLE alter_table_clause */ + { 239, -3 }, /* (112) cmd ::= ALTER STABLE alter_table_clause */ + { 268, -2 }, /* (113) alter_table_clause ::= full_table_name alter_table_options */ + { 268, -5 }, /* (114) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ + { 268, -4 }, /* (115) alter_table_clause ::= full_table_name DROP COLUMN column_name */ + { 268, -5 }, /* (116) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ + { 268, -5 }, /* (117) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ + { 268, -5 }, /* (118) alter_table_clause ::= full_table_name ADD TAG column_name type_name */ + { 268, -4 }, /* (119) alter_table_clause ::= full_table_name DROP TAG column_name */ + { 268, -5 }, /* (120) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ + { 268, -5 }, /* (121) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ + { 268, -6 }, /* (122) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ + { 265, -1 }, /* (123) multi_create_clause ::= create_subtable_clause */ + { 265, -2 }, /* (124) multi_create_clause ::= multi_create_clause create_subtable_clause */ + { 273, -10 }, /* (125) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP literal_list NK_RP table_options */ + { 267, -1 }, /* (126) multi_drop_clause ::= drop_table_clause */ + { 267, -2 }, /* (127) multi_drop_clause ::= multi_drop_clause drop_table_clause */ + { 276, -2 }, /* (128) drop_table_clause ::= exists_opt full_table_name */ + { 274, 0 }, /* (129) specific_tags_opt ::= */ + { 274, -3 }, /* (130) specific_tags_opt ::= NK_LP col_name_list NK_RP */ + { 261, -1 }, /* (131) full_table_name ::= table_name */ + { 261, -3 }, /* (132) full_table_name ::= db_name NK_DOT table_name */ + { 262, -1 }, /* (133) column_def_list ::= column_def */ + { 262, -3 }, /* (134) column_def_list ::= column_def_list NK_COMMA column_def */ + { 279, -2 }, /* (135) column_def ::= column_name type_name */ + { 279, -4 }, /* (136) column_def ::= column_name type_name COMMENT NK_STRING */ + { 271, -1 }, /* (137) type_name ::= BOOL */ + { 271, -1 }, /* (138) type_name ::= TINYINT */ + { 271, -1 }, /* (139) type_name ::= SMALLINT */ + { 271, -1 }, /* (140) type_name ::= INT */ + { 271, -1 }, /* (141) type_name ::= INTEGER */ + { 271, -1 }, /* (142) type_name ::= BIGINT */ + { 271, -1 }, /* (143) type_name ::= FLOAT */ + { 271, -1 }, /* (144) type_name ::= DOUBLE */ + { 271, -4 }, /* (145) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ + { 271, -1 }, /* (146) type_name ::= TIMESTAMP */ + { 271, -4 }, /* (147) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ + { 271, -2 }, /* (148) type_name ::= TINYINT UNSIGNED */ + { 271, -2 }, /* (149) type_name ::= SMALLINT UNSIGNED */ + { 271, -2 }, /* (150) type_name ::= INT UNSIGNED */ + { 271, -2 }, /* (151) type_name ::= BIGINT UNSIGNED */ + { 271, -1 }, /* (152) type_name ::= JSON */ + { 271, -4 }, /* (153) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ + { 271, -1 }, /* (154) type_name ::= MEDIUMBLOB */ + { 271, -1 }, /* (155) type_name ::= BLOB */ + { 271, -4 }, /* (156) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ + { 271, -1 }, /* (157) type_name ::= DECIMAL */ + { 271, -4 }, /* (158) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ + { 271, -6 }, /* (159) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ + { 263, 0 }, /* (160) tags_def_opt ::= */ + { 263, -1 }, /* (161) tags_def_opt ::= tags_def */ + { 266, -4 }, /* (162) tags_def ::= TAGS NK_LP column_def_list NK_RP */ + { 264, 0 }, /* (163) table_options ::= */ + { 264, -3 }, /* (164) table_options ::= table_options COMMENT NK_STRING */ + { 264, -3 }, /* (165) table_options ::= table_options FILE_FACTOR NK_FLOAT */ + { 264, -5 }, /* (166) table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP */ + { 264, -3 }, /* (167) table_options ::= table_options TTL NK_INTEGER */ + { 264, -5 }, /* (168) table_options ::= table_options SMA NK_LP col_name_list NK_RP */ + { 269, -1 }, /* (169) alter_table_options ::= alter_table_option */ + { 269, -2 }, /* (170) alter_table_options ::= alter_table_options alter_table_option */ + { 281, -2 }, /* (171) alter_table_option ::= COMMENT NK_STRING */ + { 281, -2 }, /* (172) alter_table_option ::= TTL NK_INTEGER */ + { 277, -1 }, /* (173) col_name_list ::= col_name */ + { 277, -3 }, /* (174) col_name_list ::= col_name_list NK_COMMA col_name */ + { 282, -1 }, /* (175) col_name ::= column_name */ + { 239, -2 }, /* (176) cmd ::= SHOW DNODES */ + { 239, -2 }, /* (177) cmd ::= SHOW USERS */ + { 239, -2 }, /* (178) cmd ::= SHOW DATABASES */ + { 239, -4 }, /* (179) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */ + { 239, -4 }, /* (180) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ + { 239, -3 }, /* (181) cmd ::= SHOW db_name_cond_opt VGROUPS */ + { 239, -2 }, /* (182) cmd ::= SHOW MNODES */ + { 239, -2 }, /* (183) cmd ::= SHOW MODULES */ + { 239, -2 }, /* (184) cmd ::= SHOW QNODES */ + { 239, -2 }, /* (185) cmd ::= SHOW FUNCTIONS */ + { 239, -5 }, /* (186) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ + { 239, -2 }, /* (187) cmd ::= SHOW STREAMS */ + { 239, -2 }, /* (188) cmd ::= SHOW ACCOUNTS */ + { 239, -2 }, /* (189) cmd ::= SHOW APPS */ + { 239, -2 }, /* (190) cmd ::= SHOW CONNECTIONS */ + { 239, -2 }, /* (191) cmd ::= SHOW LICENCE */ + { 239, -2 }, /* (192) cmd ::= SHOW GRANTS */ + { 239, -4 }, /* (193) cmd ::= SHOW CREATE DATABASE db_name */ + { 239, -4 }, /* (194) cmd ::= SHOW CREATE TABLE full_table_name */ + { 239, -4 }, /* (195) cmd ::= SHOW CREATE STABLE full_table_name */ + { 239, -2 }, /* (196) cmd ::= SHOW QUERIES */ + { 239, -2 }, /* (197) cmd ::= SHOW SCORES */ + { 239, -2 }, /* (198) cmd ::= SHOW TOPICS */ + { 239, -2 }, /* (199) cmd ::= SHOW VARIABLES */ + { 239, -2 }, /* (200) cmd ::= SHOW BNODES */ + { 239, -2 }, /* (201) cmd ::= SHOW SNODES */ + { 239, -2 }, /* (202) cmd ::= SHOW CLUSTER */ + { 239, -2 }, /* (203) cmd ::= SHOW TRANSACTIONS */ + { 283, 0 }, /* (204) db_name_cond_opt ::= */ + { 283, -2 }, /* (205) db_name_cond_opt ::= db_name NK_DOT */ + { 284, 0 }, /* (206) like_pattern_opt ::= */ + { 284, -2 }, /* (207) like_pattern_opt ::= LIKE NK_STRING */ + { 285, -1 }, /* (208) table_name_cond ::= table_name */ + { 286, 0 }, /* (209) from_db_opt ::= */ + { 286, -2 }, /* (210) from_db_opt ::= FROM db_name */ + { 280, -1 }, /* (211) func_name_list ::= func_name */ + { 280, -3 }, /* (212) func_name_list ::= func_name_list NK_COMMA func_name */ + { 287, -1 }, /* (213) func_name ::= function_name */ + { 239, -8 }, /* (214) cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options */ + { 239, -10 }, /* (215) cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP */ + { 239, -6 }, /* (216) cmd ::= DROP INDEX exists_opt index_name ON table_name */ + { 290, 0 }, /* (217) index_options ::= */ + { 290, -9 }, /* (218) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt */ + { 290, -11 }, /* (219) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt */ + { 291, -1 }, /* (220) func_list ::= func */ + { 291, -3 }, /* (221) func_list ::= func_list NK_COMMA func */ + { 294, -4 }, /* (222) func ::= function_name NK_LP expression_list NK_RP */ + { 239, -7 }, /* (223) cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS query_expression */ + { 239, -7 }, /* (224) cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS db_name */ + { 239, -4 }, /* (225) cmd ::= DROP TOPIC exists_opt topic_name */ + { 239, -7 }, /* (226) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ + { 297, 0 }, /* (227) topic_options ::= */ + { 297, -3 }, /* (228) topic_options ::= topic_options WITH TABLE */ + { 297, -3 }, /* (229) topic_options ::= topic_options WITH SCHEMA */ + { 297, -3 }, /* (230) topic_options ::= topic_options WITH TAG */ + { 239, -2 }, /* (231) cmd ::= DESC full_table_name */ + { 239, -2 }, /* (232) cmd ::= DESCRIBE full_table_name */ + { 239, -3 }, /* (233) cmd ::= RESET QUERY CACHE */ + { 239, -4 }, /* (234) cmd ::= EXPLAIN analyze_opt explain_options query_expression */ + { 300, 0 }, /* (235) analyze_opt ::= */ + { 300, -1 }, /* (236) analyze_opt ::= ANALYZE */ + { 301, 0 }, /* (237) explain_options ::= */ + { 301, -3 }, /* (238) explain_options ::= explain_options VERBOSE NK_BOOL */ + { 301, -3 }, /* (239) explain_options ::= explain_options RATIO NK_FLOAT */ + { 239, -6 }, /* (240) cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP */ + { 239, -10 }, /* (241) cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */ + { 239, -4 }, /* (242) cmd ::= DROP FUNCTION exists_opt function_name */ + { 302, 0 }, /* (243) agg_func_opt ::= */ + { 302, -1 }, /* (244) agg_func_opt ::= AGGREGATE */ + { 303, 0 }, /* (245) bufsize_opt ::= */ + { 303, -2 }, /* (246) bufsize_opt ::= BUFSIZE NK_INTEGER */ + { 239, -8 }, /* (247) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression */ + { 239, -4 }, /* (248) cmd ::= DROP STREAM exists_opt stream_name */ + { 306, 0 }, /* (249) into_opt ::= */ + { 306, -2 }, /* (250) into_opt ::= INTO full_table_name */ + { 305, 0 }, /* (251) stream_options ::= */ + { 305, -3 }, /* (252) stream_options ::= stream_options TRIGGER AT_ONCE */ + { 305, -3 }, /* (253) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ + { 305, -3 }, /* (254) stream_options ::= stream_options WATERMARK duration_literal */ + { 239, -3 }, /* (255) cmd ::= KILL CONNECTION NK_INTEGER */ + { 239, -3 }, /* (256) cmd ::= KILL QUERY NK_INTEGER */ + { 239, -3 }, /* (257) cmd ::= KILL TRANSACTION NK_INTEGER */ + { 239, -4 }, /* (258) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ + { 239, -4 }, /* (259) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ + { 239, -3 }, /* (260) cmd ::= SPLIT VGROUP NK_INTEGER */ + { 307, -2 }, /* (261) dnode_list ::= DNODE NK_INTEGER */ + { 307, -3 }, /* (262) dnode_list ::= dnode_list DNODE NK_INTEGER */ + { 239, -3 }, /* (263) cmd ::= SYNCDB db_name REPLICA */ + { 239, -1 }, /* (264) cmd ::= query_expression */ + { 242, -1 }, /* (265) literal ::= NK_INTEGER */ + { 242, -1 }, /* (266) literal ::= NK_FLOAT */ + { 242, -1 }, /* (267) literal ::= NK_STRING */ + { 242, -1 }, /* (268) literal ::= NK_BOOL */ + { 242, -2 }, /* (269) literal ::= TIMESTAMP NK_STRING */ + { 242, -1 }, /* (270) literal ::= duration_literal */ + { 242, -1 }, /* (271) literal ::= NULL */ + { 242, -1 }, /* (272) literal ::= NK_QUESTION */ + { 292, -1 }, /* (273) duration_literal ::= NK_VARIABLE */ + { 308, -1 }, /* (274) signed ::= NK_INTEGER */ + { 308, -2 }, /* (275) signed ::= NK_PLUS NK_INTEGER */ + { 308, -2 }, /* (276) signed ::= NK_MINUS NK_INTEGER */ + { 308, -1 }, /* (277) signed ::= NK_FLOAT */ + { 308, -2 }, /* (278) signed ::= NK_PLUS NK_FLOAT */ + { 308, -2 }, /* (279) signed ::= NK_MINUS NK_FLOAT */ + { 272, -1 }, /* (280) signed_literal ::= signed */ + { 272, -1 }, /* (281) signed_literal ::= NK_STRING */ + { 272, -1 }, /* (282) signed_literal ::= NK_BOOL */ + { 272, -2 }, /* (283) signed_literal ::= TIMESTAMP NK_STRING */ + { 272, -1 }, /* (284) signed_literal ::= duration_literal */ + { 272, -1 }, /* (285) signed_literal ::= NULL */ + { 272, -1 }, /* (286) signed_literal ::= literal_func */ + { 275, -1 }, /* (287) literal_list ::= signed_literal */ + { 275, -3 }, /* (288) literal_list ::= literal_list NK_COMMA signed_literal */ + { 249, -1 }, /* (289) db_name ::= NK_ID */ + { 278, -1 }, /* (290) table_name ::= NK_ID */ + { 270, -1 }, /* (291) column_name ::= NK_ID */ + { 288, -1 }, /* (292) function_name ::= NK_ID */ + { 310, -1 }, /* (293) table_alias ::= NK_ID */ + { 311, -1 }, /* (294) column_alias ::= NK_ID */ + { 244, -1 }, /* (295) user_name ::= NK_ID */ + { 289, -1 }, /* (296) index_name ::= NK_ID */ + { 296, -1 }, /* (297) topic_name ::= NK_ID */ + { 304, -1 }, /* (298) stream_name ::= NK_ID */ + { 299, -1 }, /* (299) cgroup_name ::= NK_ID */ + { 312, -1 }, /* (300) expression ::= literal */ + { 312, -1 }, /* (301) expression ::= pseudo_column */ + { 312, -1 }, /* (302) expression ::= column_reference */ + { 312, -1 }, /* (303) expression ::= function_expression */ + { 312, -1 }, /* (304) expression ::= subquery */ + { 312, -3 }, /* (305) expression ::= NK_LP expression NK_RP */ + { 312, -2 }, /* (306) expression ::= NK_PLUS expression */ + { 312, -2 }, /* (307) expression ::= NK_MINUS expression */ + { 312, -3 }, /* (308) expression ::= expression NK_PLUS expression */ + { 312, -3 }, /* (309) expression ::= expression NK_MINUS expression */ + { 312, -3 }, /* (310) expression ::= expression NK_STAR expression */ + { 312, -3 }, /* (311) expression ::= expression NK_SLASH expression */ + { 312, -3 }, /* (312) expression ::= expression NK_REM expression */ + { 312, -3 }, /* (313) expression ::= column_reference NK_ARROW NK_STRING */ + { 295, -1 }, /* (314) expression_list ::= expression */ + { 295, -3 }, /* (315) expression_list ::= expression_list NK_COMMA expression */ + { 314, -1 }, /* (316) column_reference ::= column_name */ + { 314, -3 }, /* (317) column_reference ::= table_name NK_DOT column_name */ + { 313, -1 }, /* (318) pseudo_column ::= ROWTS */ + { 313, -1 }, /* (319) pseudo_column ::= TBNAME */ + { 313, -3 }, /* (320) pseudo_column ::= table_name NK_DOT TBNAME */ + { 313, -1 }, /* (321) pseudo_column ::= QSTARTTS */ + { 313, -1 }, /* (322) pseudo_column ::= QENDTS */ + { 313, -1 }, /* (323) pseudo_column ::= WSTARTTS */ + { 313, -1 }, /* (324) pseudo_column ::= WENDTS */ + { 313, -1 }, /* (325) pseudo_column ::= WDURATION */ + { 315, -4 }, /* (326) function_expression ::= function_name NK_LP expression_list NK_RP */ + { 315, -4 }, /* (327) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ + { 315, -6 }, /* (328) function_expression ::= CAST NK_LP expression AS type_name NK_RP */ + { 315, -1 }, /* (329) function_expression ::= literal_func */ + { 309, -3 }, /* (330) literal_func ::= noarg_func NK_LP NK_RP */ + { 309, -1 }, /* (331) literal_func ::= NOW */ + { 319, -1 }, /* (332) noarg_func ::= NOW */ + { 319, -1 }, /* (333) noarg_func ::= TODAY */ + { 319, -1 }, /* (334) noarg_func ::= TIMEZONE */ + { 317, -1 }, /* (335) star_func ::= COUNT */ + { 317, -1 }, /* (336) star_func ::= FIRST */ + { 317, -1 }, /* (337) star_func ::= LAST */ + { 317, -1 }, /* (338) star_func ::= LAST_ROW */ + { 318, -1 }, /* (339) star_func_para_list ::= NK_STAR */ + { 318, -1 }, /* (340) star_func_para_list ::= other_para_list */ + { 320, -1 }, /* (341) other_para_list ::= star_func_para */ + { 320, -3 }, /* (342) other_para_list ::= other_para_list NK_COMMA star_func_para */ + { 321, -1 }, /* (343) star_func_para ::= expression */ + { 321, -3 }, /* (344) star_func_para ::= table_name NK_DOT NK_STAR */ + { 322, -3 }, /* (345) predicate ::= expression compare_op expression */ + { 322, -5 }, /* (346) predicate ::= expression BETWEEN expression AND expression */ + { 322, -6 }, /* (347) predicate ::= expression NOT BETWEEN expression AND expression */ + { 322, -3 }, /* (348) predicate ::= expression IS NULL */ + { 322, -4 }, /* (349) predicate ::= expression IS NOT NULL */ + { 322, -3 }, /* (350) predicate ::= expression in_op in_predicate_value */ + { 323, -1 }, /* (351) compare_op ::= NK_LT */ + { 323, -1 }, /* (352) compare_op ::= NK_GT */ + { 323, -1 }, /* (353) compare_op ::= NK_LE */ + { 323, -1 }, /* (354) compare_op ::= NK_GE */ + { 323, -1 }, /* (355) compare_op ::= NK_NE */ + { 323, -1 }, /* (356) compare_op ::= NK_EQ */ + { 323, -1 }, /* (357) compare_op ::= LIKE */ + { 323, -2 }, /* (358) compare_op ::= NOT LIKE */ + { 323, -1 }, /* (359) compare_op ::= MATCH */ + { 323, -1 }, /* (360) compare_op ::= NMATCH */ + { 323, -1 }, /* (361) compare_op ::= CONTAINS */ + { 324, -1 }, /* (362) in_op ::= IN */ + { 324, -2 }, /* (363) in_op ::= NOT IN */ + { 325, -3 }, /* (364) in_predicate_value ::= NK_LP expression_list NK_RP */ + { 326, -1 }, /* (365) boolean_value_expression ::= boolean_primary */ + { 326, -2 }, /* (366) boolean_value_expression ::= NOT boolean_primary */ + { 326, -3 }, /* (367) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ + { 326, -3 }, /* (368) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ + { 327, -1 }, /* (369) boolean_primary ::= predicate */ + { 327, -3 }, /* (370) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ + { 328, -1 }, /* (371) common_expression ::= expression */ + { 328, -1 }, /* (372) common_expression ::= boolean_value_expression */ + { 329, -2 }, /* (373) from_clause ::= FROM table_reference_list */ + { 330, -1 }, /* (374) table_reference_list ::= table_reference */ + { 330, -3 }, /* (375) table_reference_list ::= table_reference_list NK_COMMA table_reference */ + { 331, -1 }, /* (376) table_reference ::= table_primary */ + { 331, -1 }, /* (377) table_reference ::= joined_table */ + { 332, -2 }, /* (378) table_primary ::= table_name alias_opt */ + { 332, -4 }, /* (379) table_primary ::= db_name NK_DOT table_name alias_opt */ + { 332, -2 }, /* (380) table_primary ::= subquery alias_opt */ + { 332, -1 }, /* (381) table_primary ::= parenthesized_joined_table */ + { 334, 0 }, /* (382) alias_opt ::= */ + { 334, -1 }, /* (383) alias_opt ::= table_alias */ + { 334, -2 }, /* (384) alias_opt ::= AS table_alias */ + { 335, -3 }, /* (385) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ + { 335, -3 }, /* (386) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ + { 333, -6 }, /* (387) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ + { 336, 0 }, /* (388) join_type ::= */ + { 336, -1 }, /* (389) join_type ::= INNER */ + { 338, -9 }, /* (390) query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ + { 339, 0 }, /* (391) set_quantifier_opt ::= */ + { 339, -1 }, /* (392) set_quantifier_opt ::= DISTINCT */ + { 339, -1 }, /* (393) set_quantifier_opt ::= ALL */ + { 340, -1 }, /* (394) select_list ::= NK_STAR */ + { 340, -1 }, /* (395) select_list ::= select_sublist */ + { 346, -1 }, /* (396) select_sublist ::= select_item */ + { 346, -3 }, /* (397) select_sublist ::= select_sublist NK_COMMA select_item */ + { 347, -1 }, /* (398) select_item ::= common_expression */ + { 347, -2 }, /* (399) select_item ::= common_expression column_alias */ + { 347, -3 }, /* (400) select_item ::= common_expression AS column_alias */ + { 347, -3 }, /* (401) select_item ::= table_name NK_DOT NK_STAR */ + { 341, 0 }, /* (402) where_clause_opt ::= */ + { 341, -2 }, /* (403) where_clause_opt ::= WHERE search_condition */ + { 342, 0 }, /* (404) partition_by_clause_opt ::= */ + { 342, -3 }, /* (405) partition_by_clause_opt ::= PARTITION BY expression_list */ + { 343, 0 }, /* (406) twindow_clause_opt ::= */ + { 343, -6 }, /* (407) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ + { 343, -4 }, /* (408) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */ + { 343, -6 }, /* (409) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ + { 343, -8 }, /* (410) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ + { 293, 0 }, /* (411) sliding_opt ::= */ + { 293, -4 }, /* (412) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ + { 348, 0 }, /* (413) fill_opt ::= */ + { 348, -4 }, /* (414) fill_opt ::= FILL NK_LP fill_mode NK_RP */ + { 348, -6 }, /* (415) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ + { 349, -1 }, /* (416) fill_mode ::= NONE */ + { 349, -1 }, /* (417) fill_mode ::= PREV */ + { 349, -1 }, /* (418) fill_mode ::= NULL */ + { 349, -1 }, /* (419) fill_mode ::= LINEAR */ + { 349, -1 }, /* (420) fill_mode ::= NEXT */ + { 344, 0 }, /* (421) group_by_clause_opt ::= */ + { 344, -3 }, /* (422) group_by_clause_opt ::= GROUP BY group_by_list */ + { 350, -1 }, /* (423) group_by_list ::= expression */ + { 350, -3 }, /* (424) group_by_list ::= group_by_list NK_COMMA expression */ + { 345, 0 }, /* (425) having_clause_opt ::= */ + { 345, -2 }, /* (426) having_clause_opt ::= HAVING search_condition */ + { 298, -4 }, /* (427) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ + { 351, -1 }, /* (428) query_expression_body ::= query_primary */ + { 351, -4 }, /* (429) query_expression_body ::= query_expression_body UNION ALL query_expression_body */ + { 351, -3 }, /* (430) query_expression_body ::= query_expression_body UNION query_expression_body */ + { 355, -1 }, /* (431) query_primary ::= query_specification */ + { 355, -6 }, /* (432) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */ + { 352, 0 }, /* (433) order_by_clause_opt ::= */ + { 352, -3 }, /* (434) order_by_clause_opt ::= ORDER BY sort_specification_list */ + { 353, 0 }, /* (435) slimit_clause_opt ::= */ + { 353, -2 }, /* (436) slimit_clause_opt ::= SLIMIT NK_INTEGER */ + { 353, -4 }, /* (437) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + { 353, -4 }, /* (438) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + { 354, 0 }, /* (439) limit_clause_opt ::= */ + { 354, -2 }, /* (440) limit_clause_opt ::= LIMIT NK_INTEGER */ + { 354, -4 }, /* (441) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ + { 354, -4 }, /* (442) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + { 316, -3 }, /* (443) subquery ::= NK_LP query_expression NK_RP */ + { 337, -1 }, /* (444) search_condition ::= common_expression */ + { 356, -1 }, /* (445) sort_specification_list ::= sort_specification */ + { 356, -3 }, /* (446) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ + { 357, -3 }, /* (447) sort_specification ::= expression ordering_specification_opt null_ordering_opt */ + { 358, 0 }, /* (448) ordering_specification_opt ::= */ + { 358, -1 }, /* (449) ordering_specification_opt ::= ASC */ + { 358, -1 }, /* (450) ordering_specification_opt ::= DESC */ + { 359, 0 }, /* (451) null_ordering_opt ::= */ + { 359, -2 }, /* (452) null_ordering_opt ::= NULLS FIRST */ + { 359, -2 }, /* (453) null_ordering_opt ::= NULLS LAST */ }; static void yy_accept(yyParser*); /* Forward Declaration */ @@ -3116,11 +3128,11 @@ static YYACTIONTYPE yy_reduce( YYMINORTYPE yylhsminor; case 0: /* cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */ { pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); } - yy_destructor(yypParser,241,&yymsp[0].minor); + yy_destructor(yypParser,240,&yymsp[0].minor); break; case 1: /* cmd ::= ALTER ACCOUNT NK_ID alter_account_options */ { pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); } - yy_destructor(yypParser,242,&yymsp[0].minor); + yy_destructor(yypParser,241,&yymsp[0].minor); break; case 2: /* account_options ::= */ { } @@ -3134,20 +3146,20 @@ static YYACTIONTYPE yy_reduce( case 9: /* account_options ::= account_options USERS literal */ yytestcase(yyruleno==9); case 10: /* account_options ::= account_options CONNS literal */ yytestcase(yyruleno==10); case 11: /* account_options ::= account_options STATE literal */ yytestcase(yyruleno==11); -{ yy_destructor(yypParser,241,&yymsp[-2].minor); +{ yy_destructor(yypParser,240,&yymsp[-2].minor); { } - yy_destructor(yypParser,243,&yymsp[0].minor); + yy_destructor(yypParser,242,&yymsp[0].minor); } break; case 12: /* alter_account_options ::= alter_account_option */ -{ yy_destructor(yypParser,244,&yymsp[0].minor); +{ yy_destructor(yypParser,243,&yymsp[0].minor); { } } break; case 13: /* alter_account_options ::= alter_account_options alter_account_option */ -{ yy_destructor(yypParser,242,&yymsp[-1].minor); +{ yy_destructor(yypParser,241,&yymsp[-1].minor); { } - yy_destructor(yypParser,244,&yymsp[0].minor); + yy_destructor(yypParser,243,&yymsp[0].minor); } break; case 14: /* alter_account_option ::= PASS literal */ @@ -3161,63 +3173,63 @@ static YYACTIONTYPE yy_reduce( case 22: /* alter_account_option ::= CONNS literal */ yytestcase(yyruleno==22); case 23: /* alter_account_option ::= STATE literal */ yytestcase(yyruleno==23); { } - yy_destructor(yypParser,243,&yymsp[0].minor); + yy_destructor(yypParser,242,&yymsp[0].minor); break; case 24: /* cmd ::= CREATE USER user_name PASS NK_STRING */ -{ pCxt->pRootNode = createCreateUserStmt(pCxt, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy0); } +{ pCxt->pRootNode = createCreateUserStmt(pCxt, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy0); } break; case 25: /* cmd ::= ALTER USER user_name PASS NK_STRING */ -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy53, TSDB_ALTER_USER_PASSWD, &yymsp[0].minor.yy0); } +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy209, TSDB_ALTER_USER_PASSWD, &yymsp[0].minor.yy0); } break; case 26: /* cmd ::= ALTER USER user_name PRIVILEGE NK_STRING */ -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy53, TSDB_ALTER_USER_PRIVILEGES, &yymsp[0].minor.yy0); } +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy209, TSDB_ALTER_USER_PRIVILEGES, &yymsp[0].minor.yy0); } break; case 27: /* cmd ::= DROP USER user_name */ -{ pCxt->pRootNode = createDropUserStmt(pCxt, &yymsp[0].minor.yy53); } +{ pCxt->pRootNode = createDropUserStmt(pCxt, &yymsp[0].minor.yy209); } break; case 28: /* cmd ::= GRANT privileges ON priv_level TO user_name */ -{ pCxt->pRootNode = createGrantStmt(pCxt, yymsp[-4].minor.yy435, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy53); } +{ pCxt->pRootNode = createGrantStmt(pCxt, yymsp[-4].minor.yy189, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy209); } break; case 29: /* cmd ::= REVOKE privileges ON priv_level FROM user_name */ -{ pCxt->pRootNode = createRevokeStmt(pCxt, yymsp[-4].minor.yy435, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy53); } +{ pCxt->pRootNode = createRevokeStmt(pCxt, yymsp[-4].minor.yy189, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy209); } break; case 30: /* privileges ::= ALL */ -{ yymsp[0].minor.yy435 = PRIVILEGE_TYPE_ALL; } +{ yymsp[0].minor.yy189 = PRIVILEGE_TYPE_ALL; } break; case 31: /* privileges ::= priv_type_list */ case 32: /* priv_type_list ::= priv_type */ yytestcase(yyruleno==32); -{ yylhsminor.yy435 = yymsp[0].minor.yy435; } - yymsp[0].minor.yy435 = yylhsminor.yy435; +{ yylhsminor.yy189 = yymsp[0].minor.yy189; } + yymsp[0].minor.yy189 = yylhsminor.yy189; break; case 33: /* priv_type_list ::= priv_type_list NK_COMMA priv_type */ -{ yylhsminor.yy435 = yymsp[-2].minor.yy435 | yymsp[0].minor.yy435; } - yymsp[-2].minor.yy435 = yylhsminor.yy435; +{ yylhsminor.yy189 = yymsp[-2].minor.yy189 | yymsp[0].minor.yy189; } + yymsp[-2].minor.yy189 = yylhsminor.yy189; break; case 34: /* priv_type ::= READ */ -{ yymsp[0].minor.yy435 = PRIVILEGE_TYPE_READ; } +{ yymsp[0].minor.yy189 = PRIVILEGE_TYPE_READ; } break; case 35: /* priv_type ::= WRITE */ -{ yymsp[0].minor.yy435 = PRIVILEGE_TYPE_WRITE; } +{ yymsp[0].minor.yy189 = PRIVILEGE_TYPE_WRITE; } break; case 36: /* priv_level ::= NK_STAR NK_DOT NK_STAR */ -{ yylhsminor.yy53 = yymsp[-2].minor.yy0; } - yymsp[-2].minor.yy53 = yylhsminor.yy53; +{ yylhsminor.yy209 = yymsp[-2].minor.yy0; } + yymsp[-2].minor.yy209 = yylhsminor.yy209; break; case 37: /* priv_level ::= db_name NK_DOT NK_STAR */ -{ yylhsminor.yy53 = yymsp[-2].minor.yy53; } - yymsp[-2].minor.yy53 = yylhsminor.yy53; +{ yylhsminor.yy209 = yymsp[-2].minor.yy209; } + yymsp[-2].minor.yy209 = yylhsminor.yy209; break; case 38: /* cmd ::= CREATE DNODE dnode_endpoint */ -{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[0].minor.yy53, NULL); } +{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[0].minor.yy209, NULL); } break; case 39: /* cmd ::= CREATE DNODE dnode_host_name PORT NK_INTEGER */ -{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy0); } +{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy0); } break; case 40: /* cmd ::= DROP DNODE NK_INTEGER */ { pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[0].minor.yy0); } break; case 41: /* cmd ::= DROP DNODE dnode_endpoint */ -{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[0].minor.yy53); } +{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[0].minor.yy209); } break; case 42: /* cmd ::= ALTER DNODE NK_INTEGER NK_STRING */ { pCxt->pRootNode = createAlterDnodeStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, NULL); } @@ -3234,26 +3246,26 @@ static YYACTIONTYPE yy_reduce( case 46: /* dnode_endpoint ::= NK_STRING */ case 47: /* dnode_host_name ::= NK_ID */ yytestcase(yyruleno==47); case 48: /* dnode_host_name ::= NK_IPTOKEN */ yytestcase(yyruleno==48); - case 290: /* db_name ::= NK_ID */ yytestcase(yyruleno==290); - case 291: /* table_name ::= NK_ID */ yytestcase(yyruleno==291); - case 292: /* column_name ::= NK_ID */ yytestcase(yyruleno==292); - case 293: /* function_name ::= NK_ID */ yytestcase(yyruleno==293); - case 294: /* table_alias ::= NK_ID */ yytestcase(yyruleno==294); - case 295: /* column_alias ::= NK_ID */ yytestcase(yyruleno==295); - case 296: /* user_name ::= NK_ID */ yytestcase(yyruleno==296); - case 297: /* index_name ::= NK_ID */ yytestcase(yyruleno==297); - case 298: /* topic_name ::= NK_ID */ yytestcase(yyruleno==298); - case 299: /* stream_name ::= NK_ID */ yytestcase(yyruleno==299); - case 300: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==300); - case 333: /* noarg_func ::= NOW */ yytestcase(yyruleno==333); - case 334: /* noarg_func ::= TODAY */ yytestcase(yyruleno==334); - case 335: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==335); - case 336: /* star_func ::= COUNT */ yytestcase(yyruleno==336); - case 337: /* star_func ::= FIRST */ yytestcase(yyruleno==337); - case 338: /* star_func ::= LAST */ yytestcase(yyruleno==338); - case 339: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==339); -{ yylhsminor.yy53 = yymsp[0].minor.yy0; } - yymsp[0].minor.yy53 = yylhsminor.yy53; + case 289: /* db_name ::= NK_ID */ yytestcase(yyruleno==289); + case 290: /* table_name ::= NK_ID */ yytestcase(yyruleno==290); + case 291: /* column_name ::= NK_ID */ yytestcase(yyruleno==291); + case 292: /* function_name ::= NK_ID */ yytestcase(yyruleno==292); + case 293: /* table_alias ::= NK_ID */ yytestcase(yyruleno==293); + case 294: /* column_alias ::= NK_ID */ yytestcase(yyruleno==294); + case 295: /* user_name ::= NK_ID */ yytestcase(yyruleno==295); + case 296: /* index_name ::= NK_ID */ yytestcase(yyruleno==296); + case 297: /* topic_name ::= NK_ID */ yytestcase(yyruleno==297); + case 298: /* stream_name ::= NK_ID */ yytestcase(yyruleno==298); + case 299: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==299); + case 332: /* noarg_func ::= NOW */ yytestcase(yyruleno==332); + case 333: /* noarg_func ::= TODAY */ yytestcase(yyruleno==333); + case 334: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==334); + case 335: /* star_func ::= COUNT */ yytestcase(yyruleno==335); + case 336: /* star_func ::= FIRST */ yytestcase(yyruleno==336); + case 337: /* star_func ::= LAST */ yytestcase(yyruleno==337); + case 338: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==338); +{ yylhsminor.yy209 = yymsp[0].minor.yy0; } + yymsp[0].minor.yy209 = yylhsminor.yy209; break; case 49: /* cmd ::= ALTER LOCAL NK_STRING */ { pCxt->pRootNode = createAlterLocalStmt(pCxt, &yymsp[0].minor.yy0, NULL); } @@ -3286,1161 +3298,1157 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createDropComponentNodeStmt(pCxt, QUERY_NODE_DROP_MNODE_STMT, &yymsp[0].minor.yy0); } break; case 59: /* cmd ::= CREATE DATABASE not_exists_opt db_name db_options */ -{ pCxt->pRootNode = createCreateDatabaseStmt(pCxt, yymsp[-2].minor.yy603, &yymsp[-1].minor.yy53, yymsp[0].minor.yy636); } +{ pCxt->pRootNode = createCreateDatabaseStmt(pCxt, yymsp[-2].minor.yy137, &yymsp[-1].minor.yy209, yymsp[0].minor.yy632); } break; case 60: /* cmd ::= DROP DATABASE exists_opt db_name */ -{ pCxt->pRootNode = createDropDatabaseStmt(pCxt, yymsp[-1].minor.yy603, &yymsp[0].minor.yy53); } +{ pCxt->pRootNode = createDropDatabaseStmt(pCxt, yymsp[-1].minor.yy137, &yymsp[0].minor.yy209); } break; case 61: /* cmd ::= USE db_name */ -{ pCxt->pRootNode = createUseDatabaseStmt(pCxt, &yymsp[0].minor.yy53); } +{ pCxt->pRootNode = createUseDatabaseStmt(pCxt, &yymsp[0].minor.yy209); } break; case 62: /* cmd ::= ALTER DATABASE db_name alter_db_options */ -{ pCxt->pRootNode = createAlterDatabaseStmt(pCxt, &yymsp[-1].minor.yy53, yymsp[0].minor.yy636); } +{ pCxt->pRootNode = createAlterDatabaseStmt(pCxt, &yymsp[-1].minor.yy209, yymsp[0].minor.yy632); } break; case 63: /* not_exists_opt ::= IF NOT EXISTS */ -{ yymsp[-2].minor.yy603 = true; } +{ yymsp[-2].minor.yy137 = true; } break; case 64: /* not_exists_opt ::= */ case 66: /* exists_opt ::= */ yytestcase(yyruleno==66); - case 236: /* analyze_opt ::= */ yytestcase(yyruleno==236); - case 244: /* agg_func_opt ::= */ yytestcase(yyruleno==244); - case 392: /* set_quantifier_opt ::= */ yytestcase(yyruleno==392); -{ yymsp[1].minor.yy603 = false; } + case 235: /* analyze_opt ::= */ yytestcase(yyruleno==235); + case 243: /* agg_func_opt ::= */ yytestcase(yyruleno==243); + case 391: /* set_quantifier_opt ::= */ yytestcase(yyruleno==391); +{ yymsp[1].minor.yy137 = false; } break; case 65: /* exists_opt ::= IF EXISTS */ -{ yymsp[-1].minor.yy603 = true; } +{ yymsp[-1].minor.yy137 = true; } break; case 67: /* db_options ::= */ -{ yymsp[1].minor.yy636 = createDefaultDatabaseOptions(pCxt); } +{ yymsp[1].minor.yy632 = createDefaultDatabaseOptions(pCxt); } break; case 68: /* db_options ::= db_options BUFFER NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_BUFFER, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = setDatabaseOption(pCxt, yymsp[-2].minor.yy632, DB_OPTION_BUFFER, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; case 69: /* db_options ::= db_options CACHELAST NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_CACHELAST, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = setDatabaseOption(pCxt, yymsp[-2].minor.yy632, DB_OPTION_CACHELAST, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; case 70: /* db_options ::= db_options COMP NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_COMP, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = setDatabaseOption(pCxt, yymsp[-2].minor.yy632, DB_OPTION_COMP, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; case 71: /* db_options ::= db_options DAYS NK_INTEGER */ case 72: /* db_options ::= db_options DAYS NK_VARIABLE */ yytestcase(yyruleno==72); -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_DAYS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = setDatabaseOption(pCxt, yymsp[-2].minor.yy632, DB_OPTION_DAYS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; case 73: /* db_options ::= db_options FSYNC NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_FSYNC, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = setDatabaseOption(pCxt, yymsp[-2].minor.yy632, DB_OPTION_FSYNC, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; case 74: /* db_options ::= db_options MAXROWS NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_MAXROWS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = setDatabaseOption(pCxt, yymsp[-2].minor.yy632, DB_OPTION_MAXROWS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; case 75: /* db_options ::= db_options MINROWS NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_MINROWS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = setDatabaseOption(pCxt, yymsp[-2].minor.yy632, DB_OPTION_MINROWS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; case 76: /* db_options ::= db_options KEEP integer_list */ case 77: /* db_options ::= db_options KEEP variable_list */ yytestcase(yyruleno==77); -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_KEEP, yymsp[0].minor.yy236); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = setDatabaseOption(pCxt, yymsp[-2].minor.yy632, DB_OPTION_KEEP, yymsp[0].minor.yy424); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; case 78: /* db_options ::= db_options PAGES NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_PAGES, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = setDatabaseOption(pCxt, yymsp[-2].minor.yy632, DB_OPTION_PAGES, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; case 79: /* db_options ::= db_options PAGESIZE NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_PAGESIZE, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = setDatabaseOption(pCxt, yymsp[-2].minor.yy632, DB_OPTION_PAGESIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; case 80: /* db_options ::= db_options PRECISION NK_STRING */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_PRECISION, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = setDatabaseOption(pCxt, yymsp[-2].minor.yy632, DB_OPTION_PRECISION, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; case 81: /* db_options ::= db_options REPLICA NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_REPLICA, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = setDatabaseOption(pCxt, yymsp[-2].minor.yy632, DB_OPTION_REPLICA, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; case 82: /* db_options ::= db_options STRICT NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_STRICT, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = setDatabaseOption(pCxt, yymsp[-2].minor.yy632, DB_OPTION_STRICT, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; case 83: /* db_options ::= db_options WAL NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_WAL, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = setDatabaseOption(pCxt, yymsp[-2].minor.yy632, DB_OPTION_WAL, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; case 84: /* db_options ::= db_options VGROUPS NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_VGROUPS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = setDatabaseOption(pCxt, yymsp[-2].minor.yy632, DB_OPTION_VGROUPS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; case 85: /* db_options ::= db_options SINGLE_STABLE NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_SINGLE_STABLE, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = setDatabaseOption(pCxt, yymsp[-2].minor.yy632, DB_OPTION_SINGLE_STABLE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; case 86: /* db_options ::= db_options RETENTIONS retention_list */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_RETENTIONS, yymsp[0].minor.yy236); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = setDatabaseOption(pCxt, yymsp[-2].minor.yy632, DB_OPTION_RETENTIONS, yymsp[0].minor.yy424); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; case 87: /* db_options ::= db_options SCHEMALESS NK_INTEGER */ -{ yylhsminor.yy636 = setDatabaseOption(pCxt, yymsp[-2].minor.yy636, DB_OPTION_SCHEMALESS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = setDatabaseOption(pCxt, yymsp[-2].minor.yy632, DB_OPTION_SCHEMALESS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; case 88: /* alter_db_options ::= alter_db_option */ -{ yylhsminor.yy636 = createAlterDatabaseOptions(pCxt); yylhsminor.yy636 = setAlterDatabaseOption(pCxt, yylhsminor.yy636, &yymsp[0].minor.yy25); } - yymsp[0].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = createAlterDatabaseOptions(pCxt); yylhsminor.yy632 = setAlterDatabaseOption(pCxt, yylhsminor.yy632, &yymsp[0].minor.yy605); } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; case 89: /* alter_db_options ::= alter_db_options alter_db_option */ -{ yylhsminor.yy636 = setAlterDatabaseOption(pCxt, yymsp[-1].minor.yy636, &yymsp[0].minor.yy25); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = setAlterDatabaseOption(pCxt, yymsp[-1].minor.yy632, &yymsp[0].minor.yy605); } + yymsp[-1].minor.yy632 = yylhsminor.yy632; break; case 90: /* alter_db_option ::= BUFFER NK_INTEGER */ -{ yymsp[-1].minor.yy25.type = DB_OPTION_BUFFER; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy605.type = DB_OPTION_BUFFER; yymsp[-1].minor.yy605.val = yymsp[0].minor.yy0; } break; case 91: /* alter_db_option ::= CACHELAST NK_INTEGER */ -{ yymsp[-1].minor.yy25.type = DB_OPTION_CACHELAST; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy605.type = DB_OPTION_CACHELAST; yymsp[-1].minor.yy605.val = yymsp[0].minor.yy0; } break; case 92: /* alter_db_option ::= FSYNC NK_INTEGER */ -{ yymsp[-1].minor.yy25.type = DB_OPTION_FSYNC; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy605.type = DB_OPTION_FSYNC; yymsp[-1].minor.yy605.val = yymsp[0].minor.yy0; } break; case 93: /* alter_db_option ::= KEEP integer_list */ case 94: /* alter_db_option ::= KEEP variable_list */ yytestcase(yyruleno==94); -{ yymsp[-1].minor.yy25.type = DB_OPTION_KEEP; yymsp[-1].minor.yy25.pList = yymsp[0].minor.yy236; } +{ yymsp[-1].minor.yy605.type = DB_OPTION_KEEP; yymsp[-1].minor.yy605.pList = yymsp[0].minor.yy424; } break; case 95: /* alter_db_option ::= PAGES NK_INTEGER */ -{ yymsp[-1].minor.yy25.type = DB_OPTION_PAGES; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy605.type = DB_OPTION_PAGES; yymsp[-1].minor.yy605.val = yymsp[0].minor.yy0; } break; case 96: /* alter_db_option ::= REPLICA NK_INTEGER */ -{ yymsp[-1].minor.yy25.type = DB_OPTION_REPLICA; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy605.type = DB_OPTION_REPLICA; yymsp[-1].minor.yy605.val = yymsp[0].minor.yy0; } break; case 97: /* alter_db_option ::= STRICT NK_INTEGER */ -{ yymsp[-1].minor.yy25.type = DB_OPTION_STRICT; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy605.type = DB_OPTION_STRICT; yymsp[-1].minor.yy605.val = yymsp[0].minor.yy0; } break; case 98: /* alter_db_option ::= WAL NK_INTEGER */ -{ yymsp[-1].minor.yy25.type = DB_OPTION_WAL; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } +{ yymsp[-1].minor.yy605.type = DB_OPTION_WAL; yymsp[-1].minor.yy605.val = yymsp[0].minor.yy0; } break; case 99: /* integer_list ::= NK_INTEGER */ -{ yylhsminor.yy236 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy236 = yylhsminor.yy236; +{ yylhsminor.yy424 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy424 = yylhsminor.yy424; break; case 100: /* integer_list ::= integer_list NK_COMMA NK_INTEGER */ - case 263: /* dnode_list ::= dnode_list DNODE NK_INTEGER */ yytestcase(yyruleno==263); -{ yylhsminor.yy236 = addNodeToList(pCxt, yymsp[-2].minor.yy236, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } - yymsp[-2].minor.yy236 = yylhsminor.yy236; + case 262: /* dnode_list ::= dnode_list DNODE NK_INTEGER */ yytestcase(yyruleno==262); +{ yylhsminor.yy424 = addNodeToList(pCxt, yymsp[-2].minor.yy424, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy424 = yylhsminor.yy424; break; case 101: /* variable_list ::= NK_VARIABLE */ -{ yylhsminor.yy236 = createNodeList(pCxt, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy236 = yylhsminor.yy236; +{ yylhsminor.yy424 = createNodeList(pCxt, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy424 = yylhsminor.yy424; break; case 102: /* variable_list ::= variable_list NK_COMMA NK_VARIABLE */ -{ yylhsminor.yy236 = addNodeToList(pCxt, yymsp[-2].minor.yy236, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[-2].minor.yy236 = yylhsminor.yy236; +{ yylhsminor.yy424 = addNodeToList(pCxt, yymsp[-2].minor.yy424, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy424 = yylhsminor.yy424; break; case 103: /* retention_list ::= retention */ case 123: /* multi_create_clause ::= create_subtable_clause */ yytestcase(yyruleno==123); case 126: /* multi_drop_clause ::= drop_table_clause */ yytestcase(yyruleno==126); case 133: /* column_def_list ::= column_def */ yytestcase(yyruleno==133); - case 174: /* col_name_list ::= col_name */ yytestcase(yyruleno==174); - case 212: /* func_name_list ::= func_name */ yytestcase(yyruleno==212); - case 221: /* func_list ::= func */ yytestcase(yyruleno==221); - case 288: /* literal_list ::= signed_literal */ yytestcase(yyruleno==288); - case 342: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==342); - case 397: /* select_sublist ::= select_item */ yytestcase(yyruleno==397); - case 446: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==446); -{ yylhsminor.yy236 = createNodeList(pCxt, yymsp[0].minor.yy636); } - yymsp[0].minor.yy236 = yylhsminor.yy236; + case 173: /* col_name_list ::= col_name */ yytestcase(yyruleno==173); + case 211: /* func_name_list ::= func_name */ yytestcase(yyruleno==211); + case 220: /* func_list ::= func */ yytestcase(yyruleno==220); + case 287: /* literal_list ::= signed_literal */ yytestcase(yyruleno==287); + case 341: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==341); + case 396: /* select_sublist ::= select_item */ yytestcase(yyruleno==396); + case 445: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==445); +{ yylhsminor.yy424 = createNodeList(pCxt, yymsp[0].minor.yy632); } + yymsp[0].minor.yy424 = yylhsminor.yy424; break; case 104: /* retention_list ::= retention_list NK_COMMA retention */ case 134: /* column_def_list ::= column_def_list NK_COMMA column_def */ yytestcase(yyruleno==134); - case 175: /* col_name_list ::= col_name_list NK_COMMA col_name */ yytestcase(yyruleno==175); - case 213: /* func_name_list ::= func_name_list NK_COMMA func_name */ yytestcase(yyruleno==213); - case 222: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==222); - case 289: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==289); - case 343: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==343); - case 398: /* select_sublist ::= select_sublist NK_COMMA select_item */ yytestcase(yyruleno==398); - case 447: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==447); -{ yylhsminor.yy236 = addNodeToList(pCxt, yymsp[-2].minor.yy236, yymsp[0].minor.yy636); } - yymsp[-2].minor.yy236 = yylhsminor.yy236; + case 174: /* col_name_list ::= col_name_list NK_COMMA col_name */ yytestcase(yyruleno==174); + case 212: /* func_name_list ::= func_name_list NK_COMMA func_name */ yytestcase(yyruleno==212); + case 221: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==221); + case 288: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==288); + case 342: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==342); + case 397: /* select_sublist ::= select_sublist NK_COMMA select_item */ yytestcase(yyruleno==397); + case 446: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==446); +{ yylhsminor.yy424 = addNodeToList(pCxt, yymsp[-2].minor.yy424, yymsp[0].minor.yy632); } + yymsp[-2].minor.yy424 = yylhsminor.yy424; break; case 105: /* retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ -{ yylhsminor.yy636 = createNodeListNodeEx(pCxt, createDurationValueNode(pCxt, &yymsp[-2].minor.yy0), createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = createNodeListNodeEx(pCxt, createDurationValueNode(pCxt, &yymsp[-2].minor.yy0), createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; case 106: /* cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ case 108: /* cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ yytestcase(yyruleno==108); -{ pCxt->pRootNode = createCreateTableStmt(pCxt, yymsp[-6].minor.yy603, yymsp[-5].minor.yy636, yymsp[-3].minor.yy236, yymsp[-1].minor.yy236, yymsp[0].minor.yy636); } +{ pCxt->pRootNode = createCreateTableStmt(pCxt, yymsp[-6].minor.yy137, yymsp[-5].minor.yy632, yymsp[-3].minor.yy424, yymsp[-1].minor.yy424, yymsp[0].minor.yy632); } break; case 107: /* cmd ::= CREATE TABLE multi_create_clause */ -{ pCxt->pRootNode = createCreateMultiTableStmt(pCxt, yymsp[0].minor.yy236); } +{ pCxt->pRootNode = createCreateMultiTableStmt(pCxt, yymsp[0].minor.yy424); } break; case 109: /* cmd ::= DROP TABLE multi_drop_clause */ -{ pCxt->pRootNode = createDropTableStmt(pCxt, yymsp[0].minor.yy236); } +{ pCxt->pRootNode = createDropTableStmt(pCxt, yymsp[0].minor.yy424); } break; case 110: /* cmd ::= DROP STABLE exists_opt full_table_name */ -{ pCxt->pRootNode = createDropSuperTableStmt(pCxt, yymsp[-1].minor.yy603, yymsp[0].minor.yy636); } +{ pCxt->pRootNode = createDropSuperTableStmt(pCxt, yymsp[-1].minor.yy137, yymsp[0].minor.yy632); } break; case 111: /* cmd ::= ALTER TABLE alter_table_clause */ case 112: /* cmd ::= ALTER STABLE alter_table_clause */ yytestcase(yyruleno==112); - case 265: /* cmd ::= query_expression */ yytestcase(yyruleno==265); -{ pCxt->pRootNode = yymsp[0].minor.yy636; } + case 264: /* cmd ::= query_expression */ yytestcase(yyruleno==264); +{ pCxt->pRootNode = yymsp[0].minor.yy632; } break; case 113: /* alter_table_clause ::= full_table_name alter_table_options */ -{ yylhsminor.yy636 = createAlterTableModifyOptions(pCxt, yymsp[-1].minor.yy636, yymsp[0].minor.yy636); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = createAlterTableModifyOptions(pCxt, yymsp[-1].minor.yy632, yymsp[0].minor.yy632); } + yymsp[-1].minor.yy632 = yylhsminor.yy632; break; case 114: /* alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ -{ yylhsminor.yy636 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy636, TSDB_ALTER_TABLE_ADD_COLUMN, &yymsp[-1].minor.yy53, yymsp[0].minor.yy450); } - yymsp[-4].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy632, TSDB_ALTER_TABLE_ADD_COLUMN, &yymsp[-1].minor.yy209, yymsp[0].minor.yy304); } + yymsp[-4].minor.yy632 = yylhsminor.yy632; break; case 115: /* alter_table_clause ::= full_table_name DROP COLUMN column_name */ -{ yylhsminor.yy636 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy636, TSDB_ALTER_TABLE_DROP_COLUMN, &yymsp[0].minor.yy53); } - yymsp[-3].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy632, TSDB_ALTER_TABLE_DROP_COLUMN, &yymsp[0].minor.yy209); } + yymsp[-3].minor.yy632 = yylhsminor.yy632; break; case 116: /* alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ -{ yylhsminor.yy636 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy636, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, &yymsp[-1].minor.yy53, yymsp[0].minor.yy450); } - yymsp[-4].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy632, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, &yymsp[-1].minor.yy209, yymsp[0].minor.yy304); } + yymsp[-4].minor.yy632 = yylhsminor.yy632; break; case 117: /* alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ -{ yylhsminor.yy636 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy636, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &yymsp[-1].minor.yy53, &yymsp[0].minor.yy53); } - yymsp[-4].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy632, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &yymsp[-1].minor.yy209, &yymsp[0].minor.yy209); } + yymsp[-4].minor.yy632 = yylhsminor.yy632; break; case 118: /* alter_table_clause ::= full_table_name ADD TAG column_name type_name */ -{ yylhsminor.yy636 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy636, TSDB_ALTER_TABLE_ADD_TAG, &yymsp[-1].minor.yy53, yymsp[0].minor.yy450); } - yymsp[-4].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy632, TSDB_ALTER_TABLE_ADD_TAG, &yymsp[-1].minor.yy209, yymsp[0].minor.yy304); } + yymsp[-4].minor.yy632 = yylhsminor.yy632; break; case 119: /* alter_table_clause ::= full_table_name DROP TAG column_name */ -{ yylhsminor.yy636 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy636, TSDB_ALTER_TABLE_DROP_TAG, &yymsp[0].minor.yy53); } - yymsp[-3].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy632, TSDB_ALTER_TABLE_DROP_TAG, &yymsp[0].minor.yy209); } + yymsp[-3].minor.yy632 = yylhsminor.yy632; break; case 120: /* alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ -{ yylhsminor.yy636 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy636, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &yymsp[-1].minor.yy53, yymsp[0].minor.yy450); } - yymsp[-4].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy632, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &yymsp[-1].minor.yy209, yymsp[0].minor.yy304); } + yymsp[-4].minor.yy632 = yylhsminor.yy632; break; case 121: /* alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ -{ yylhsminor.yy636 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy636, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &yymsp[-1].minor.yy53, &yymsp[0].minor.yy53); } - yymsp[-4].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy632, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &yymsp[-1].minor.yy209, &yymsp[0].minor.yy209); } + yymsp[-4].minor.yy632 = yylhsminor.yy632; break; case 122: /* alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ -{ yylhsminor.yy636 = createAlterTableSetTag(pCxt, yymsp[-5].minor.yy636, &yymsp[-2].minor.yy53, yymsp[0].minor.yy636); } - yymsp[-5].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = createAlterTableSetTag(pCxt, yymsp[-5].minor.yy632, &yymsp[-2].minor.yy209, yymsp[0].minor.yy632); } + yymsp[-5].minor.yy632 = yylhsminor.yy632; break; case 124: /* multi_create_clause ::= multi_create_clause create_subtable_clause */ case 127: /* multi_drop_clause ::= multi_drop_clause drop_table_clause */ yytestcase(yyruleno==127); -{ yylhsminor.yy236 = addNodeToList(pCxt, yymsp[-1].minor.yy236, yymsp[0].minor.yy636); } - yymsp[-1].minor.yy236 = yylhsminor.yy236; +{ yylhsminor.yy424 = addNodeToList(pCxt, yymsp[-1].minor.yy424, yymsp[0].minor.yy632); } + yymsp[-1].minor.yy424 = yylhsminor.yy424; break; case 125: /* create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP literal_list NK_RP table_options */ -{ yylhsminor.yy636 = createCreateSubTableClause(pCxt, yymsp[-9].minor.yy603, yymsp[-8].minor.yy636, yymsp[-6].minor.yy636, yymsp[-5].minor.yy236, yymsp[-2].minor.yy236, yymsp[0].minor.yy636); } - yymsp[-9].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = createCreateSubTableClause(pCxt, yymsp[-9].minor.yy137, yymsp[-8].minor.yy632, yymsp[-6].minor.yy632, yymsp[-5].minor.yy424, yymsp[-2].minor.yy424, yymsp[0].minor.yy632); } + yymsp[-9].minor.yy632 = yylhsminor.yy632; break; case 128: /* drop_table_clause ::= exists_opt full_table_name */ -{ yylhsminor.yy636 = createDropTableClause(pCxt, yymsp[-1].minor.yy603, yymsp[0].minor.yy636); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = createDropTableClause(pCxt, yymsp[-1].minor.yy137, yymsp[0].minor.yy632); } + yymsp[-1].minor.yy632 = yylhsminor.yy632; break; case 129: /* specific_tags_opt ::= */ case 160: /* tags_def_opt ::= */ yytestcase(yyruleno==160); - case 405: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==405); - case 422: /* group_by_clause_opt ::= */ yytestcase(yyruleno==422); - case 434: /* order_by_clause_opt ::= */ yytestcase(yyruleno==434); -{ yymsp[1].minor.yy236 = NULL; } + case 404: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==404); + case 421: /* group_by_clause_opt ::= */ yytestcase(yyruleno==421); + case 433: /* order_by_clause_opt ::= */ yytestcase(yyruleno==433); +{ yymsp[1].minor.yy424 = NULL; } break; case 130: /* specific_tags_opt ::= NK_LP col_name_list NK_RP */ -{ yymsp[-2].minor.yy236 = yymsp[-1].minor.yy236; } +{ yymsp[-2].minor.yy424 = yymsp[-1].minor.yy424; } break; case 131: /* full_table_name ::= table_name */ -{ yylhsminor.yy636 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy53, NULL); } - yymsp[0].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy209, NULL); } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; case 132: /* full_table_name ::= db_name NK_DOT table_name */ -{ yylhsminor.yy636 = createRealTableNode(pCxt, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy53, NULL); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = createRealTableNode(pCxt, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy209, NULL); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; case 135: /* column_def ::= column_name type_name */ -{ yylhsminor.yy636 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy53, yymsp[0].minor.yy450, NULL); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy209, yymsp[0].minor.yy304, NULL); } + yymsp[-1].minor.yy632 = yylhsminor.yy632; break; case 136: /* column_def ::= column_name type_name COMMENT NK_STRING */ -{ yylhsminor.yy636 = createColumnDefNode(pCxt, &yymsp[-3].minor.yy53, yymsp[-2].minor.yy450, &yymsp[0].minor.yy0); } - yymsp[-3].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = createColumnDefNode(pCxt, &yymsp[-3].minor.yy209, yymsp[-2].minor.yy304, &yymsp[0].minor.yy0); } + yymsp[-3].minor.yy632 = yylhsminor.yy632; break; case 137: /* type_name ::= BOOL */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_BOOL); } +{ yymsp[0].minor.yy304 = createDataType(TSDB_DATA_TYPE_BOOL); } break; case 138: /* type_name ::= TINYINT */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_TINYINT); } +{ yymsp[0].minor.yy304 = createDataType(TSDB_DATA_TYPE_TINYINT); } break; case 139: /* type_name ::= SMALLINT */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_SMALLINT); } +{ yymsp[0].minor.yy304 = createDataType(TSDB_DATA_TYPE_SMALLINT); } break; case 140: /* type_name ::= INT */ case 141: /* type_name ::= INTEGER */ yytestcase(yyruleno==141); -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_INT); } +{ yymsp[0].minor.yy304 = createDataType(TSDB_DATA_TYPE_INT); } break; case 142: /* type_name ::= BIGINT */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_BIGINT); } +{ yymsp[0].minor.yy304 = createDataType(TSDB_DATA_TYPE_BIGINT); } break; case 143: /* type_name ::= FLOAT */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_FLOAT); } +{ yymsp[0].minor.yy304 = createDataType(TSDB_DATA_TYPE_FLOAT); } break; case 144: /* type_name ::= DOUBLE */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_DOUBLE); } +{ yymsp[0].minor.yy304 = createDataType(TSDB_DATA_TYPE_DOUBLE); } break; case 145: /* type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy450 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy0); } +{ yymsp[-3].minor.yy304 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy0); } break; case 146: /* type_name ::= TIMESTAMP */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_TIMESTAMP); } +{ yymsp[0].minor.yy304 = createDataType(TSDB_DATA_TYPE_TIMESTAMP); } break; case 147: /* type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy450 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, &yymsp[-1].minor.yy0); } +{ yymsp[-3].minor.yy304 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, &yymsp[-1].minor.yy0); } break; case 148: /* type_name ::= TINYINT UNSIGNED */ -{ yymsp[-1].minor.yy450 = createDataType(TSDB_DATA_TYPE_UTINYINT); } +{ yymsp[-1].minor.yy304 = createDataType(TSDB_DATA_TYPE_UTINYINT); } break; case 149: /* type_name ::= SMALLINT UNSIGNED */ -{ yymsp[-1].minor.yy450 = createDataType(TSDB_DATA_TYPE_USMALLINT); } +{ yymsp[-1].minor.yy304 = createDataType(TSDB_DATA_TYPE_USMALLINT); } break; case 150: /* type_name ::= INT UNSIGNED */ -{ yymsp[-1].minor.yy450 = createDataType(TSDB_DATA_TYPE_UINT); } +{ yymsp[-1].minor.yy304 = createDataType(TSDB_DATA_TYPE_UINT); } break; case 151: /* type_name ::= BIGINT UNSIGNED */ -{ yymsp[-1].minor.yy450 = createDataType(TSDB_DATA_TYPE_UBIGINT); } +{ yymsp[-1].minor.yy304 = createDataType(TSDB_DATA_TYPE_UBIGINT); } break; case 152: /* type_name ::= JSON */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_JSON); } +{ yymsp[0].minor.yy304 = createDataType(TSDB_DATA_TYPE_JSON); } break; case 153: /* type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy450 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, &yymsp[-1].minor.yy0); } +{ yymsp[-3].minor.yy304 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, &yymsp[-1].minor.yy0); } break; case 154: /* type_name ::= MEDIUMBLOB */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_MEDIUMBLOB); } +{ yymsp[0].minor.yy304 = createDataType(TSDB_DATA_TYPE_MEDIUMBLOB); } break; case 155: /* type_name ::= BLOB */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_BLOB); } +{ yymsp[0].minor.yy304 = createDataType(TSDB_DATA_TYPE_BLOB); } break; case 156: /* type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy450 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, &yymsp[-1].minor.yy0); } +{ yymsp[-3].minor.yy304 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, &yymsp[-1].minor.yy0); } break; case 157: /* type_name ::= DECIMAL */ -{ yymsp[0].minor.yy450 = createDataType(TSDB_DATA_TYPE_DECIMAL); } +{ yymsp[0].minor.yy304 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; case 158: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy450 = createDataType(TSDB_DATA_TYPE_DECIMAL); } +{ yymsp[-3].minor.yy304 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; case 159: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ -{ yymsp[-5].minor.yy450 = createDataType(TSDB_DATA_TYPE_DECIMAL); } +{ yymsp[-5].minor.yy304 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; case 161: /* tags_def_opt ::= tags_def */ - case 341: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==341); - case 396: /* select_list ::= select_sublist */ yytestcase(yyruleno==396); -{ yylhsminor.yy236 = yymsp[0].minor.yy236; } - yymsp[0].minor.yy236 = yylhsminor.yy236; + case 340: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==340); + case 395: /* select_list ::= select_sublist */ yytestcase(yyruleno==395); +{ yylhsminor.yy424 = yymsp[0].minor.yy424; } + yymsp[0].minor.yy424 = yylhsminor.yy424; break; case 162: /* tags_def ::= TAGS NK_LP column_def_list NK_RP */ -{ yymsp[-3].minor.yy236 = yymsp[-1].minor.yy236; } +{ yymsp[-3].minor.yy424 = yymsp[-1].minor.yy424; } break; case 163: /* table_options ::= */ -{ yymsp[1].minor.yy636 = createDefaultTableOptions(pCxt); } +{ yymsp[1].minor.yy632 = createDefaultTableOptions(pCxt); } break; case 164: /* table_options ::= table_options COMMENT NK_STRING */ -{ yylhsminor.yy636 = setTableOption(pCxt, yymsp[-2].minor.yy636, TABLE_OPTION_COMMENT, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; +{ yylhsminor.yy632 = setTableOption(pCxt, yymsp[-2].minor.yy632, TABLE_OPTION_COMMENT, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 165: /* table_options ::= table_options DELAY NK_INTEGER */ -{ yylhsminor.yy636 = setTableOption(pCxt, yymsp[-2].minor.yy636, TABLE_OPTION_DELAY, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 165: /* table_options ::= table_options FILE_FACTOR NK_FLOAT */ +{ yylhsminor.yy632 = setTableOption(pCxt, yymsp[-2].minor.yy632, TABLE_OPTION_FILE_FACTOR, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 166: /* table_options ::= table_options FILE_FACTOR NK_FLOAT */ -{ yylhsminor.yy636 = setTableOption(pCxt, yymsp[-2].minor.yy636, TABLE_OPTION_FILE_FACTOR, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 166: /* table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP */ +{ yylhsminor.yy632 = setTableOption(pCxt, yymsp[-4].minor.yy632, TABLE_OPTION_ROLLUP, yymsp[-1].minor.yy424); } + yymsp[-4].minor.yy632 = yylhsminor.yy632; break; - case 167: /* table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP */ -{ yylhsminor.yy636 = setTableOption(pCxt, yymsp[-4].minor.yy636, TABLE_OPTION_ROLLUP, yymsp[-1].minor.yy236); } - yymsp[-4].minor.yy636 = yylhsminor.yy636; + case 167: /* table_options ::= table_options TTL NK_INTEGER */ +{ yylhsminor.yy632 = setTableOption(pCxt, yymsp[-2].minor.yy632, TABLE_OPTION_TTL, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 168: /* table_options ::= table_options TTL NK_INTEGER */ -{ yylhsminor.yy636 = setTableOption(pCxt, yymsp[-2].minor.yy636, TABLE_OPTION_TTL, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 168: /* table_options ::= table_options SMA NK_LP col_name_list NK_RP */ +{ yylhsminor.yy632 = setTableOption(pCxt, yymsp[-4].minor.yy632, TABLE_OPTION_SMA, yymsp[-1].minor.yy424); } + yymsp[-4].minor.yy632 = yylhsminor.yy632; break; - case 169: /* table_options ::= table_options SMA NK_LP col_name_list NK_RP */ -{ yylhsminor.yy636 = setTableOption(pCxt, yymsp[-4].minor.yy636, TABLE_OPTION_SMA, yymsp[-1].minor.yy236); } - yymsp[-4].minor.yy636 = yylhsminor.yy636; + case 169: /* alter_table_options ::= alter_table_option */ +{ yylhsminor.yy632 = createAlterTableOptions(pCxt); yylhsminor.yy632 = setTableOption(pCxt, yylhsminor.yy632, yymsp[0].minor.yy605.type, &yymsp[0].minor.yy605.val); } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; - case 170: /* alter_table_options ::= alter_table_option */ -{ yylhsminor.yy636 = createAlterTableOptions(pCxt); yylhsminor.yy636 = setTableOption(pCxt, yylhsminor.yy636, yymsp[0].minor.yy25.type, &yymsp[0].minor.yy25.val); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 170: /* alter_table_options ::= alter_table_options alter_table_option */ +{ yylhsminor.yy632 = setTableOption(pCxt, yymsp[-1].minor.yy632, yymsp[0].minor.yy605.type, &yymsp[0].minor.yy605.val); } + yymsp[-1].minor.yy632 = yylhsminor.yy632; break; - case 171: /* alter_table_options ::= alter_table_options alter_table_option */ -{ yylhsminor.yy636 = setTableOption(pCxt, yymsp[-1].minor.yy636, yymsp[0].minor.yy25.type, &yymsp[0].minor.yy25.val); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; + case 171: /* alter_table_option ::= COMMENT NK_STRING */ +{ yymsp[-1].minor.yy605.type = TABLE_OPTION_COMMENT; yymsp[-1].minor.yy605.val = yymsp[0].minor.yy0; } break; - case 172: /* alter_table_option ::= COMMENT NK_STRING */ -{ yymsp[-1].minor.yy25.type = TABLE_OPTION_COMMENT; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } + case 172: /* alter_table_option ::= TTL NK_INTEGER */ +{ yymsp[-1].minor.yy605.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy605.val = yymsp[0].minor.yy0; } break; - case 173: /* alter_table_option ::= TTL NK_INTEGER */ -{ yymsp[-1].minor.yy25.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } + case 175: /* col_name ::= column_name */ +{ yylhsminor.yy632 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy209); } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; - case 176: /* col_name ::= column_name */ -{ yylhsminor.yy636 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy53); } - yymsp[0].minor.yy636 = yylhsminor.yy636; - break; - case 177: /* cmd ::= SHOW DNODES */ + case 176: /* cmd ::= SHOW DNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DNODES_STMT, NULL, NULL); } break; - case 178: /* cmd ::= SHOW USERS */ + case 177: /* cmd ::= SHOW USERS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_USERS_STMT, NULL, NULL); } break; - case 179: /* cmd ::= SHOW DATABASES */ + case 178: /* cmd ::= SHOW DATABASES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DATABASES_STMT, NULL, NULL); } break; - case 180: /* cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */ -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TABLES_STMT, yymsp[-2].minor.yy636, yymsp[0].minor.yy636); } + case 179: /* cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */ +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TABLES_STMT, yymsp[-2].minor.yy632, yymsp[0].minor.yy632); } break; - case 181: /* cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_STABLES_STMT, yymsp[-2].minor.yy636, yymsp[0].minor.yy636); } + case 180: /* cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_STABLES_STMT, yymsp[-2].minor.yy632, yymsp[0].minor.yy632); } break; - case 182: /* cmd ::= SHOW db_name_cond_opt VGROUPS */ -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, yymsp[-1].minor.yy636, NULL); } + case 181: /* cmd ::= SHOW db_name_cond_opt VGROUPS */ +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, yymsp[-1].minor.yy632, NULL); } break; - case 183: /* cmd ::= SHOW MNODES */ + case 182: /* cmd ::= SHOW MNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_MNODES_STMT, NULL, NULL); } break; - case 184: /* cmd ::= SHOW MODULES */ + case 183: /* cmd ::= SHOW MODULES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_MODULES_STMT, NULL, NULL); } break; - case 185: /* cmd ::= SHOW QNODES */ + case 184: /* cmd ::= SHOW QNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QNODES_STMT, NULL, NULL); } break; - case 186: /* cmd ::= SHOW FUNCTIONS */ + case 185: /* cmd ::= SHOW FUNCTIONS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_FUNCTIONS_STMT, NULL, NULL); } break; - case 187: /* cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, yymsp[-1].minor.yy636, yymsp[0].minor.yy636); } + case 186: /* cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, yymsp[-1].minor.yy632, yymsp[0].minor.yy632); } break; - case 188: /* cmd ::= SHOW STREAMS */ + case 187: /* cmd ::= SHOW STREAMS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_STREAMS_STMT, NULL, NULL); } break; - case 189: /* cmd ::= SHOW ACCOUNTS */ + case 188: /* cmd ::= SHOW ACCOUNTS */ { pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); } break; - case 190: /* cmd ::= SHOW APPS */ + case 189: /* cmd ::= SHOW APPS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_APPS_STMT, NULL, NULL); } break; - case 191: /* cmd ::= SHOW CONNECTIONS */ + case 190: /* cmd ::= SHOW CONNECTIONS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CONNECTIONS_STMT, NULL, NULL); } break; - case 192: /* cmd ::= SHOW LICENCE */ - case 193: /* cmd ::= SHOW GRANTS */ yytestcase(yyruleno==193); + case 191: /* cmd ::= SHOW LICENCE */ + case 192: /* cmd ::= SHOW GRANTS */ yytestcase(yyruleno==192); { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_LICENCE_STMT, NULL, NULL); } break; - case 194: /* cmd ::= SHOW CREATE DATABASE db_name */ -{ pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &yymsp[0].minor.yy53); } + case 193: /* cmd ::= SHOW CREATE DATABASE db_name */ +{ pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &yymsp[0].minor.yy209); } break; - case 195: /* cmd ::= SHOW CREATE TABLE full_table_name */ -{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, yymsp[0].minor.yy636); } + case 194: /* cmd ::= SHOW CREATE TABLE full_table_name */ +{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, yymsp[0].minor.yy632); } break; - case 196: /* cmd ::= SHOW CREATE STABLE full_table_name */ -{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, yymsp[0].minor.yy636); } + case 195: /* cmd ::= SHOW CREATE STABLE full_table_name */ +{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, yymsp[0].minor.yy632); } break; - case 197: /* cmd ::= SHOW QUERIES */ + case 196: /* cmd ::= SHOW QUERIES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QUERIES_STMT, NULL, NULL); } break; - case 198: /* cmd ::= SHOW SCORES */ + case 197: /* cmd ::= SHOW SCORES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SCORES_STMT, NULL, NULL); } break; - case 199: /* cmd ::= SHOW TOPICS */ + case 198: /* cmd ::= SHOW TOPICS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TOPICS_STMT, NULL, NULL); } break; - case 200: /* cmd ::= SHOW VARIABLES */ + case 199: /* cmd ::= SHOW VARIABLES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_VARIABLE_STMT, NULL, NULL); } break; - case 201: /* cmd ::= SHOW BNODES */ + case 200: /* cmd ::= SHOW BNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_BNODES_STMT, NULL, NULL); } break; - case 202: /* cmd ::= SHOW SNODES */ + case 201: /* cmd ::= SHOW SNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SNODES_STMT, NULL, NULL); } break; - case 203: /* cmd ::= SHOW CLUSTER */ + case 202: /* cmd ::= SHOW CLUSTER */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CLUSTER_STMT, NULL, NULL); } break; - case 204: /* cmd ::= SHOW TRANSACTIONS */ + case 203: /* cmd ::= SHOW TRANSACTIONS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TRANSACTIONS_STMT, NULL, NULL); } break; - case 205: /* db_name_cond_opt ::= */ - case 210: /* from_db_opt ::= */ yytestcase(yyruleno==210); -{ yymsp[1].minor.yy636 = createDefaultDatabaseCondValue(pCxt); } + case 204: /* db_name_cond_opt ::= */ + case 209: /* from_db_opt ::= */ yytestcase(yyruleno==209); +{ yymsp[1].minor.yy632 = createDefaultDatabaseCondValue(pCxt); } break; - case 206: /* db_name_cond_opt ::= db_name NK_DOT */ -{ yylhsminor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy53); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; + case 205: /* db_name_cond_opt ::= db_name NK_DOT */ +{ yylhsminor.yy632 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy209); } + yymsp[-1].minor.yy632 = yylhsminor.yy632; break; - case 207: /* like_pattern_opt ::= */ - case 218: /* index_options ::= */ yytestcase(yyruleno==218); - case 250: /* into_opt ::= */ yytestcase(yyruleno==250); - case 403: /* where_clause_opt ::= */ yytestcase(yyruleno==403); - case 407: /* twindow_clause_opt ::= */ yytestcase(yyruleno==407); - case 412: /* sliding_opt ::= */ yytestcase(yyruleno==412); - case 414: /* fill_opt ::= */ yytestcase(yyruleno==414); - case 426: /* having_clause_opt ::= */ yytestcase(yyruleno==426); - case 436: /* slimit_clause_opt ::= */ yytestcase(yyruleno==436); - case 440: /* limit_clause_opt ::= */ yytestcase(yyruleno==440); -{ yymsp[1].minor.yy636 = NULL; } + case 206: /* like_pattern_opt ::= */ + case 217: /* index_options ::= */ yytestcase(yyruleno==217); + case 249: /* into_opt ::= */ yytestcase(yyruleno==249); + case 402: /* where_clause_opt ::= */ yytestcase(yyruleno==402); + case 406: /* twindow_clause_opt ::= */ yytestcase(yyruleno==406); + case 411: /* sliding_opt ::= */ yytestcase(yyruleno==411); + case 413: /* fill_opt ::= */ yytestcase(yyruleno==413); + case 425: /* having_clause_opt ::= */ yytestcase(yyruleno==425); + case 435: /* slimit_clause_opt ::= */ yytestcase(yyruleno==435); + case 439: /* limit_clause_opt ::= */ yytestcase(yyruleno==439); +{ yymsp[1].minor.yy632 = NULL; } break; - case 208: /* like_pattern_opt ::= LIKE NK_STRING */ -{ yymsp[-1].minor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } + case 207: /* like_pattern_opt ::= LIKE NK_STRING */ +{ yymsp[-1].minor.yy632 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } break; - case 209: /* table_name_cond ::= table_name */ -{ yylhsminor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy53); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 208: /* table_name_cond ::= table_name */ +{ yylhsminor.yy632 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy209); } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; - case 211: /* from_db_opt ::= FROM db_name */ -{ yymsp[-1].minor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy53); } + case 210: /* from_db_opt ::= FROM db_name */ +{ yymsp[-1].minor.yy632 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy209); } break; - case 214: /* func_name ::= function_name */ -{ yylhsminor.yy636 = createFunctionNode(pCxt, &yymsp[0].minor.yy53, NULL); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 213: /* func_name ::= function_name */ +{ yylhsminor.yy632 = createFunctionNode(pCxt, &yymsp[0].minor.yy209, NULL); } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; - case 215: /* cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options */ -{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_SMA, yymsp[-4].minor.yy603, &yymsp[-3].minor.yy53, &yymsp[-1].minor.yy53, NULL, yymsp[0].minor.yy636); } + case 214: /* cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options */ +{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_SMA, yymsp[-4].minor.yy137, &yymsp[-3].minor.yy209, &yymsp[-1].minor.yy209, NULL, yymsp[0].minor.yy632); } break; - case 216: /* cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP */ -{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_FULLTEXT, yymsp[-6].minor.yy603, &yymsp[-5].minor.yy53, &yymsp[-3].minor.yy53, yymsp[-1].minor.yy236, NULL); } + case 215: /* cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP */ +{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_FULLTEXT, yymsp[-6].minor.yy137, &yymsp[-5].minor.yy209, &yymsp[-3].minor.yy209, yymsp[-1].minor.yy424, NULL); } break; - case 217: /* cmd ::= DROP INDEX exists_opt index_name ON table_name */ -{ pCxt->pRootNode = createDropIndexStmt(pCxt, yymsp[-3].minor.yy603, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy53); } + case 216: /* cmd ::= DROP INDEX exists_opt index_name ON table_name */ +{ pCxt->pRootNode = createDropIndexStmt(pCxt, yymsp[-3].minor.yy137, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy209); } break; - case 219: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt */ -{ yymsp[-8].minor.yy636 = createIndexOption(pCxt, yymsp[-6].minor.yy236, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), NULL, yymsp[0].minor.yy636); } + case 218: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt */ +{ yymsp[-8].minor.yy632 = createIndexOption(pCxt, yymsp[-6].minor.yy424, releaseRawExprNode(pCxt, yymsp[-2].minor.yy632), NULL, yymsp[0].minor.yy632); } break; - case 220: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt */ -{ yymsp[-10].minor.yy636 = createIndexOption(pCxt, yymsp[-8].minor.yy236, releaseRawExprNode(pCxt, yymsp[-4].minor.yy636), releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), yymsp[0].minor.yy636); } + case 219: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt */ +{ yymsp[-10].minor.yy632 = createIndexOption(pCxt, yymsp[-8].minor.yy424, releaseRawExprNode(pCxt, yymsp[-4].minor.yy632), releaseRawExprNode(pCxt, yymsp[-2].minor.yy632), yymsp[0].minor.yy632); } break; - case 223: /* func ::= function_name NK_LP expression_list NK_RP */ -{ yylhsminor.yy636 = createFunctionNode(pCxt, &yymsp[-3].minor.yy53, yymsp[-1].minor.yy236); } - yymsp[-3].minor.yy636 = yylhsminor.yy636; + case 222: /* func ::= function_name NK_LP expression_list NK_RP */ +{ yylhsminor.yy632 = createFunctionNode(pCxt, &yymsp[-3].minor.yy209, yymsp[-1].minor.yy424); } + yymsp[-3].minor.yy632 = yylhsminor.yy632; break; - case 224: /* cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS query_expression */ -{ pCxt->pRootNode = createCreateTopicStmt(pCxt, yymsp[-4].minor.yy603, &yymsp[-3].minor.yy53, yymsp[0].minor.yy636, NULL, yymsp[-2].minor.yy636); } + case 223: /* cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS query_expression */ +{ pCxt->pRootNode = createCreateTopicStmt(pCxt, yymsp[-4].minor.yy137, &yymsp[-3].minor.yy209, yymsp[0].minor.yy632, NULL, yymsp[-2].minor.yy632); } break; - case 225: /* cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS db_name */ -{ pCxt->pRootNode = createCreateTopicStmt(pCxt, yymsp[-4].minor.yy603, &yymsp[-3].minor.yy53, NULL, &yymsp[0].minor.yy53, yymsp[-2].minor.yy636); } + case 224: /* cmd ::= CREATE TOPIC not_exists_opt topic_name topic_options AS db_name */ +{ pCxt->pRootNode = createCreateTopicStmt(pCxt, yymsp[-4].minor.yy137, &yymsp[-3].minor.yy209, NULL, &yymsp[0].minor.yy209, yymsp[-2].minor.yy632); } break; - case 226: /* cmd ::= DROP TOPIC exists_opt topic_name */ -{ pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy603, &yymsp[0].minor.yy53); } + case 225: /* cmd ::= DROP TOPIC exists_opt topic_name */ +{ pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy137, &yymsp[0].minor.yy209); } break; - case 227: /* cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ -{ pCxt->pRootNode = createDropCGroupStmt(pCxt, yymsp[-3].minor.yy603, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy53); } + case 226: /* cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ +{ pCxt->pRootNode = createDropCGroupStmt(pCxt, yymsp[-3].minor.yy137, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy209); } break; - case 228: /* topic_options ::= */ -{ yymsp[1].minor.yy636 = createTopicOptions(pCxt); } + case 227: /* topic_options ::= */ +{ yymsp[1].minor.yy632 = createTopicOptions(pCxt); } break; - case 229: /* topic_options ::= topic_options WITH TABLE */ -{ ((STopicOptions*)yymsp[-2].minor.yy636)->withTable = true; yylhsminor.yy636 = yymsp[-2].minor.yy636; } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 228: /* topic_options ::= topic_options WITH TABLE */ +{ ((STopicOptions*)yymsp[-2].minor.yy632)->withTable = true; yylhsminor.yy632 = yymsp[-2].minor.yy632; } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 230: /* topic_options ::= topic_options WITH SCHEMA */ -{ ((STopicOptions*)yymsp[-2].minor.yy636)->withSchema = true; yylhsminor.yy636 = yymsp[-2].minor.yy636; } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 229: /* topic_options ::= topic_options WITH SCHEMA */ +{ ((STopicOptions*)yymsp[-2].minor.yy632)->withSchema = true; yylhsminor.yy632 = yymsp[-2].minor.yy632; } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 231: /* topic_options ::= topic_options WITH TAG */ -{ ((STopicOptions*)yymsp[-2].minor.yy636)->withTag = true; yylhsminor.yy636 = yymsp[-2].minor.yy636; } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 230: /* topic_options ::= topic_options WITH TAG */ +{ ((STopicOptions*)yymsp[-2].minor.yy632)->withTag = true; yylhsminor.yy632 = yymsp[-2].minor.yy632; } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 232: /* cmd ::= DESC full_table_name */ - case 233: /* cmd ::= DESCRIBE full_table_name */ yytestcase(yyruleno==233); -{ pCxt->pRootNode = createDescribeStmt(pCxt, yymsp[0].minor.yy636); } + case 231: /* cmd ::= DESC full_table_name */ + case 232: /* cmd ::= DESCRIBE full_table_name */ yytestcase(yyruleno==232); +{ pCxt->pRootNode = createDescribeStmt(pCxt, yymsp[0].minor.yy632); } break; - case 234: /* cmd ::= RESET QUERY CACHE */ + case 233: /* cmd ::= RESET QUERY CACHE */ { pCxt->pRootNode = createResetQueryCacheStmt(pCxt); } break; - case 235: /* cmd ::= EXPLAIN analyze_opt explain_options query_expression */ -{ pCxt->pRootNode = createExplainStmt(pCxt, yymsp[-2].minor.yy603, yymsp[-1].minor.yy636, yymsp[0].minor.yy636); } + case 234: /* cmd ::= EXPLAIN analyze_opt explain_options query_expression */ +{ pCxt->pRootNode = createExplainStmt(pCxt, yymsp[-2].minor.yy137, yymsp[-1].minor.yy632, yymsp[0].minor.yy632); } break; - case 237: /* analyze_opt ::= ANALYZE */ - case 245: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==245); - case 393: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==393); -{ yymsp[0].minor.yy603 = true; } + case 236: /* analyze_opt ::= ANALYZE */ + case 244: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==244); + case 392: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==392); +{ yymsp[0].minor.yy137 = true; } break; - case 238: /* explain_options ::= */ -{ yymsp[1].minor.yy636 = createDefaultExplainOptions(pCxt); } + case 237: /* explain_options ::= */ +{ yymsp[1].minor.yy632 = createDefaultExplainOptions(pCxt); } break; - case 239: /* explain_options ::= explain_options VERBOSE NK_BOOL */ -{ yylhsminor.yy636 = setExplainVerbose(pCxt, yymsp[-2].minor.yy636, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 238: /* explain_options ::= explain_options VERBOSE NK_BOOL */ +{ yylhsminor.yy632 = setExplainVerbose(pCxt, yymsp[-2].minor.yy632, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 240: /* explain_options ::= explain_options RATIO NK_FLOAT */ -{ yylhsminor.yy636 = setExplainRatio(pCxt, yymsp[-2].minor.yy636, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 239: /* explain_options ::= explain_options RATIO NK_FLOAT */ +{ yylhsminor.yy632 = setExplainRatio(pCxt, yymsp[-2].minor.yy632, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 241: /* cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP */ -{ pCxt->pRootNode = createCompactStmt(pCxt, yymsp[-1].minor.yy236); } + case 240: /* cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP */ +{ pCxt->pRootNode = createCompactStmt(pCxt, yymsp[-1].minor.yy424); } break; - case 242: /* cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */ -{ pCxt->pRootNode = createCreateFunctionStmt(pCxt, yymsp[-6].minor.yy603, yymsp[-8].minor.yy603, &yymsp[-5].minor.yy53, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy450, yymsp[0].minor.yy158); } + case 241: /* cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */ +{ pCxt->pRootNode = createCreateFunctionStmt(pCxt, yymsp[-6].minor.yy137, yymsp[-8].minor.yy137, &yymsp[-5].minor.yy209, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy304, yymsp[0].minor.yy100); } break; - case 243: /* cmd ::= DROP FUNCTION exists_opt function_name */ -{ pCxt->pRootNode = createDropFunctionStmt(pCxt, yymsp[-1].minor.yy603, &yymsp[0].minor.yy53); } + case 242: /* cmd ::= DROP FUNCTION exists_opt function_name */ +{ pCxt->pRootNode = createDropFunctionStmt(pCxt, yymsp[-1].minor.yy137, &yymsp[0].minor.yy209); } break; - case 246: /* bufsize_opt ::= */ -{ yymsp[1].minor.yy158 = 0; } + case 245: /* bufsize_opt ::= */ +{ yymsp[1].minor.yy100 = 0; } break; - case 247: /* bufsize_opt ::= BUFSIZE NK_INTEGER */ -{ yymsp[-1].minor.yy158 = taosStr2Int32(yymsp[0].minor.yy0.z, NULL, 10); } + case 246: /* bufsize_opt ::= BUFSIZE NK_INTEGER */ +{ yymsp[-1].minor.yy100 = taosStr2Int32(yymsp[0].minor.yy0.z, NULL, 10); } break; - case 248: /* cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression */ -{ pCxt->pRootNode = createCreateStreamStmt(pCxt, yymsp[-5].minor.yy603, &yymsp[-4].minor.yy53, yymsp[-2].minor.yy636, yymsp[-3].minor.yy636, yymsp[0].minor.yy636); } + case 247: /* cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression */ +{ pCxt->pRootNode = createCreateStreamStmt(pCxt, yymsp[-5].minor.yy137, &yymsp[-4].minor.yy209, yymsp[-2].minor.yy632, yymsp[-3].minor.yy632, yymsp[0].minor.yy632); } break; - case 249: /* cmd ::= DROP STREAM exists_opt stream_name */ -{ pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy603, &yymsp[0].minor.yy53); } + case 248: /* cmd ::= DROP STREAM exists_opt stream_name */ +{ pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy137, &yymsp[0].minor.yy209); } break; - case 251: /* into_opt ::= INTO full_table_name */ - case 374: /* from_clause ::= FROM table_reference_list */ yytestcase(yyruleno==374); - case 404: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==404); - case 427: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==427); -{ yymsp[-1].minor.yy636 = yymsp[0].minor.yy636; } + case 250: /* into_opt ::= INTO full_table_name */ + case 373: /* from_clause ::= FROM table_reference_list */ yytestcase(yyruleno==373); + case 403: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==403); + case 426: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==426); +{ yymsp[-1].minor.yy632 = yymsp[0].minor.yy632; } break; - case 252: /* stream_options ::= */ -{ yymsp[1].minor.yy636 = createStreamOptions(pCxt); } + case 251: /* stream_options ::= */ +{ yymsp[1].minor.yy632 = createStreamOptions(pCxt); } break; - case 253: /* stream_options ::= stream_options TRIGGER AT_ONCE */ -{ ((SStreamOptions*)yymsp[-2].minor.yy636)->triggerType = STREAM_TRIGGER_AT_ONCE; yylhsminor.yy636 = yymsp[-2].minor.yy636; } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 252: /* stream_options ::= stream_options TRIGGER AT_ONCE */ +{ ((SStreamOptions*)yymsp[-2].minor.yy632)->triggerType = STREAM_TRIGGER_AT_ONCE; yylhsminor.yy632 = yymsp[-2].minor.yy632; } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 254: /* stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ -{ ((SStreamOptions*)yymsp[-2].minor.yy636)->triggerType = STREAM_TRIGGER_WINDOW_CLOSE; yylhsminor.yy636 = yymsp[-2].minor.yy636; } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 253: /* stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ +{ ((SStreamOptions*)yymsp[-2].minor.yy632)->triggerType = STREAM_TRIGGER_WINDOW_CLOSE; yylhsminor.yy632 = yymsp[-2].minor.yy632; } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 255: /* stream_options ::= stream_options WATERMARK duration_literal */ -{ ((SStreamOptions*)yymsp[-2].minor.yy636)->pWatermark = releaseRawExprNode(pCxt, yymsp[0].minor.yy636); yylhsminor.yy636 = yymsp[-2].minor.yy636; } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 254: /* stream_options ::= stream_options WATERMARK duration_literal */ +{ ((SStreamOptions*)yymsp[-2].minor.yy632)->pWatermark = releaseRawExprNode(pCxt, yymsp[0].minor.yy632); yylhsminor.yy632 = yymsp[-2].minor.yy632; } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 256: /* cmd ::= KILL CONNECTION NK_INTEGER */ + case 255: /* cmd ::= KILL CONNECTION NK_INTEGER */ { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_CONNECTION_STMT, &yymsp[0].minor.yy0); } break; - case 257: /* cmd ::= KILL QUERY NK_INTEGER */ + case 256: /* cmd ::= KILL QUERY NK_INTEGER */ { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_QUERY_STMT, &yymsp[0].minor.yy0); } break; - case 258: /* cmd ::= KILL TRANSACTION NK_INTEGER */ + case 257: /* cmd ::= KILL TRANSACTION NK_INTEGER */ { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_TRANSACTION_STMT, &yymsp[0].minor.yy0); } break; - case 259: /* cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ + case 258: /* cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ { pCxt->pRootNode = createMergeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } break; - case 260: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ -{ pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy236); } + case 259: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ +{ pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy424); } break; - case 261: /* cmd ::= SPLIT VGROUP NK_INTEGER */ + case 260: /* cmd ::= SPLIT VGROUP NK_INTEGER */ { pCxt->pRootNode = createSplitVgroupStmt(pCxt, &yymsp[0].minor.yy0); } break; - case 262: /* dnode_list ::= DNODE NK_INTEGER */ -{ yymsp[-1].minor.yy236 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } + case 261: /* dnode_list ::= DNODE NK_INTEGER */ +{ yymsp[-1].minor.yy424 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } break; - case 264: /* cmd ::= SYNCDB db_name REPLICA */ -{ pCxt->pRootNode = createSyncdbStmt(pCxt, &yymsp[-1].minor.yy53); } + case 263: /* cmd ::= SYNCDB db_name REPLICA */ +{ pCxt->pRootNode = createSyncdbStmt(pCxt, &yymsp[-1].minor.yy209); } break; - case 266: /* literal ::= NK_INTEGER */ -{ yylhsminor.yy636 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 265: /* literal ::= NK_INTEGER */ +{ yylhsminor.yy632 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; - case 267: /* literal ::= NK_FLOAT */ -{ yylhsminor.yy636 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 266: /* literal ::= NK_FLOAT */ +{ yylhsminor.yy632 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; - case 268: /* literal ::= NK_STRING */ -{ yylhsminor.yy636 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 267: /* literal ::= NK_STRING */ +{ yylhsminor.yy632 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; - case 269: /* literal ::= NK_BOOL */ -{ yylhsminor.yy636 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 268: /* literal ::= NK_BOOL */ +{ yylhsminor.yy632 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; - case 270: /* literal ::= TIMESTAMP NK_STRING */ -{ yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; + case 269: /* literal ::= TIMESTAMP NK_STRING */ +{ yylhsminor.yy632 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); } + yymsp[-1].minor.yy632 = yylhsminor.yy632; break; - case 271: /* literal ::= duration_literal */ - case 281: /* signed_literal ::= signed */ yytestcase(yyruleno==281); - case 301: /* expression ::= literal */ yytestcase(yyruleno==301); - case 302: /* expression ::= pseudo_column */ yytestcase(yyruleno==302); - case 303: /* expression ::= column_reference */ yytestcase(yyruleno==303); - case 304: /* expression ::= function_expression */ yytestcase(yyruleno==304); - case 305: /* expression ::= subquery */ yytestcase(yyruleno==305); - case 330: /* function_expression ::= literal_func */ yytestcase(yyruleno==330); - case 366: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==366); - case 370: /* boolean_primary ::= predicate */ yytestcase(yyruleno==370); - case 372: /* common_expression ::= expression */ yytestcase(yyruleno==372); - case 373: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==373); - case 375: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==375); - case 377: /* table_reference ::= table_primary */ yytestcase(yyruleno==377); - case 378: /* table_reference ::= joined_table */ yytestcase(yyruleno==378); - case 382: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==382); - case 429: /* query_expression_body ::= query_primary */ yytestcase(yyruleno==429); - case 432: /* query_primary ::= query_specification */ yytestcase(yyruleno==432); -{ yylhsminor.yy636 = yymsp[0].minor.yy636; } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 270: /* literal ::= duration_literal */ + case 280: /* signed_literal ::= signed */ yytestcase(yyruleno==280); + case 300: /* expression ::= literal */ yytestcase(yyruleno==300); + case 301: /* expression ::= pseudo_column */ yytestcase(yyruleno==301); + case 302: /* expression ::= column_reference */ yytestcase(yyruleno==302); + case 303: /* expression ::= function_expression */ yytestcase(yyruleno==303); + case 304: /* expression ::= subquery */ yytestcase(yyruleno==304); + case 329: /* function_expression ::= literal_func */ yytestcase(yyruleno==329); + case 365: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==365); + case 369: /* boolean_primary ::= predicate */ yytestcase(yyruleno==369); + case 371: /* common_expression ::= expression */ yytestcase(yyruleno==371); + case 372: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==372); + case 374: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==374); + case 376: /* table_reference ::= table_primary */ yytestcase(yyruleno==376); + case 377: /* table_reference ::= joined_table */ yytestcase(yyruleno==377); + case 381: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==381); + case 428: /* query_expression_body ::= query_primary */ yytestcase(yyruleno==428); + case 431: /* query_primary ::= query_specification */ yytestcase(yyruleno==431); +{ yylhsminor.yy632 = yymsp[0].minor.yy632; } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; - case 272: /* literal ::= NULL */ -{ yylhsminor.yy636 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 271: /* literal ::= NULL */ +{ yylhsminor.yy632 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; - case 273: /* literal ::= NK_QUESTION */ -{ yylhsminor.yy636 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 272: /* literal ::= NK_QUESTION */ +{ yylhsminor.yy632 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; - case 274: /* duration_literal ::= NK_VARIABLE */ -{ yylhsminor.yy636 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 273: /* duration_literal ::= NK_VARIABLE */ +{ yylhsminor.yy632 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; - case 275: /* signed ::= NK_INTEGER */ -{ yylhsminor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 274: /* signed ::= NK_INTEGER */ +{ yylhsminor.yy632 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; - case 276: /* signed ::= NK_PLUS NK_INTEGER */ -{ yymsp[-1].minor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); } + case 275: /* signed ::= NK_PLUS NK_INTEGER */ +{ yymsp[-1].minor.yy632 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); } break; - case 277: /* signed ::= NK_MINUS NK_INTEGER */ + case 276: /* signed ::= NK_MINUS NK_INTEGER */ { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &t); + yylhsminor.yy632 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &t); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; + yymsp[-1].minor.yy632 = yylhsminor.yy632; break; - case 278: /* signed ::= NK_FLOAT */ -{ yylhsminor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 277: /* signed ::= NK_FLOAT */ +{ yylhsminor.yy632 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; - case 279: /* signed ::= NK_PLUS NK_FLOAT */ -{ yymsp[-1].minor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } + case 278: /* signed ::= NK_PLUS NK_FLOAT */ +{ yymsp[-1].minor.yy632 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } break; - case 280: /* signed ::= NK_MINUS NK_FLOAT */ + case 279: /* signed ::= NK_MINUS NK_FLOAT */ { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t); + yylhsminor.yy632 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; + yymsp[-1].minor.yy632 = yylhsminor.yy632; break; - case 282: /* signed_literal ::= NK_STRING */ -{ yylhsminor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 281: /* signed_literal ::= NK_STRING */ +{ yylhsminor.yy632 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; - case 283: /* signed_literal ::= NK_BOOL */ -{ yylhsminor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 282: /* signed_literal ::= NK_BOOL */ +{ yylhsminor.yy632 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; - case 284: /* signed_literal ::= TIMESTAMP NK_STRING */ -{ yymsp[-1].minor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } + case 283: /* signed_literal ::= TIMESTAMP NK_STRING */ +{ yymsp[-1].minor.yy632 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } break; - case 285: /* signed_literal ::= duration_literal */ - case 287: /* signed_literal ::= literal_func */ yytestcase(yyruleno==287); - case 344: /* star_func_para ::= expression */ yytestcase(yyruleno==344); - case 399: /* select_item ::= common_expression */ yytestcase(yyruleno==399); - case 445: /* search_condition ::= common_expression */ yytestcase(yyruleno==445); -{ yylhsminor.yy636 = releaseRawExprNode(pCxt, yymsp[0].minor.yy636); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 284: /* signed_literal ::= duration_literal */ + case 286: /* signed_literal ::= literal_func */ yytestcase(yyruleno==286); + case 343: /* star_func_para ::= expression */ yytestcase(yyruleno==343); + case 398: /* select_item ::= common_expression */ yytestcase(yyruleno==398); + case 444: /* search_condition ::= common_expression */ yytestcase(yyruleno==444); +{ yylhsminor.yy632 = releaseRawExprNode(pCxt, yymsp[0].minor.yy632); } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; - case 286: /* signed_literal ::= NULL */ -{ yylhsminor.yy636 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 285: /* signed_literal ::= NULL */ +{ yylhsminor.yy632 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; - case 306: /* expression ::= NK_LP expression NK_RP */ - case 371: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==371); -{ yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy636)); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 305: /* expression ::= NK_LP expression NK_RP */ + case 370: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==370); +{ yylhsminor.yy632 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy632)); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 307: /* expression ::= NK_PLUS expression */ + case 306: /* expression ::= NK_PLUS expression */ { - SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy636)); + SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy632); + yylhsminor.yy632 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy632)); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; + yymsp[-1].minor.yy632 = yylhsminor.yy632; break; - case 308: /* expression ::= NK_MINUS expression */ + case 307: /* expression ::= NK_MINUS expression */ { - SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy636), NULL)); + SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy632); + yylhsminor.yy632 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy632), NULL)); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; + yymsp[-1].minor.yy632 = yylhsminor.yy632; break; - case 309: /* expression ::= expression NK_PLUS expression */ + case 308: /* expression ::= expression NK_PLUS expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy636); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_ADD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy632); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy632); + yylhsminor.yy632 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_ADD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy632), releaseRawExprNode(pCxt, yymsp[0].minor.yy632))); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 310: /* expression ::= expression NK_MINUS expression */ + case 309: /* expression ::= expression NK_MINUS expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy636); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_SUB, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy632); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy632); + yylhsminor.yy632 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_SUB, releaseRawExprNode(pCxt, yymsp[-2].minor.yy632), releaseRawExprNode(pCxt, yymsp[0].minor.yy632))); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 311: /* expression ::= expression NK_STAR expression */ + case 310: /* expression ::= expression NK_STAR expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy636); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MULTI, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy632); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy632); + yylhsminor.yy632 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MULTI, releaseRawExprNode(pCxt, yymsp[-2].minor.yy632), releaseRawExprNode(pCxt, yymsp[0].minor.yy632))); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 312: /* expression ::= expression NK_SLASH expression */ + case 311: /* expression ::= expression NK_SLASH expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy636); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_DIV, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy632); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy632); + yylhsminor.yy632 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_DIV, releaseRawExprNode(pCxt, yymsp[-2].minor.yy632), releaseRawExprNode(pCxt, yymsp[0].minor.yy632))); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 313: /* expression ::= expression NK_REM expression */ + case 312: /* expression ::= expression NK_REM expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy636); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MOD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy632); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy632); + yylhsminor.yy632 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MOD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy632), releaseRawExprNode(pCxt, yymsp[0].minor.yy632))); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 314: /* expression ::= column_reference NK_ARROW NK_STRING */ + case 313: /* expression ::= column_reference NK_ARROW NK_STRING */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy632); + yylhsminor.yy632 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy632), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0))); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 315: /* expression_list ::= expression */ -{ yylhsminor.yy236 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy636)); } - yymsp[0].minor.yy236 = yylhsminor.yy236; + case 314: /* expression_list ::= expression */ +{ yylhsminor.yy424 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy632)); } + yymsp[0].minor.yy424 = yylhsminor.yy424; break; - case 316: /* expression_list ::= expression_list NK_COMMA expression */ -{ yylhsminor.yy236 = addNodeToList(pCxt, yymsp[-2].minor.yy236, releaseRawExprNode(pCxt, yymsp[0].minor.yy636)); } - yymsp[-2].minor.yy236 = yylhsminor.yy236; + case 315: /* expression_list ::= expression_list NK_COMMA expression */ +{ yylhsminor.yy424 = addNodeToList(pCxt, yymsp[-2].minor.yy424, releaseRawExprNode(pCxt, yymsp[0].minor.yy632)); } + yymsp[-2].minor.yy424 = yylhsminor.yy424; break; - case 317: /* column_reference ::= column_name */ -{ yylhsminor.yy636 = createRawExprNode(pCxt, &yymsp[0].minor.yy53, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy53)); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 316: /* column_reference ::= column_name */ +{ yylhsminor.yy632 = createRawExprNode(pCxt, &yymsp[0].minor.yy209, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy209)); } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; - case 318: /* column_reference ::= table_name NK_DOT column_name */ -{ yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy53, createColumnNode(pCxt, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy53)); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 317: /* column_reference ::= table_name NK_DOT column_name */ +{ yylhsminor.yy632 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy209, createColumnNode(pCxt, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy209)); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 319: /* pseudo_column ::= ROWTS */ - case 320: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==320); - case 322: /* pseudo_column ::= QSTARTTS */ yytestcase(yyruleno==322); - case 323: /* pseudo_column ::= QENDTS */ yytestcase(yyruleno==323); - case 324: /* pseudo_column ::= WSTARTTS */ yytestcase(yyruleno==324); - case 325: /* pseudo_column ::= WENDTS */ yytestcase(yyruleno==325); - case 326: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==326); - case 332: /* literal_func ::= NOW */ yytestcase(yyruleno==332); -{ yylhsminor.yy636 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); } - yymsp[0].minor.yy636 = yylhsminor.yy636; + case 318: /* pseudo_column ::= ROWTS */ + case 319: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==319); + case 321: /* pseudo_column ::= QSTARTTS */ yytestcase(yyruleno==321); + case 322: /* pseudo_column ::= QENDTS */ yytestcase(yyruleno==322); + case 323: /* pseudo_column ::= WSTARTTS */ yytestcase(yyruleno==323); + case 324: /* pseudo_column ::= WENDTS */ yytestcase(yyruleno==324); + case 325: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==325); + case 331: /* literal_func ::= NOW */ yytestcase(yyruleno==331); +{ yylhsminor.yy632 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); } + yymsp[0].minor.yy632 = yylhsminor.yy632; break; - case 321: /* pseudo_column ::= table_name NK_DOT TBNAME */ -{ yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy53)))); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 320: /* pseudo_column ::= table_name NK_DOT TBNAME */ +{ yylhsminor.yy632 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy209)))); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 327: /* function_expression ::= function_name NK_LP expression_list NK_RP */ - case 328: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==328); -{ yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy53, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy53, yymsp[-1].minor.yy236)); } - yymsp[-3].minor.yy636 = yylhsminor.yy636; + case 326: /* function_expression ::= function_name NK_LP expression_list NK_RP */ + case 327: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==327); +{ yylhsminor.yy632 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy209, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy209, yymsp[-1].minor.yy424)); } + yymsp[-3].minor.yy632 = yylhsminor.yy632; break; - case 329: /* function_expression ::= CAST NK_LP expression AS type_name NK_RP */ -{ yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy636), yymsp[-1].minor.yy450)); } - yymsp[-5].minor.yy636 = yylhsminor.yy636; + case 328: /* function_expression ::= CAST NK_LP expression AS type_name NK_RP */ +{ yylhsminor.yy632 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy632), yymsp[-1].minor.yy304)); } + yymsp[-5].minor.yy632 = yylhsminor.yy632; break; - case 331: /* literal_func ::= noarg_func NK_LP NK_RP */ -{ yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy53, NULL)); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 330: /* literal_func ::= noarg_func NK_LP NK_RP */ +{ yylhsminor.yy632 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy209, NULL)); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 340: /* star_func_para_list ::= NK_STAR */ -{ yylhsminor.yy236 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy236 = yylhsminor.yy236; + case 339: /* star_func_para_list ::= NK_STAR */ +{ yylhsminor.yy424 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy424 = yylhsminor.yy424; break; - case 345: /* star_func_para ::= table_name NK_DOT NK_STAR */ - case 402: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==402); -{ yylhsminor.yy636 = createColumnNode(pCxt, &yymsp[-2].minor.yy53, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 344: /* star_func_para ::= table_name NK_DOT NK_STAR */ + case 401: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==401); +{ yylhsminor.yy632 = createColumnNode(pCxt, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 346: /* predicate ::= expression compare_op expression */ - case 351: /* predicate ::= expression in_op in_predicate_value */ yytestcase(yyruleno==351); + case 345: /* predicate ::= expression compare_op expression */ + case 350: /* predicate ::= expression in_op in_predicate_value */ yytestcase(yyruleno==350); { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy636); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, yymsp[-1].minor.yy136, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy632); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy632); + yylhsminor.yy632 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, yymsp[-1].minor.yy380, releaseRawExprNode(pCxt, yymsp[-2].minor.yy632), releaseRawExprNode(pCxt, yymsp[0].minor.yy632))); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 347: /* predicate ::= expression BETWEEN expression AND expression */ + case 346: /* predicate ::= expression BETWEEN expression AND expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy636); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &e, createBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-4].minor.yy636), releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy632); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy632); + yylhsminor.yy632 = createRawExprNodeExt(pCxt, &s, &e, createBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-4].minor.yy632), releaseRawExprNode(pCxt, yymsp[-2].minor.yy632), releaseRawExprNode(pCxt, yymsp[0].minor.yy632))); } - yymsp[-4].minor.yy636 = yylhsminor.yy636; + yymsp[-4].minor.yy632 = yylhsminor.yy632; break; - case 348: /* predicate ::= expression NOT BETWEEN expression AND expression */ + case 347: /* predicate ::= expression NOT BETWEEN expression AND expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy636); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &e, createNotBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy636), releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy632); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy632); + yylhsminor.yy632 = createRawExprNodeExt(pCxt, &s, &e, createNotBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy632), releaseRawExprNode(pCxt, yymsp[-2].minor.yy632), releaseRawExprNode(pCxt, yymsp[0].minor.yy632))); } - yymsp[-5].minor.yy636 = yylhsminor.yy636; + yymsp[-5].minor.yy632 = yylhsminor.yy632; break; - case 349: /* predicate ::= expression IS NULL */ + case 348: /* predicate ::= expression IS NULL */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), NULL)); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy632); + yylhsminor.yy632 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy632), NULL)); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 350: /* predicate ::= expression IS NOT NULL */ + case 349: /* predicate ::= expression IS NOT NULL */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy636), NULL)); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy632); + yylhsminor.yy632 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy632), NULL)); } - yymsp[-3].minor.yy636 = yylhsminor.yy636; + yymsp[-3].minor.yy632 = yylhsminor.yy632; break; - case 352: /* compare_op ::= NK_LT */ -{ yymsp[0].minor.yy136 = OP_TYPE_LOWER_THAN; } + case 351: /* compare_op ::= NK_LT */ +{ yymsp[0].minor.yy380 = OP_TYPE_LOWER_THAN; } break; - case 353: /* compare_op ::= NK_GT */ -{ yymsp[0].minor.yy136 = OP_TYPE_GREATER_THAN; } + case 352: /* compare_op ::= NK_GT */ +{ yymsp[0].minor.yy380 = OP_TYPE_GREATER_THAN; } break; - case 354: /* compare_op ::= NK_LE */ -{ yymsp[0].minor.yy136 = OP_TYPE_LOWER_EQUAL; } + case 353: /* compare_op ::= NK_LE */ +{ yymsp[0].minor.yy380 = OP_TYPE_LOWER_EQUAL; } break; - case 355: /* compare_op ::= NK_GE */ -{ yymsp[0].minor.yy136 = OP_TYPE_GREATER_EQUAL; } + case 354: /* compare_op ::= NK_GE */ +{ yymsp[0].minor.yy380 = OP_TYPE_GREATER_EQUAL; } break; - case 356: /* compare_op ::= NK_NE */ -{ yymsp[0].minor.yy136 = OP_TYPE_NOT_EQUAL; } + case 355: /* compare_op ::= NK_NE */ +{ yymsp[0].minor.yy380 = OP_TYPE_NOT_EQUAL; } break; - case 357: /* compare_op ::= NK_EQ */ -{ yymsp[0].minor.yy136 = OP_TYPE_EQUAL; } + case 356: /* compare_op ::= NK_EQ */ +{ yymsp[0].minor.yy380 = OP_TYPE_EQUAL; } break; - case 358: /* compare_op ::= LIKE */ -{ yymsp[0].minor.yy136 = OP_TYPE_LIKE; } + case 357: /* compare_op ::= LIKE */ +{ yymsp[0].minor.yy380 = OP_TYPE_LIKE; } break; - case 359: /* compare_op ::= NOT LIKE */ -{ yymsp[-1].minor.yy136 = OP_TYPE_NOT_LIKE; } + case 358: /* compare_op ::= NOT LIKE */ +{ yymsp[-1].minor.yy380 = OP_TYPE_NOT_LIKE; } break; - case 360: /* compare_op ::= MATCH */ -{ yymsp[0].minor.yy136 = OP_TYPE_MATCH; } + case 359: /* compare_op ::= MATCH */ +{ yymsp[0].minor.yy380 = OP_TYPE_MATCH; } break; - case 361: /* compare_op ::= NMATCH */ -{ yymsp[0].minor.yy136 = OP_TYPE_NMATCH; } + case 360: /* compare_op ::= NMATCH */ +{ yymsp[0].minor.yy380 = OP_TYPE_NMATCH; } break; - case 362: /* compare_op ::= CONTAINS */ -{ yymsp[0].minor.yy136 = OP_TYPE_JSON_CONTAINS; } + case 361: /* compare_op ::= CONTAINS */ +{ yymsp[0].minor.yy380 = OP_TYPE_JSON_CONTAINS; } break; - case 363: /* in_op ::= IN */ -{ yymsp[0].minor.yy136 = OP_TYPE_IN; } + case 362: /* in_op ::= IN */ +{ yymsp[0].minor.yy380 = OP_TYPE_IN; } break; - case 364: /* in_op ::= NOT IN */ -{ yymsp[-1].minor.yy136 = OP_TYPE_NOT_IN; } + case 363: /* in_op ::= NOT IN */ +{ yymsp[-1].minor.yy380 = OP_TYPE_NOT_IN; } break; - case 365: /* in_predicate_value ::= NK_LP expression_list NK_RP */ -{ yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy236)); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 364: /* in_predicate_value ::= NK_LP expression_list NK_RP */ +{ yylhsminor.yy632 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy424)); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 367: /* boolean_value_expression ::= NOT boolean_primary */ + case 366: /* boolean_value_expression ::= NOT boolean_primary */ { - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy636), NULL)); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy632); + yylhsminor.yy632 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy632), NULL)); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; + yymsp[-1].minor.yy632 = yylhsminor.yy632; break; - case 368: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ + case 367: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy636); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy632); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy632); + yylhsminor.yy632 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy632), releaseRawExprNode(pCxt, yymsp[0].minor.yy632))); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 369: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ + case 368: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy636); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy636); - yylhsminor.yy636 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy632); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy632); + yylhsminor.yy632 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy632), releaseRawExprNode(pCxt, yymsp[0].minor.yy632))); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 376: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */ -{ yylhsminor.yy636 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy636, yymsp[0].minor.yy636, NULL); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 375: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */ +{ yylhsminor.yy632 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy632, yymsp[0].minor.yy632, NULL); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 379: /* table_primary ::= table_name alias_opt */ -{ yylhsminor.yy636 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy53, &yymsp[0].minor.yy53); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; + case 378: /* table_primary ::= table_name alias_opt */ +{ yylhsminor.yy632 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy209, &yymsp[0].minor.yy209); } + yymsp[-1].minor.yy632 = yylhsminor.yy632; break; - case 380: /* table_primary ::= db_name NK_DOT table_name alias_opt */ -{ yylhsminor.yy636 = createRealTableNode(pCxt, &yymsp[-3].minor.yy53, &yymsp[-1].minor.yy53, &yymsp[0].minor.yy53); } - yymsp[-3].minor.yy636 = yylhsminor.yy636; + case 379: /* table_primary ::= db_name NK_DOT table_name alias_opt */ +{ yylhsminor.yy632 = createRealTableNode(pCxt, &yymsp[-3].minor.yy209, &yymsp[-1].minor.yy209, &yymsp[0].minor.yy209); } + yymsp[-3].minor.yy632 = yylhsminor.yy632; break; - case 381: /* table_primary ::= subquery alias_opt */ -{ yylhsminor.yy636 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy636), &yymsp[0].minor.yy53); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; + case 380: /* table_primary ::= subquery alias_opt */ +{ yylhsminor.yy632 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy632), &yymsp[0].minor.yy209); } + yymsp[-1].minor.yy632 = yylhsminor.yy632; break; - case 383: /* alias_opt ::= */ -{ yymsp[1].minor.yy53 = nil_token; } + case 382: /* alias_opt ::= */ +{ yymsp[1].minor.yy209 = nil_token; } break; - case 384: /* alias_opt ::= table_alias */ -{ yylhsminor.yy53 = yymsp[0].minor.yy53; } - yymsp[0].minor.yy53 = yylhsminor.yy53; + case 383: /* alias_opt ::= table_alias */ +{ yylhsminor.yy209 = yymsp[0].minor.yy209; } + yymsp[0].minor.yy209 = yylhsminor.yy209; break; - case 385: /* alias_opt ::= AS table_alias */ -{ yymsp[-1].minor.yy53 = yymsp[0].minor.yy53; } + case 384: /* alias_opt ::= AS table_alias */ +{ yymsp[-1].minor.yy209 = yymsp[0].minor.yy209; } break; - case 386: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - case 387: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==387); -{ yymsp[-2].minor.yy636 = yymsp[-1].minor.yy636; } + case 385: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */ + case 386: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==386); +{ yymsp[-2].minor.yy632 = yymsp[-1].minor.yy632; } break; - case 388: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ -{ yylhsminor.yy636 = createJoinTableNode(pCxt, yymsp[-4].minor.yy342, yymsp[-5].minor.yy636, yymsp[-2].minor.yy636, yymsp[0].minor.yy636); } - yymsp[-5].minor.yy636 = yylhsminor.yy636; + case 387: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ +{ yylhsminor.yy632 = createJoinTableNode(pCxt, yymsp[-4].minor.yy612, yymsp[-5].minor.yy632, yymsp[-2].minor.yy632, yymsp[0].minor.yy632); } + yymsp[-5].minor.yy632 = yylhsminor.yy632; break; - case 389: /* join_type ::= */ -{ yymsp[1].minor.yy342 = JOIN_TYPE_INNER; } + case 388: /* join_type ::= */ +{ yymsp[1].minor.yy612 = JOIN_TYPE_INNER; } break; - case 390: /* join_type ::= INNER */ -{ yymsp[0].minor.yy342 = JOIN_TYPE_INNER; } + case 389: /* join_type ::= INNER */ +{ yymsp[0].minor.yy612 = JOIN_TYPE_INNER; } break; - case 391: /* query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ + case 390: /* query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ { - yymsp[-8].minor.yy636 = createSelectStmt(pCxt, yymsp[-7].minor.yy603, yymsp[-6].minor.yy236, yymsp[-5].minor.yy636); - yymsp[-8].minor.yy636 = addWhereClause(pCxt, yymsp[-8].minor.yy636, yymsp[-4].minor.yy636); - yymsp[-8].minor.yy636 = addPartitionByClause(pCxt, yymsp[-8].minor.yy636, yymsp[-3].minor.yy236); - yymsp[-8].minor.yy636 = addWindowClauseClause(pCxt, yymsp[-8].minor.yy636, yymsp[-2].minor.yy636); - yymsp[-8].minor.yy636 = addGroupByClause(pCxt, yymsp[-8].minor.yy636, yymsp[-1].minor.yy236); - yymsp[-8].minor.yy636 = addHavingClause(pCxt, yymsp[-8].minor.yy636, yymsp[0].minor.yy636); + yymsp[-8].minor.yy632 = createSelectStmt(pCxt, yymsp[-7].minor.yy137, yymsp[-6].minor.yy424, yymsp[-5].minor.yy632); + yymsp[-8].minor.yy632 = addWhereClause(pCxt, yymsp[-8].minor.yy632, yymsp[-4].minor.yy632); + yymsp[-8].minor.yy632 = addPartitionByClause(pCxt, yymsp[-8].minor.yy632, yymsp[-3].minor.yy424); + yymsp[-8].minor.yy632 = addWindowClauseClause(pCxt, yymsp[-8].minor.yy632, yymsp[-2].minor.yy632); + yymsp[-8].minor.yy632 = addGroupByClause(pCxt, yymsp[-8].minor.yy632, yymsp[-1].minor.yy424); + yymsp[-8].minor.yy632 = addHavingClause(pCxt, yymsp[-8].minor.yy632, yymsp[0].minor.yy632); } break; - case 394: /* set_quantifier_opt ::= ALL */ -{ yymsp[0].minor.yy603 = false; } + case 393: /* set_quantifier_opt ::= ALL */ +{ yymsp[0].minor.yy137 = false; } break; - case 395: /* select_list ::= NK_STAR */ -{ yymsp[0].minor.yy236 = NULL; } + case 394: /* select_list ::= NK_STAR */ +{ yymsp[0].minor.yy424 = NULL; } break; - case 400: /* select_item ::= common_expression column_alias */ -{ yylhsminor.yy636 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy636), &yymsp[0].minor.yy53); } - yymsp[-1].minor.yy636 = yylhsminor.yy636; + case 399: /* select_item ::= common_expression column_alias */ +{ yylhsminor.yy632 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy632), &yymsp[0].minor.yy209); } + yymsp[-1].minor.yy632 = yylhsminor.yy632; break; - case 401: /* select_item ::= common_expression AS column_alias */ -{ yylhsminor.yy636 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), &yymsp[0].minor.yy53); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 400: /* select_item ::= common_expression AS column_alias */ +{ yylhsminor.yy632 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy632), &yymsp[0].minor.yy209); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 406: /* partition_by_clause_opt ::= PARTITION BY expression_list */ - case 423: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==423); - case 435: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==435); -{ yymsp[-2].minor.yy236 = yymsp[0].minor.yy236; } + case 405: /* partition_by_clause_opt ::= PARTITION BY expression_list */ + case 422: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==422); + case 434: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==434); +{ yymsp[-2].minor.yy424 = yymsp[0].minor.yy424; } break; - case 408: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ -{ yymsp[-5].minor.yy636 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy636), releaseRawExprNode(pCxt, yymsp[-1].minor.yy636)); } + case 407: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ +{ yymsp[-5].minor.yy632 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy632), releaseRawExprNode(pCxt, yymsp[-1].minor.yy632)); } break; - case 409: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */ -{ yymsp[-3].minor.yy636 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy636)); } + case 408: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */ +{ yymsp[-3].minor.yy632 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy632)); } break; - case 410: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ -{ yymsp[-5].minor.yy636 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy636), NULL, yymsp[-1].minor.yy636, yymsp[0].minor.yy636); } + case 409: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ +{ yymsp[-5].minor.yy632 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy632), NULL, yymsp[-1].minor.yy632, yymsp[0].minor.yy632); } break; - case 411: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ -{ yymsp[-7].minor.yy636 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy636), releaseRawExprNode(pCxt, yymsp[-3].minor.yy636), yymsp[-1].minor.yy636, yymsp[0].minor.yy636); } + case 410: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ +{ yymsp[-7].minor.yy632 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy632), releaseRawExprNode(pCxt, yymsp[-3].minor.yy632), yymsp[-1].minor.yy632, yymsp[0].minor.yy632); } break; - case 413: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ -{ yymsp[-3].minor.yy636 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy636); } + case 412: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ +{ yymsp[-3].minor.yy632 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy632); } break; - case 415: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ -{ yymsp[-3].minor.yy636 = createFillNode(pCxt, yymsp[-1].minor.yy18, NULL); } + case 414: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ +{ yymsp[-3].minor.yy632 = createFillNode(pCxt, yymsp[-1].minor.yy54, NULL); } break; - case 416: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ -{ yymsp[-5].minor.yy636 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy236)); } + case 415: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ +{ yymsp[-5].minor.yy632 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy424)); } break; - case 417: /* fill_mode ::= NONE */ -{ yymsp[0].minor.yy18 = FILL_MODE_NONE; } + case 416: /* fill_mode ::= NONE */ +{ yymsp[0].minor.yy54 = FILL_MODE_NONE; } break; - case 418: /* fill_mode ::= PREV */ -{ yymsp[0].minor.yy18 = FILL_MODE_PREV; } + case 417: /* fill_mode ::= PREV */ +{ yymsp[0].minor.yy54 = FILL_MODE_PREV; } break; - case 419: /* fill_mode ::= NULL */ -{ yymsp[0].minor.yy18 = FILL_MODE_NULL; } + case 418: /* fill_mode ::= NULL */ +{ yymsp[0].minor.yy54 = FILL_MODE_NULL; } break; - case 420: /* fill_mode ::= LINEAR */ -{ yymsp[0].minor.yy18 = FILL_MODE_LINEAR; } + case 419: /* fill_mode ::= LINEAR */ +{ yymsp[0].minor.yy54 = FILL_MODE_LINEAR; } break; - case 421: /* fill_mode ::= NEXT */ -{ yymsp[0].minor.yy18 = FILL_MODE_NEXT; } + case 420: /* fill_mode ::= NEXT */ +{ yymsp[0].minor.yy54 = FILL_MODE_NEXT; } break; - case 424: /* group_by_list ::= expression */ -{ yylhsminor.yy236 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); } - yymsp[0].minor.yy236 = yylhsminor.yy236; + case 423: /* group_by_list ::= expression */ +{ yylhsminor.yy424 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy632))); } + yymsp[0].minor.yy424 = yylhsminor.yy424; break; - case 425: /* group_by_list ::= group_by_list NK_COMMA expression */ -{ yylhsminor.yy236 = addNodeToList(pCxt, yymsp[-2].minor.yy236, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy636))); } - yymsp[-2].minor.yy236 = yylhsminor.yy236; + case 424: /* group_by_list ::= group_by_list NK_COMMA expression */ +{ yylhsminor.yy424 = addNodeToList(pCxt, yymsp[-2].minor.yy424, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy632))); } + yymsp[-2].minor.yy424 = yylhsminor.yy424; break; - case 428: /* query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ + case 427: /* query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ { - yylhsminor.yy636 = addOrderByClause(pCxt, yymsp[-3].minor.yy636, yymsp[-2].minor.yy236); - yylhsminor.yy636 = addSlimitClause(pCxt, yylhsminor.yy636, yymsp[-1].minor.yy636); - yylhsminor.yy636 = addLimitClause(pCxt, yylhsminor.yy636, yymsp[0].minor.yy636); + yylhsminor.yy632 = addOrderByClause(pCxt, yymsp[-3].minor.yy632, yymsp[-2].minor.yy424); + yylhsminor.yy632 = addSlimitClause(pCxt, yylhsminor.yy632, yymsp[-1].minor.yy632); + yylhsminor.yy632 = addLimitClause(pCxt, yylhsminor.yy632, yymsp[0].minor.yy632); } - yymsp[-3].minor.yy636 = yylhsminor.yy636; + yymsp[-3].minor.yy632 = yylhsminor.yy632; break; - case 430: /* query_expression_body ::= query_expression_body UNION ALL query_expression_body */ -{ yylhsminor.yy636 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy636, yymsp[0].minor.yy636); } - yymsp[-3].minor.yy636 = yylhsminor.yy636; + case 429: /* query_expression_body ::= query_expression_body UNION ALL query_expression_body */ +{ yylhsminor.yy632 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy632, yymsp[0].minor.yy632); } + yymsp[-3].minor.yy632 = yylhsminor.yy632; break; - case 431: /* query_expression_body ::= query_expression_body UNION query_expression_body */ -{ yylhsminor.yy636 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy636, yymsp[0].minor.yy636); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 430: /* query_expression_body ::= query_expression_body UNION query_expression_body */ +{ yylhsminor.yy632 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy632, yymsp[0].minor.yy632); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 433: /* query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */ -{ yymsp[-5].minor.yy636 = yymsp[-4].minor.yy636; } - yy_destructor(yypParser,353,&yymsp[-3].minor); - yy_destructor(yypParser,354,&yymsp[-2].minor); - yy_destructor(yypParser,355,&yymsp[-1].minor); + case 432: /* query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */ +{ yymsp[-5].minor.yy632 = yymsp[-4].minor.yy632; } + yy_destructor(yypParser,352,&yymsp[-3].minor); + yy_destructor(yypParser,353,&yymsp[-2].minor); + yy_destructor(yypParser,354,&yymsp[-1].minor); break; - case 437: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ - case 441: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==441); -{ yymsp[-1].minor.yy636 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); } + case 436: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ + case 440: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==440); +{ yymsp[-1].minor.yy632 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); } break; - case 438: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - case 442: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==442); -{ yymsp[-3].minor.yy636 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } + case 437: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + case 441: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==441); +{ yymsp[-3].minor.yy632 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } break; - case 439: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - case 443: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==443); -{ yymsp[-3].minor.yy636 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); } + case 438: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + case 442: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==442); +{ yymsp[-3].minor.yy632 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); } break; - case 444: /* subquery ::= NK_LP query_expression NK_RP */ -{ yylhsminor.yy636 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy636); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 443: /* subquery ::= NK_LP query_expression NK_RP */ +{ yylhsminor.yy632 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy632); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 448: /* sort_specification ::= expression ordering_specification_opt null_ordering_opt */ -{ yylhsminor.yy636 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy636), yymsp[-1].minor.yy430, yymsp[0].minor.yy185); } - yymsp[-2].minor.yy636 = yylhsminor.yy636; + case 447: /* sort_specification ::= expression ordering_specification_opt null_ordering_opt */ +{ yylhsminor.yy632 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy632), yymsp[-1].minor.yy578, yymsp[0].minor.yy217); } + yymsp[-2].minor.yy632 = yylhsminor.yy632; break; - case 449: /* ordering_specification_opt ::= */ -{ yymsp[1].minor.yy430 = ORDER_ASC; } + case 448: /* ordering_specification_opt ::= */ +{ yymsp[1].minor.yy578 = ORDER_ASC; } break; - case 450: /* ordering_specification_opt ::= ASC */ -{ yymsp[0].minor.yy430 = ORDER_ASC; } + case 449: /* ordering_specification_opt ::= ASC */ +{ yymsp[0].minor.yy578 = ORDER_ASC; } break; - case 451: /* ordering_specification_opt ::= DESC */ -{ yymsp[0].minor.yy430 = ORDER_DESC; } + case 450: /* ordering_specification_opt ::= DESC */ +{ yymsp[0].minor.yy578 = ORDER_DESC; } break; - case 452: /* null_ordering_opt ::= */ -{ yymsp[1].minor.yy185 = NULL_ORDER_DEFAULT; } + case 451: /* null_ordering_opt ::= */ +{ yymsp[1].minor.yy217 = NULL_ORDER_DEFAULT; } break; - case 453: /* null_ordering_opt ::= NULLS FIRST */ -{ yymsp[-1].minor.yy185 = NULL_ORDER_FIRST; } + case 452: /* null_ordering_opt ::= NULLS FIRST */ +{ yymsp[-1].minor.yy217 = NULL_ORDER_FIRST; } break; - case 454: /* null_ordering_opt ::= NULLS LAST */ -{ yymsp[-1].minor.yy185 = NULL_ORDER_LAST; } + case 453: /* null_ordering_opt ::= NULLS LAST */ +{ yymsp[-1].minor.yy217 = NULL_ORDER_LAST; } break; default: break; From 7511bfbadaddc51121c031f4130b192f3987394e Mon Sep 17 00:00:00 2001 From: Xiaoyu Wang Date: Tue, 31 May 2022 15:13:57 +0800 Subject: [PATCH 09/28] fix: error in data precision of super table query --- source/libs/parser/test/parInitialCTest.cpp | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/source/libs/parser/test/parInitialCTest.cpp b/source/libs/parser/test/parInitialCTest.cpp index e55f36376c..51ea1bf5e3 100644 --- a/source/libs/parser/test/parInitialCTest.cpp +++ b/source/libs/parser/test/parInitialCTest.cpp @@ -298,14 +298,12 @@ TEST_F(ParserInitialCTest, createStable) { auto setCreateStbReqFunc = [&](const char* pTbname, int8_t igExists = 0, float xFilesFactor = TSDB_DEFAULT_ROLLUP_FILE_FACTOR, - int32_t delay = TSDB_DEFAULT_ROLLUP_DELAY, int32_t ttl = TSDB_DEFAULT_TABLE_TTL, - const char* pComment = nullptr) { + int32_t ttl = TSDB_DEFAULT_TABLE_TTL, const char* pComment = nullptr) { memset(&expect, 0, sizeof(SMCreateStbReq)); int32_t len = snprintf(expect.name, sizeof(expect.name), "0.test.%s", pTbname); expect.name[len] = '\0'; expect.igExists = igExists; expect.xFilesFactor = xFilesFactor; - expect.delay = delay; expect.ttl = ttl; if (nullptr != pComment) { expect.comment = strdup(pComment); @@ -393,7 +391,7 @@ TEST_F(ParserInitialCTest, createStable) { addFieldToCreateStbReqFunc(false, "id", TSDB_DATA_TYPE_INT); run("CREATE STABLE t1(ts TIMESTAMP, c1 INT) TAGS(id INT)"); - setCreateStbReqFunc("t1", 1, 0.1, 2, 100, "test create table"); + setCreateStbReqFunc("t1", 1, 0.1, 100, "test create table"); addFieldToCreateStbReqFunc(true, "ts", TSDB_DATA_TYPE_TIMESTAMP, 0, 0); addFieldToCreateStbReqFunc(true, "c1", TSDB_DATA_TYPE_INT); addFieldToCreateStbReqFunc(true, "c2", TSDB_DATA_TYPE_UINT); @@ -431,7 +429,7 @@ TEST_F(ParserInitialCTest, createStable) { "TAGS (a1 TIMESTAMP, a2 INT, a3 INT UNSIGNED, a4 BIGINT, a5 BIGINT UNSIGNED, a6 FLOAT, a7 DOUBLE, " "a8 BINARY(20), a9 SMALLINT, a10 SMALLINT UNSIGNED COMMENT 'test column comment', a11 TINYINT, " "a12 TINYINT UNSIGNED, a13 BOOL, a14 NCHAR(30), a15 VARCHAR(50)) " - "TTL 100 COMMENT 'test create table' SMA(c1, c2, c3) ROLLUP (MIN) FILE_FACTOR 0.1 DELAY 2"); + "TTL 100 COMMENT 'test create table' SMA(c1, c2, c3) ROLLUP (MIN) FILE_FACTOR 0.1"); } TEST_F(ParserInitialCTest, createStream) { From dbda5c8b2e3df935c549471c3493845418bb7721 Mon Sep 17 00:00:00 2001 From: jiacy-jcy Date: Tue, 31 May 2022 15:38:20 +0800 Subject: [PATCH 10/28] update --- tests/system-test/2-query/stateduration.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/tests/system-test/2-query/stateduration.py b/tests/system-test/2-query/stateduration.py index 6689fab2c3..fa71009ef2 100644 --- a/tests/system-test/2-query/stateduration.py +++ b/tests/system-test/2-query/stateduration.py @@ -24,10 +24,6 @@ class TDTestCase: self.row_num = 10 def run(self): tdSql.prepare() - - - - # timestamp = 1ms , time_unit = 1s tdSql.execute('''create table test(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double, col7 bool, col8 binary(20), col9 nchar(20), col11 tinyint unsigned, col12 smallint unsigned, col13 int unsigned, col14 bigint unsigned)''') From 48c15b18e8ffb823260f4fdbe59e5bd101a37148 Mon Sep 17 00:00:00 2001 From: jiacy-jcy Date: Tue, 31 May 2022 15:38:56 +0800 Subject: [PATCH 11/28] update --- tests/system-test/fulltest.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/system-test/fulltest.sh b/tests/system-test/fulltest.sh index 7b4908eba2..b33c4b14be 100644 --- a/tests/system-test/fulltest.sh +++ b/tests/system-test/fulltest.sh @@ -81,6 +81,7 @@ python3 ./test.py -f 2-query/diff.py python3 ./test.py -f 2-query/sample.py python3 ./test.py -f 2-query/function_diff.py python3 ./test.py -f 2-query/unique.py +python3 ./test.py -f 2-query/stateduration.py python3 ./test.py -f 7-tmq/basic5.py python3 ./test.py -f 7-tmq/subscribeDb.py From 85c2647b10b4858a4de5c64155b6bbdbb0e4a3ff Mon Sep 17 00:00:00 2001 From: gccgdb1234 Date: Tue, 31 May 2022 15:45:14 +0800 Subject: [PATCH 12/28] docs: refine data types for 3.0 in English --- docs-cn/12-taos-sql/01-data-type.md | 9 +++-- docs-en/12-taos-sql/01-data-type.md | 54 ++++++++++++++++++++--------- 2 files changed, 44 insertions(+), 19 deletions(-) diff --git a/docs-cn/12-taos-sql/01-data-type.md b/docs-cn/12-taos-sql/01-data-type.md index 50d59a3186..8ac6ee3b87 100644 --- a/docs-cn/12-taos-sql/01-data-type.md +++ b/docs-cn/12-taos-sql/01-data-type.md @@ -58,10 +58,15 @@ TDengine支持多个类型的常量，细节如下表： | # | **语法** | **类型** | **说明** | | --- | :-------: | --------- | -------------------------------------- | | 1 | [{+ \| -}]123 | BIGINT | 整型数值的字面量的类型均为BIGINT。如果用户输入超过了BIGINT的表示范围，TDengine 按BIGINT对数值进行截断。| -| 2 | 123.45 | DOUBLE | 浮点数值的字面量的类型均为DOUBLE。TDengine依据是否存在小数点，或使用科学计数法表示，来判断数值类型是否为整型或者浮点型，因此在使用时要注意相应类型越界的情况。例如，9999999999999999999会认为超过长整型的上边界而溢出，而9999999999999999999.0会被认为是有效的浮点数。| +| 2 | 123.45 | DOUBLE | 浮点数值的字面量的类型均为DOUBLE。TDengine依据是否存在小数点，或使用科学计数法表示，来判断数值类型是否为整型或者浮点型。| | 3 | 1.2E3 | DOUBLE | 科学计数法的字面量的类型为DOUBLE。| | 4 | 'abc' | BINARY | 单引号括住的内容为字符串字面值，其类型为BINARY，BINARY的size为实际的字符个数。对于字符串内的单引号，可以用转义字符反斜线加单引号来表示，即 \'。| | 5 | "abc" | BINARY | 双引号括住的内容为字符串字面值，其类型为BINARY，BINARY的size为实际的字符个数。对于字符串内的双引号，可以用转义字符反斜线加单引号来表示，即 \"。 | | 6 | TIMESTAMP {'literal' \| "literal"} | TIMESTAMP | TIMESTAMP关键字表示后面的字符串字面量需要被解释为TIMESTAMP类型。字符串需要满足YYYY-MM-DD HH:mm:ss.MS格式，其时间分辨率为当前数据库的时间分辨率。 | -| 7 | {TRUE | FALSE} | BOOL | 布尔类型字面量。 | +| 7 | {TRUE \| FALSE} | BOOL | 布尔类型字面量。 | | 8 | {'' \| "" \| '\t' \| "\t" \| ' ' \| " " \| NULL } | -- | 空值字面量。可以用于任意类型。| + +:::note +- TDengine依据是否存在小数点，或使用科学计数法表示，来判断数值类型是否为整型或者浮点型，因此在使用时要注意相应类型越界的情况。例如，9999999999999999999会认为超过长整型的上边界而溢出，而9999999999999999999.0会被认为是有效的浮点数。 + +::: diff --git a/docs-en/12-taos-sql/01-data-type.md b/docs-en/12-taos-sql/01-data-type.md index 3f5a49e313..d038219c8a 100644 --- a/docs-en/12-taos-sql/01-data-type.md +++ b/docs-en/12-taos-sql/01-data-type.md @@ -3,6 +3,8 @@ title: Data Types description: "TDengine supports a variety of data types including timestamp, float, JSON and many others." --- +## TIMESTAMP + When using TDengine to store and query data, the most important part of the data is timestamp. Timestamp must be specified when creating and inserting data rows. Timestamp must follow the rules below: - The format must be `YYYY-MM-DD HH:mm:ss.MS`, the default time precision is millisecond (ms), for example `2017-08-12 18:25:58.128` @@ -17,33 +19,51 @@ Time precision in TDengine can be set by the `PRECISION` parameter when executin CREATE DATABASE db_name PRECISION 'ns'; ``` +## Data Types + In TDengine, the data types below can be used when specifying a column or tag. | # | **type** | **Bytes** | **Description** | | --- | :-------: | --------- | ------------------------- | | 1 | TIMESTAMP | 8 | Default precision is millisecond, microsecond and nanosecond are also supported | -| 2 | INT | 4 | Integer, the value range is [-2^31+1, 2^31-1], while -2^31 is treated as NULL | -| 3 | BIGINT | 8 | Long integer, the value range is [-2^63+1, 2^63-1], while -2^63 is treated as NULL | -| 4 | FLOAT | 4 | Floating point number, the effective number of digits is 6-7, the value range is [-3.4E38, 3.4E38] | -| 5 | DOUBLE | 8 | Double precision floating point number, the effective number of digits is 15-16, the value range is [-1.7E308, 1.7E308] | -| 6 | BINARY | User Defined | Single-byte string for ASCII visible characters. Length must be specified when defining a column or tag of binary type. The string length can be up to 16374 bytes. The string value must be quoted with single quotes. The literal single quote inside the string must be preceded with back slash like `\'` | -| 7 | SMALLINT | 2 | Short integer, the value range is [-32767, 32767], while -32768 is treated as NULL | -| 8 | TINYINT | 1 | Single-byte integer, the value range is [-127, 127], while -128 is treated as NULL | -| 9 | BOOL | 1 | Bool, the value range is {true, false} | -| 10 | NCHAR | User Defined| Multi-Byte string that can include multi byte characters like Chinese characters. Each character of NCHAR type consumes 4 bytes storage. The string value should be quoted with single quotes. Literal single quote inside the string must be preceded with backslash, like `\’`. The length must be specified when defining a column or tag of NCHAR type, for example nchar(10) means it can store at most 10 characters of nchar type and will consume fixed storage of 40 bytes. An error will be reported if the string value exceeds the length defined. | -| 11 | JSON | | JSON type can only be used on tags. A tag of json type is excluded with any other tags of any other type | - -:::tip -TDengine is case insensitive and treats any characters in the sql command as lower case by default, case sensitive strings must be quoted with single quotes. - -::: +| 2 | INT | 4 | Integer, the value range is [-2^31, 2^31-1] | +| 3 |INT UNSIGNED|4 | Unsigned integer, the value range is [0, 2^31-1] | +| 4 | BIGINT | 8 | Long integer, the value range is [-2^63, 2^63-1] | +| 5 | BIGINT UNSIGNED | 8 | Unsigned long integer, the value range is [0, 2^63-1] | +| 6 | FLOAT | 4 | Floating point number, the effective number of digits is 6-7, the value range is [-3.4E38, 3.4E38] | +| 7 | DOUBLE | 8 | Double precision floating point number, the effective number of digits is 15-16, the value range is [-1.7E308, 1.7E308] | +| 8 | BINARY | User Defined | Single-byte string for ASCII visible characters. Length must be specified when defining a column or tag of binary type. The string length can be up to 16374 bytes. The string value must be quoted with single quotes. The literal single quote inside the string must be preceded with back slash like `\'` | +| 9 | SMALLINT | 2 | Short integer, the value range is [-32768, 32767] | +| 10 | SMALLINT UNSIGNED | 2 | Unsigned short integer, the value range is [0, 32767] | +| 11 | TINYINT | 1 | Single-byte integer, the value range is [-128, 127] | +| 12 | TINYINT UNSIGNED | 1 | Unsigned single-byte integer, the value range is [0, 127] | +| 13 | BOOL | 1 | Bool, the value range is {true, false} | +| 14 | NCHAR | User Defined| Multi-Byte string that can include multi byte characters like Chinese characters. Each character of NCHAR type consumes 4 bytes storage. The string value should be quoted with single quotes. Literal single quote inside the string must be preceded with backslash, like `\’`. The length must be specified when defining a column or tag of NCHAR type, for example nchar(10) means it can store at most 10 characters of nchar type and will consume fixed storage of 40 bytes. An error will be reported if the string value exceeds the length defined. | +| 15 | JSON | | JSON type can only be used on tags. A tag of json type is excluded with any other tags of any other type | +| 16 | VARCHAR | User Defined| Alias of BINARY type | :::note -Only ASCII visible characters are suggested to be used in a column or tag of BINARY type. Multi-byte characters must be stored in NCHAR type. +- TDengine is case insensitive and treats any characters in the sql command as lower case by default, case sensitive strings must be quoted with single quotes. +- Only ASCII visible characters are suggested to be used in a column or tag of BINARY type. Multi-byte characters must be stored in NCHAR type. +- Numeric values in SQL statements will be determined as integer or float type according to whether there is decimal point or whether scientific notation is used, so attention must be paid to avoid overflow. For example, 9999999999999999999 will be considered as overflow because it exceeds the upper limit of long integer, but 9999999999999999999.0 will be considered as a legal float number. ::: +## Constants +TDengine supports constants of multiple data type. + +| # | **Syntax** | **Type** | **Description** | +| --- | :-------: | --------- | -------------------------------------- | +| 1 | [{+ \| -}]123 | BIGINT | Numeric constants are treated as BIGINT type. The value will be truncated if it exceeds the range of BIGINT type. | +| 2 | 123.45 | DOUBLE | Floating number constants are treated as DOUBLE type. TDengine determines whether it's a floating number based on if decimal point or scientific notation is used. | +| 3 | 1.2E3 | DOUBLE | Constants in scientific notation are treated ad DOUBLE type. | +| 4 | 'abc' | BINARY | String constants enclosed by single quotes are treated as BINARY type. Its size is determined as the acutal length. Single quote itself can be included by preceding backslash, i.e. `\'`, in a string constant. | +| 5 | "abc" | BINARY | String constants enclosed by double quotes are treated as BINARY type. Its size is determined as the acutal length. Double quote itself can be included by preceding backslash, i.e. `\"`, in a string constant. | +| 6 | TIMESTAMP {'literal' \| "literal"} | TIMESTAMP | A string constant following `TIMESTAMP` keyword is treated as TIMESTAMP type. The string should be in the format of "YYYY-MM-DD HH:mm:ss.MS". Its time precision is same as that of the current database being used. | +| 7 | {TRUE \| FALSE} | BOOL | BOOL type contant. | +| 8 | {'' \| "" \| '\t' \| "\t" \| ' ' \| " " \| NULL } | -- | NULL constant, it can be used for any type.| + :::note -Numeric values in SQL statements will be determined as integer or float type according to whether there is decimal point or whether scientific notation is used, so attention must be paid to avoid overflow. For example, 9999999999999999999 will be considered as overflow because it exceeds the upper limit of long integer, but 9999999999999999999.0 will be considered as a legal float number. +- TDengine determines whether it's a floating number based on if decimal point or scientific notation is used. So whether the value is determined as overflow depends on both the value and the determined type. For example, 9999999999999999999 is determined as overflow because it exceeds the upper limit of BIGINT type, while 9999999999999999999.0 is considered as a valid floating number because it is within the range of DOUBLE type. ::: From 96a0555d1fd0b62decab68b3b1ba4d0b41ad7ca2 Mon Sep 17 00:00:00 2001 From: Xiaoyu Wang Date: Tue, 31 May 2022 15:49:14 +0800 Subject: [PATCH 13/28] fix: error in data precision of super table query --- source/libs/parser/test/parInitialCTest.cpp | 2 +- tests/script/tsim/insert/update0.sim | 2 +- tests/script/tsim/sma/rsmaCreateInsertQuery.sim | 2 +- tests/system-test/fulltest.sh | 4 +++- 4 files changed, 6 insertions(+), 4 deletions(-) diff --git a/source/libs/parser/test/parInitialCTest.cpp b/source/libs/parser/test/parInitialCTest.cpp index 51ea1bf5e3..f8072c0792 100644 --- a/source/libs/parser/test/parInitialCTest.cpp +++ b/source/libs/parser/test/parInitialCTest.cpp @@ -462,7 +462,7 @@ TEST_F(ParserInitialCTest, createTable) { "TAGS (a1 TIMESTAMP, a2 INT, a3 INT UNSIGNED, a4 BIGINT, a5 BIGINT UNSIGNED, a6 FLOAT, a7 DOUBLE, a8 BINARY(20), " "a9 SMALLINT, a10 SMALLINT UNSIGNED COMMENT 'test column comment', a11 TINYINT, a12 TINYINT UNSIGNED, a13 BOOL, " "a14 NCHAR(30), a15 VARCHAR(50)) " - "TTL 100 COMMENT 'test create table' SMA(c1, c2, c3) ROLLUP (MIN) FILE_FACTOR 0.1 DELAY 2"); + "TTL 100 COMMENT 'test create table' SMA(c1, c2, c3) ROLLUP (MIN) FILE_FACTOR 0.1"); run("CREATE TABLE IF NOT EXISTS t1 USING st1 TAGS(1, 'wxy')"); diff --git a/tests/script/tsim/insert/update0.sim b/tests/script/tsim/insert/update0.sim index 3cb5e4008e..0ba3e98c91 100644 --- a/tests/script/tsim/insert/update0.sim +++ b/tests/script/tsim/insert/update0.sim @@ -9,7 +9,7 @@ sql create database d0 keep 365000d,365000d,365000d sql use d0 print =============== create super table and register rsma -sql create table if not exists stb (ts timestamp, c1 int) tags (city binary(20),district binary(20)) rollup(min) file_factor 0.1 delay 2; +sql create table if not exists stb (ts timestamp, c1 int) tags (city binary(20),district binary(20)) rollup(min) file_factor 0.1; sql show stables if $rows != 1 then diff --git a/tests/script/tsim/sma/rsmaCreateInsertQuery.sim b/tests/script/tsim/sma/rsmaCreateInsertQuery.sim index 5d9425e506..f929dda18c 100644 --- a/tests/script/tsim/sma/rsmaCreateInsertQuery.sim +++ b/tests/script/tsim/sma/rsmaCreateInsertQuery.sim @@ -9,7 +9,7 @@ sql create database d0 retentions 15s:7d,1m:21d,15m:365d; sql use d0 print =============== create super table and register rsma -sql create table if not exists stb (ts timestamp, c1 int) tags (city binary(20),district binary(20)) rollup(min) file_factor 0.1 delay 2; +sql create table if not exists stb (ts timestamp, c1 int) tags (city binary(20),district binary(20)) rollup(min) file_factor 0.1; sql show stables if $rows != 1 then diff --git a/tests/system-test/fulltest.sh b/tests/system-test/fulltest.sh index 2725cf3d13..a155515551 100644 --- a/tests/system-test/fulltest.sh +++ b/tests/system-test/fulltest.sh @@ -72,7 +72,9 @@ python3 ./test.py -f 2-query/arccos.py python3 ./test.py -f 2-query/arctan.py python3 ./test.py -f 2-query/query_cols_tags_and_or.py # python3 ./test.py -f 2-query/nestedQuery.py -python3 ./test.py -f 2-query/nestedQuery_str.py +# TD-15983 subquery output duplicate name column. +# Please Xiangyang Guo modify the following script +# python3 ./test.py -f 2-query/nestedQuery_str.py python3 ./test.py -f 2-query/avg.py python3 ./test.py -f 2-query/elapsed.py python3 ./test.py -f 2-query/csum.py From 1f833afebc7f899504a4fe3b9c6bf95a0f146d31 Mon Sep 17 00:00:00 2001 From: Hui Li <52318143+plum-lihui@users.noreply.github.com> Date: Tue, 31 May 2022 15:50:24 +0800 Subject: [PATCH 14/28] Delete insert.json test: no use --- tests/system-test/insert.json | 76 ----------------------------------- 1 file changed, 76 deletions(-) delete mode 100644 tests/system-test/insert.json diff --git a/tests/system-test/insert.json b/tests/system-test/insert.json deleted file mode 100644 index 5dea9eabfe..0000000000 --- a/tests/system-test/insert.json +++ /dev/null @@ -1,76 +0,0 @@ -{ - "filetype": "insert", - "cfgdir": "/etc/taos", - "host": "127.0.0.1", - "port": 6030, - "user": "root", - "password": "taosdata", - "thread_count": 16, - "create_table_thread_count": 1, - "result_file": "./insert_res.txt", - "confirm_parameter_prompt": "no", - "insert_interval": 0, - "interlace_rows": 0, - "num_of_records_per_req": 10000, - "prepared_rand": 10000, - "chinese": "no", - "databases": [ - { - "dbinfo": { - "name": "db", - "drop": "yes", - "vgroups":4, - "replica": 1, - "precision": "ms" - }, - "super_tables": [ - { - "name": "stb", - "child_table_exists": "no", - "childtable_count": 1000, - "childtable_prefix": "stb_", - "escape_character": "no", - "auto_create_table": "no", - "batch_create_tbl_num": 10, - "data_source": "rand", - "insert_mode": "taosc", - "non_stop_mode": "no", - "line_protocol": "line", - "insert_rows": 100000, - "interlace_rows": 0, - "insert_interval": 0, - "disorder_ratio": 0, - "timestamp_step": 1, - "start_timestamp": "2020-10-01 00:00:00.000", - "use_sample_ts": "no", - "tags_file": "", - "columns": [ - { - "type": "FLOAT", - "name": "current", - "count": 4, - "max": 12, - "min": 8 - }, - { "type": "INT", "name": "voltage", "max": 225, "min": 215 }, - { "type": "FLOAT", "name": "phase", "max": 1, "min": 0 } - ], - "tags": [ - { - "type": "TINYINT", - "name": "groupid", - "max": 10, - "min": 1 - }, - { - "name": "location", - "type": "BINARY", - "len": 16, - "values": ["beijing", "shanghai"] - } - ] - } - ] - } - ] -} From 6bf44b6aa26fc29ffe5fcfaf0c07ee3b8f212bbd Mon Sep 17 00:00:00 2001 From: gccgdb1234 Date: Tue, 31 May 2022 16:11:26 +0800 Subject: [PATCH 15/28] docs: refine keywords in 3.0 --- docs-cn/12-taos-sql/12-keywords/index.md | 6 +++--- docs-en/12-taos-sql/12-keywords.md | 8 ++++---- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/docs-cn/12-taos-sql/12-keywords/index.md b/docs-cn/12-taos-sql/12-keywords/index.md index 0b9ec4de86..c6640b2f92 100644 --- a/docs-cn/12-taos-sql/12-keywords/index.md +++ b/docs-cn/12-taos-sql/12-keywords/index.md @@ -86,7 +86,7 @@ title: TDengine 参数限制与保留关键字 | CONNS | ID | NOTNULL | STABLE | WAL | | COPY | IF | NOW | STABLES | WHERE | | _C0 | _QSTART | _QSTOP | _QDURATION | _WSTART | -| _WSTOP | _WDURATION | +| _WSTOP | _WDURATION | _ROWTS | ## 特殊说明 ### TBNAME @@ -124,5 +124,5 @@ Query OK, 1 row(s) in set (0.001091s) ### _WSTART/_WSTOP/_WDURATION 窗口切分聚合查询（例如 interval/session window/state window）中表示每个切分窗口的起始，结束以及持续时间（从 2.6.0.0 版本开始支持） -### _c0 -表示表或超级表的第一列 \ No newline at end of file +### _c0/_ROWTS +_c0 _ROWTS 等价，表示表或超级表的第一列 \ No newline at end of file diff --git a/docs-en/12-taos-sql/12-keywords.md b/docs-en/12-taos-sql/12-keywords.md index 56a82a02a1..cbacf6cfc7 100644 --- a/docs-en/12-taos-sql/12-keywords.md +++ b/docs-en/12-taos-sql/12-keywords.md @@ -47,11 +47,11 @@ There are about 200 keywords reserved by TDengine, they can't be used as the nam | CONNS | ID | NOTNULL | STable | WAL | | COPY | IF | NOW | STableS | WHERE | | _C0 | _QSTART | _QSTOP | _QDURATION | _WSTART | -| _WSTOP | _WDURATION | +| _WSTOP | _WDURATION | _ROWTS | ## Explanations ### TBNAME -`TBNAME` can be considered as a special tag, which represents the name of the subtable, in STable. +`TBNAME` can be considered as a special tag, which represents the name of the subtable, in a STable. Get the table name and tag values of all subtables in a STable. ```mysql @@ -85,5 +85,5 @@ The start, stop and duration of a query time window (Since version 2.6.0.0). ### _WSTART/_WSTOP/_WDURATION The start, stop and duration of aggegate query by time window, like interval, session window, state window (Since version 2.6.0.0). -### _c0 -The first column of a table or STable. \ No newline at end of file +### _c0/_ROWTS +_c0 is equal to _ROWTS, it means the first column of a table or STable. \ No newline at end of file From 901ff9bf18bbf28b2b79a33be2bf513cf3016463 Mon Sep 17 00:00:00 2001 From: 54liuyao <54liuyao@163.com> Date: Tue, 31 May 2022 15:31:28 +0800 Subject: [PATCH 16/28] feat(sma):files factor --- include/common/tmsg.h | 6 +- include/libs/nodes/cmdnodes.h | 2 +- include/libs/nodes/plannodes.h | 4 + include/libs/planner/planner.h | 1 + source/dnode/mnode/impl/inc/mndScheduler.h | 2 +- source/dnode/mnode/impl/src/mndScheduler.c | 3 +- source/dnode/mnode/impl/src/mndStb.c | 4 +- source/dnode/vnode/src/inc/vnodeInt.h | 2 +- source/dnode/vnode/src/sma/smaRollup.c | 6 +- source/dnode/vnode/src/vnd/vnodeSvr.c | 2 +- source/libs/executor/inc/executorimpl.h | 5 +- source/libs/executor/src/executorimpl.c | 33 ++++++- source/libs/executor/src/scanoperator.c | 12 ++- source/libs/executor/src/timewindowoperator.c | 44 +++++++--- source/libs/nodes/src/nodesCloneFuncs.c | 5 ++ source/libs/nodes/src/nodesCodeFuncs.c | 15 +++- source/libs/parser/src/parAstCreater.c | 2 +- source/libs/planner/src/planLogicCreater.c | 4 + source/libs/planner/src/planOptimizer.c | 4 +- source/libs/planner/src/planPhysiCreater.c | 2 + source/libs/stream/src/tstreamUpdate.c | 4 +- .../script/tsim/sma/tsmaCreateInsertData.sim | 2 +- tests/script/tsim/stream/session0.sim | 4 +- tests/script/tsim/stream/session1.sim | 6 +- tests/script/tsim/stream/triggerInterval0.sim | 88 ------------------- 25 files changed, 132 insertions(+), 130 deletions(-) diff --git a/include/common/tmsg.h b/include/common/tmsg.h index faf4addb4b..12d1c85879 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -1439,8 +1439,10 @@ typedef struct { int32_t code; } STaskDropRsp; -#define STREAM_TRIGGER_AT_ONCE 1 -#define STREAM_TRIGGER_WINDOW_CLOSE 2 +#define STREAM_TRIGGER_AT_ONCE_SMA 0 +#define STREAM_TRIGGER_AT_ONCE 1 +#define STREAM_TRIGGER_WINDOW_CLOSE 2 +#define STREAM_TRIGGER_WINDOW_CLOSE_SMA 3 typedef struct { char name[TSDB_TABLE_FNAME_LEN]; diff --git a/include/libs/nodes/cmdnodes.h b/include/libs/nodes/cmdnodes.h index 0bd6d73ce1..b437ad60b8 100644 --- a/include/libs/nodes/cmdnodes.h +++ b/include/libs/nodes/cmdnodes.h @@ -80,7 +80,7 @@ typedef struct SAlterDatabaseStmt { typedef struct STableOptions { ENodeType type; char comment[TSDB_TB_COMMENT_LEN]; - float filesFactor; + double filesFactor; SNodeList* pRollupFuncs; int32_t ttl; SNodeList* pSma; diff --git a/include/libs/nodes/plannodes.h b/include/libs/nodes/plannodes.h index 2648a468dd..44e7295b69 100644 --- a/include/libs/nodes/plannodes.h +++ b/include/libs/nodes/plannodes.h @@ -59,6 +59,7 @@ typedef struct SScanLogicNode { int8_t triggerType; int64_t watermark; int16_t tsColId; + double filesFactor; } SScanLogicNode; typedef struct SJoinLogicNode { @@ -113,6 +114,7 @@ typedef struct SWindowLogicNode { SNode* pStateExpr; int8_t triggerType; int64_t watermark; + double filesFactor; } SWindowLogicNode; typedef struct SFillLogicNode { @@ -222,6 +224,7 @@ typedef struct STableScanPhysiNode { int8_t triggerType; int64_t watermark; int16_t tsColId; + double filesFactor; } STableScanPhysiNode; typedef STableScanPhysiNode STableSeqScanPhysiNode; @@ -272,6 +275,7 @@ typedef struct SWinodwPhysiNode { SNode* pTspk; // timestamp primary key int8_t triggerType; int64_t watermark; + double filesFactor; } SWinodwPhysiNode; typedef struct SIntervalPhysiNode { diff --git a/include/libs/planner/planner.h b/include/libs/planner/planner.h index c4f71e57a8..6e14445ac7 100644 --- a/include/libs/planner/planner.h +++ b/include/libs/planner/planner.h @@ -36,6 +36,7 @@ typedef struct SPlanContext { int64_t watermark; char* pMsg; int32_t msgLen; + double filesFactor; } SPlanContext; // Create the physical plan for the query, according to the AST. diff --git a/source/dnode/mnode/impl/inc/mndScheduler.h b/source/dnode/mnode/impl/inc/mndScheduler.h index 9f4e377dd1..05aea3f68c 100644 --- a/source/dnode/mnode/impl/inc/mndScheduler.h +++ b/source/dnode/mnode/impl/inc/mndScheduler.h @@ -30,7 +30,7 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib int32_t mndScheduleStream(SMnode* pMnode, STrans* pTrans, SStreamObj* pStream); int32_t mndConvertRSmaTask(const char* ast, int64_t uid, int8_t triggerType, int64_t watermark, char** pStr, - int32_t* pLen); + int32_t* pLen, double filesFactor); #ifdef __cplusplus } diff --git a/source/dnode/mnode/impl/src/mndScheduler.c b/source/dnode/mnode/impl/src/mndScheduler.c index d1404b96fe..eb8d2f0752 100644 --- a/source/dnode/mnode/impl/src/mndScheduler.c +++ b/source/dnode/mnode/impl/src/mndScheduler.c @@ -36,7 +36,7 @@ extern bool tsStreamSchedV; int32_t mndConvertRSmaTask(const char* ast, int64_t uid, int8_t triggerType, int64_t watermark, char** pStr, - int32_t* pLen) { + int32_t* pLen, double filesFactor) { SNode* pAst = NULL; SQueryPlan* pPlan = NULL; terrno = TSDB_CODE_SUCCESS; @@ -58,6 +58,7 @@ int32_t mndConvertRSmaTask(const char* ast, int64_t uid, int8_t triggerType, int .rSmaQuery = true, .triggerType = triggerType, .watermark = watermark, + .filesFactor = filesFactor, }; if (qCreateQueryPlan(&cxt, &pPlan, NULL) < 0) { terrno = TSDB_CODE_QRY_INVALID_INPUT; diff --git a/source/dnode/mnode/impl/src/mndStb.c b/source/dnode/mnode/impl/src/mndStb.c index b33c09a0f9..d436b684ad 100644 --- a/source/dnode/mnode/impl/src/mndStb.c +++ b/source/dnode/mnode/impl/src/mndStb.c @@ -397,13 +397,13 @@ static void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pSt req.pRSmaParam.xFilesFactor = pStb->xFilesFactor; req.pRSmaParam.delay = pStb->delay; if (pStb->ast1Len > 0) { - if (mndConvertRSmaTask(pStb->pAst1, pStb->uid, 0, 0, &req.pRSmaParam.qmsg1, &req.pRSmaParam.qmsg1Len) != + if (mndConvertRSmaTask(pStb->pAst1, pStb->uid, 0, 0, &req.pRSmaParam.qmsg1, &req.pRSmaParam.qmsg1Len, req.pRSmaParam.xFilesFactor) != TSDB_CODE_SUCCESS) { return NULL; } } if (pStb->ast2Len > 0) { - if (mndConvertRSmaTask(pStb->pAst2, pStb->uid, 0, 0, &req.pRSmaParam.qmsg2, &req.pRSmaParam.qmsg2Len) != + if (mndConvertRSmaTask(pStb->pAst2, pStb->uid, 0, 0, &req.pRSmaParam.qmsg2, &req.pRSmaParam.qmsg2Len, req.pRSmaParam.xFilesFactor) != TSDB_CODE_SUCCESS) { return NULL; } diff --git a/source/dnode/vnode/src/inc/vnodeInt.h b/source/dnode/vnode/src/inc/vnodeInt.h index 0e67d9e426..e3a0c94ccc 100644 --- a/source/dnode/vnode/src/inc/vnodeInt.h +++ b/source/dnode/vnode/src/inc/vnodeInt.h @@ -149,7 +149,7 @@ int32_t tdUpdateExpireWindow(SSma* pSma, SSubmitReq* pMsg, int64_t version); int32_t tdProcessTSmaCreate(SSma* pSma, int64_t version, const char* msg); int32_t tdProcessTSmaInsert(SSma* pSma, int64_t indexUid, const char* msg); -int32_t tdProcessRSmaCreate(SSma* pSma, SMeta* pMeta, SVCreateStbReq* pReq, SMsgCb* pMsgCb); +int32_t tdProcessRSmaCreate(SVnode *pVnode, SVCreateStbReq* pReq); int32_t tdProcessRSmaSubmit(SSma* pSma, void* pMsg, int32_t inputType); int32_t tdFetchTbUidList(SSma* pSma, STbUidStore** ppStore, tb_uid_t suid, tb_uid_t uid); int32_t tdUpdateTbUidList(SSma* pSma, STbUidStore* pUidStore); diff --git a/source/dnode/vnode/src/sma/smaRollup.c b/source/dnode/vnode/src/sma/smaRollup.c index 0769da12bc..a1e397f11d 100644 --- a/source/dnode/vnode/src/sma/smaRollup.c +++ b/source/dnode/vnode/src/sma/smaRollup.c @@ -165,7 +165,10 @@ int32_t tdFetchTbUidList(SSma *pSma, STbUidStore **ppStore, tb_uid_t suid, tb_ui * @param pReq * @return int32_t */ -int32_t tdProcessRSmaCreate(SSma *pSma, SMeta *pMeta, SVCreateStbReq *pReq, SMsgCb *pMsgCb) { +int32_t tdProcessRSmaCreate(SVnode *pVnode, SVCreateStbReq *pReq) { + SSma *pSma = pVnode->pSma; + SMeta *pMeta = pVnode->pMeta; + SMsgCb *pMsgCb = &pVnode->msgCb; if (!pReq->rollup) { smaTrace("vgId:%d return directly since no rollup for stable %s %" PRIi64, SMA_VID(pSma), pReq->name, pReq->suid); return TSDB_CODE_SUCCESS; @@ -210,6 +213,7 @@ int32_t tdProcessRSmaCreate(SSma *pSma, SMeta *pMeta, SVCreateStbReq *pReq, SMsg .reader = pReadHandle, .meta = pMeta, .pMsgCb = pMsgCb, + .vnode = pVnode, }; if (param->qmsg1) { diff --git a/source/dnode/vnode/src/vnd/vnodeSvr.c b/source/dnode/vnode/src/vnd/vnodeSvr.c index 74b6982008..4b237bc703 100644 --- a/source/dnode/vnode/src/vnd/vnodeSvr.c +++ b/source/dnode/vnode/src/vnd/vnodeSvr.c @@ -360,7 +360,7 @@ static int vnodeProcessCreateStbReq(SVnode *pVnode, int64_t version, void *pReq, goto _err; } - tdProcessRSmaCreate(pVnode->pSma, pVnode->pMeta, &req, &pVnode->msgCb); + tdProcessRSmaCreate(pVnode, &req); tDecoderClear(&coder); return 0; diff --git a/source/libs/executor/inc/executorimpl.h b/source/libs/executor/inc/executorimpl.h index cb45fa9730..8139e71f63 100644 --- a/source/libs/executor/inc/executorimpl.h +++ b/source/libs/executor/inc/executorimpl.h @@ -440,6 +440,7 @@ typedef struct STimeWindowSupp { int64_t waterMark; TSKEY maxTs; SColumnInfoData timeWindowData; // query time window info for scalar function execution. + SHashObj *winMap; } STimeWindowAggSupp; typedef struct SIntervalAggOperatorInfo { @@ -758,7 +759,7 @@ SOperatorInfo* createDataBlockInfoScanOperator(void* dataReader, SExecTaskInfo* SOperatorInfo* createStreamScanOperatorInfo(void* pDataReader, SReadHandle* pHandle, SArray* pTableIdList, STableScanPhysiNode* pTableScanNode, SExecTaskInfo* pTaskInfo, - STimeWindowAggSupp* pTwSup, int16_t tsColId); + STimeWindowAggSupp* pTwSup); SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExpr, int32_t numOfCols, @@ -837,6 +838,8 @@ SResultWindowInfo* getSessionTimeWindow(SArray* pWinInfos, TSKEY ts, int64_t gap int32_t updateSessionWindowInfo(SResultWindowInfo* pWinInfo, TSKEY* pTs, int32_t rows, int32_t start, int64_t gap, SHashObj* pStDeleted); bool functionNeedToExecute(SqlFunctionCtx* pCtx); +int64_t getSmaWaterMark(int64_t interval, double filesFactor); +bool isSmaStream(int8_t triggerType); int32_t compareTimeWindow(const void* p1, const void* p2, const void* param); #ifdef __cplusplus diff --git a/source/libs/executor/src/executorimpl.c b/source/libs/executor/src/executorimpl.c index e7de886b03..7786ae009a 100644 --- a/source/libs/executor/src/executorimpl.c +++ b/source/libs/executor/src/executorimpl.c @@ -4529,8 +4529,8 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo qDebug("%s pDataReader is not NULL", GET_TASKID(pTaskInfo)); } SArray* tableIdList = extractTableIdList(pTableListInfo); - SOperatorInfo* pOperator = createStreamScanOperatorInfo(pDataReader, pHandle, tableIdList, pTableScanNode, - pTaskInfo, &twSup, pTableScanNode->tsColId); + SOperatorInfo* pOperator = createStreamScanOperatorInfo(pDataReader, pHandle, + tableIdList, pTableScanNode, pTaskInfo, &twSup); taosArrayDestroy(tableIdList); return pOperator; @@ -4631,7 +4631,19 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo STimeWindowAggSupp as = {.waterMark = pIntervalPhyNode->window.watermark, .calTrigger = pIntervalPhyNode->window.triggerType, - .maxTs = INT64_MIN}; + .maxTs = INT64_MIN, + .winMap = NULL,}; + if (isSmaStream(pIntervalPhyNode->window.triggerType)) { + if (FLT_LESS(pIntervalPhyNode->window.filesFactor, 1.000000)) { + as.calTrigger = STREAM_TRIGGER_AT_ONCE_SMA; + } else { + _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_TIMESTAMP); + as.winMap = taosHashInit(64, hashFn, true, HASH_NO_LOCK); + as.waterMark = getSmaWaterMark(interval.interval, + pIntervalPhyNode->window.filesFactor); + as.calTrigger = STREAM_TRIGGER_WINDOW_CLOSE_SMA; + } + } int32_t tsSlotId = ((SColumnNode*)pIntervalPhyNode->window.pTspk)->slotId; pOptr = createIntervalOperatorInfo(ops[0], pExprInfo, num, pResBlock, &interval, tsSlotId, &as, pTaskInfo); @@ -5300,3 +5312,18 @@ int32_t initStreamAggSupporter(SStreamAggSupporter* pSup, const char* pKey) { } return createDiskbasedBuf(&pSup->pResultBuf, pageSize, bufSize, pKey, TD_TMP_DIR_PATH); } + +int64_t getSmaWaterMark(int64_t interval, double filesFactor) { + int64_t waterMark = 0; + ASSERT(FLT_GREATEREQUAL(filesFactor,0.000000)); + waterMark = -1 * filesFactor; + return waterMark; +} + +bool isSmaStream(int8_t triggerType) { + if (triggerType == STREAM_TRIGGER_AT_ONCE || + triggerType == STREAM_TRIGGER_WINDOW_CLOSE) { + return false; + } + return true; +} diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c index b954eb3a22..3e14589faa 100644 --- a/source/libs/executor/src/scanoperator.c +++ b/source/libs/executor/src/scanoperator.c @@ -875,7 +875,7 @@ static SSDataBlock* doStreamBlockScan(SOperatorInfo* pOperator) { if (rows == 0) { pOperator->status = OP_EXEC_DONE; } else if (pInfo->pUpdateInfo) { - SSDataBlock* upRes = getUpdateDataBlock(pInfo, true); // TODO(liuyao) get invertible from plan + SSDataBlock* upRes = getUpdateDataBlock(pInfo, true); if (upRes) { pInfo->pUpdateRes = upRes; if (upRes->info.type == STREAM_REPROCESS) { @@ -894,7 +894,7 @@ static SSDataBlock* doStreamBlockScan(SOperatorInfo* pOperator) { SOperatorInfo* createStreamScanOperatorInfo(void* pDataReader, SReadHandle* pHandle, SArray* pTableIdList, STableScanPhysiNode* pTableScanNode, SExecTaskInfo* pTaskInfo, - STimeWindowAggSupp* pTwSup, int16_t tsColId) { + STimeWindowAggSupp* pTwSup) { SStreamBlockScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamBlockScanInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -939,8 +939,12 @@ SOperatorInfo* createStreamScanOperatorInfo(void* pDataReader, SReadHandle* pHan goto _error; } - pInfo->primaryTsIndex = tsColId; - if (pSTInfo->interval.interval > 0) { + if (isSmaStream(pTableScanNode->triggerType)) { + pTwSup->waterMark = getSmaWaterMark(pSTInfo->interval.interval, + pTableScanNode->filesFactor); + } + pInfo->primaryTsIndex = 0; // pTableScanNode->tsColId; + if (pSTInfo->interval.interval > 0 && pDataReader) { pInfo->pUpdateInfo = updateInfoInitP(&pSTInfo->interval, pTwSup->waterMark); } else { pInfo->pUpdateInfo = NULL; diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c index 9b8c2f75ba..14344daf81 100644 --- a/source/libs/executor/src/timewindowoperator.c +++ b/source/libs/executor/src/timewindowoperator.c @@ -748,10 +748,14 @@ static void hashIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResul longjmp(pTaskInfo->env, TSDB_CODE_QRY_OUT_OF_MEMORY); } - if (pInfo->execModel == OPTR_EXEC_MODEL_STREAM && - (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE || - pInfo->twAggSup.calTrigger == 0) ) { - saveResult(pResult, tableGroupId, pUpdated); + if (pInfo->execModel == OPTR_EXEC_MODEL_STREAM) { + if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE || + pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE_SMA) { + saveResult(pResult, tableGroupId, pUpdated); + } + if (pInfo->twAggSup.winMap) { + taosHashRemove(pInfo->twAggSup.winMap, &win.skey, sizeof(TSKEY)); + } } int32_t forwardStep = 0; @@ -824,10 +828,14 @@ static void hashIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResul longjmp(pTaskInfo->env, TSDB_CODE_QRY_OUT_OF_MEMORY); } - if (pInfo->execModel == OPTR_EXEC_MODEL_STREAM && - (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE || - pInfo->twAggSup.calTrigger == 0) ) { - saveResult(pResult, tableGroupId, pUpdated); + if (pInfo->execModel == OPTR_EXEC_MODEL_STREAM) { + if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE || + pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE_SMA) { + saveResult(pResult, tableGroupId, pUpdated); + } + if (pInfo->twAggSup.winMap) { + taosHashRemove(pInfo->twAggSup.winMap, &win.skey, sizeof(TSKEY)); + } } ekey = ascScan? nextWin.ekey:nextWin.skey; @@ -1172,15 +1180,23 @@ static int32_t closeIntervalWindow(SHashObj *pHashMap, STimeWindowAggSupp *pSup, void* key = taosHashGetKey(pIte, &keyLen); uint64_t groupId = *(uint64_t*) key; ASSERT(keyLen == GET_RES_WINDOW_KEY_LEN(sizeof(TSKEY))); - TSKEY ts = *(uint64_t*) ((char*)key + sizeof(uint64_t)); + TSKEY ts = *(int64_t*) ((char*)key + sizeof(uint64_t)); SResultRowInfo dumyInfo; dumyInfo.cur.pageId = -1; STimeWindow win = getActiveTimeWindow(NULL, &dumyInfo, ts, pInterval, pInterval->precision, NULL); if (win.ekey < pSup->maxTs - pSup->waterMark) { + if (pSup->calTrigger == STREAM_TRIGGER_WINDOW_CLOSE_SMA) { + if (taosHashGet(pSup->winMap, &win.skey, sizeof(TSKEY))) { + continue; + } + } char keyBuf[GET_RES_WINDOW_KEY_LEN(sizeof(TSKEY))]; SET_RES_WINDOW_KEY(keyBuf, &ts, sizeof(TSKEY), groupId); - taosHashRemove(pHashMap, keyBuf, keyLen); + if (pSup->calTrigger != STREAM_TRIGGER_AT_ONCE_SMA && + pSup->calTrigger != STREAM_TRIGGER_WINDOW_CLOSE_SMA) { + taosHashRemove(pHashMap, keyBuf, keyLen); + } SResKeyPos* pos = taosMemoryMalloc(sizeof(SResKeyPos) + sizeof(uint64_t)); if (pos == NULL) { return TSDB_CODE_OUT_OF_MEMORY; @@ -1192,6 +1208,7 @@ static int32_t closeIntervalWindow(SHashObj *pHashMap, STimeWindowAggSupp *pSup, taosMemoryFree(pos); return TSDB_CODE_OUT_OF_MEMORY; } + taosHashPut(pSup->winMap, &win.skey, sizeof(TSKEY), NULL, 0); } } return TSDB_CODE_SUCCESS; @@ -1248,7 +1265,8 @@ static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) { &pInfo->interval, pClosed); finalizeUpdatedResult(pOperator->numOfExprs, pInfo->aggSup.pResultBuf, pClosed, pInfo->binfo.rowCellInfoOffset); - if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER__WINDOW_CLOSE) { + if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE || + pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE_SMA) { taosArrayAddAll(pUpdated, pClosed); } taosArrayDestroy(pClosed); @@ -2412,7 +2430,7 @@ int32_t closeSessionWindow(SArray *pWins, STimeWindowAggSupp *pTwSup, SArray *pC return TSDB_CODE_OUT_OF_MEMORY; } pSeWin->isClosed = true; - if (calTrigger == STREAM_TRIGGER__WINDOW_CLOSE) { + if (calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) { pSeWin->isOutput = true; } } @@ -2486,7 +2504,7 @@ static SSDataBlock* doStreamSessionWindowAgg(SOperatorInfo* pOperator) { SArray* pUpdated = taosArrayInit(16, POINTER_BYTES); copyUpdateResult(pStUpdated, pUpdated, pBInfo->pRes->info.groupId); taosHashCleanup(pStUpdated); - if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER__WINDOW_CLOSE) { + if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) { taosArrayAddAll(pUpdated, pClosed); } diff --git a/source/libs/nodes/src/nodesCloneFuncs.c b/source/libs/nodes/src/nodesCloneFuncs.c index 84b5e0a043..cb4a4f104c 100644 --- a/source/libs/nodes/src/nodesCloneFuncs.c +++ b/source/libs/nodes/src/nodesCloneFuncs.c @@ -329,6 +329,10 @@ static SNode* logicScanCopy(const SScanLogicNode* pSrc, SScanLogicNode* pDst) { COPY_SCALAR_FIELD(intervalUnit); COPY_SCALAR_FIELD(slidingUnit); CLONE_NODE_FIELD(pTagCond); + COPY_SCALAR_FIELD(triggerType); + COPY_SCALAR_FIELD(watermark); + COPY_SCALAR_FIELD(tsColId); + COPY_SCALAR_FIELD(filesFactor); return (SNode*)pDst; } @@ -385,6 +389,7 @@ static SNode* logicWindowCopy(const SWindowLogicNode* pSrc, SWindowLogicNode* pD CLONE_NODE_FIELD(pStateExpr); COPY_SCALAR_FIELD(triggerType); COPY_SCALAR_FIELD(watermark); + COPY_SCALAR_FIELD(filesFactor); return (SNode*)pDst; } diff --git a/source/libs/nodes/src/nodesCodeFuncs.c b/source/libs/nodes/src/nodesCodeFuncs.c index 78710569cb..4b62963ac6 100644 --- a/source/libs/nodes/src/nodesCodeFuncs.c +++ b/source/libs/nodes/src/nodesCodeFuncs.c @@ -1133,6 +1133,7 @@ static const char* jkTableScanPhysiPlanSlidingUnit = "slidingUnit"; static const char* jkTableScanPhysiPlanTriggerType = "triggerType"; static const char* jkTableScanPhysiPlanWatermark = "watermark"; static const char* jkTableScanPhysiPlanTsColId = "tsColId"; +static const char* jkTableScanPhysiPlanFilesFactor = "FilesFactor"; static int32_t physiTableScanNodeToJson(const void* pObj, SJson* pJson) { const STableScanPhysiNode* pNode = (const STableScanPhysiNode*)pObj; @@ -1183,6 +1184,9 @@ static int32_t physiTableScanNodeToJson(const void* pObj, SJson* pJson) { if (TSDB_CODE_SUCCESS == code) { code = tjsonAddIntegerToObject(pJson, jkTableScanPhysiPlanTsColId, pNode->tsColId); } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddDoubleToObject(pJson, jkTableScanPhysiPlanFilesFactor, pNode->filesFactor); + } return code; } @@ -1242,7 +1246,9 @@ static int32_t jsonToPhysiTableScanNode(const SJson* pJson, void* pObj) { if (TSDB_CODE_SUCCESS == code) { tjsonGetNumberValue(pJson, jkTableScanPhysiPlanTsColId, pNode->tsColId, code); } - + if (TSDB_CODE_SUCCESS == code) { + code = tjsonGetDoubleValue(pJson, jkTableScanPhysiPlanFilesFactor, &pNode->filesFactor); + } return code; } @@ -1496,6 +1502,7 @@ static const char* jkWindowPhysiPlanFuncs = "Funcs"; static const char* jkWindowPhysiPlanTsPk = "TsPk"; static const char* jkWindowPhysiPlanTriggerType = "TriggerType"; static const char* jkWindowPhysiPlanWatermark = "Watermark"; +static const char* jkWindowPhysiPlanFilesFactor = "FilesFactor"; static int32_t physiWindowNodeToJson(const void* pObj, SJson* pJson) { const SWinodwPhysiNode* pNode = (const SWinodwPhysiNode*)pObj; @@ -1516,6 +1523,9 @@ static int32_t physiWindowNodeToJson(const void* pObj, SJson* pJson) { if (TSDB_CODE_SUCCESS == code) { code = tjsonAddIntegerToObject(pJson, jkWindowPhysiPlanWatermark, pNode->watermark); } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddDoubleToObject(pJson, jkWindowPhysiPlanFilesFactor, pNode->filesFactor); + } return code; } @@ -1541,6 +1551,9 @@ static int32_t jsonToPhysiWindowNode(const SJson* pJson, void* pObj) { tjsonGetNumberValue(pJson, jkWindowPhysiPlanWatermark, pNode->watermark, code); ; } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonGetDoubleValue(pJson, jkWindowPhysiPlanFilesFactor, &pNode->filesFactor); + } return code; } diff --git a/source/libs/parser/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c index 4380e28727..eb51830d61 100644 --- a/source/libs/parser/src/parAstCreater.c +++ b/source/libs/parser/src/parAstCreater.c @@ -881,7 +881,7 @@ SNode* setTableOption(SAstCreateContext* pCxt, SNode* pOptions, ETableOptionType } break; case TABLE_OPTION_FILE_FACTOR: - ((STableOptions*)pOptions)->filesFactor = taosStr2Float(((SToken*)pVal)->z, NULL); + ((STableOptions*)pOptions)->filesFactor = taosStr2Double(((SToken*)pVal)->z, NULL); break; case TABLE_OPTION_ROLLUP: ((STableOptions*)pOptions)->pRollupFuncs = pVal; diff --git a/source/libs/planner/src/planLogicCreater.c b/source/libs/planner/src/planLogicCreater.c index 2df248e53f..eae8799b04 100644 --- a/source/libs/planner/src/planLogicCreater.c +++ b/source/libs/planner/src/planLogicCreater.c @@ -487,6 +487,10 @@ static int32_t createWindowLogicNodeFinalize(SLogicPlanContext* pCxt, SSelectStm pWindow->watermark = pCxt->pPlanCxt->watermark; } + if (pCxt->pPlanCxt->rSmaQuery) { + pWindow->filesFactor = pCxt->pPlanCxt->filesFactor; + } + if (TSDB_CODE_SUCCESS == code) { code = rewriteExprForSelect(pWindow->pFuncs, pSelect, SQL_CLAUSE_WINDOW); } diff --git a/source/libs/planner/src/planOptimizer.c b/source/libs/planner/src/planOptimizer.c index adc07fcd0d..5f88fc40e5 100644 --- a/source/libs/planner/src/planOptimizer.c +++ b/source/libs/planner/src/planOptimizer.c @@ -99,7 +99,8 @@ static bool osdMayBeOptimized(SLogicNode* pNode) { return false; } // todo: release after function splitting - if (TSDB_SUPER_TABLE == ((SScanLogicNode*)pNode)->pMeta->tableType) { + if (TSDB_SUPER_TABLE == ((SScanLogicNode*)pNode)->pMeta->tableType && + SCAN_TYPE_STREAM != ((SScanLogicNode*)pNode)->scanType) { return false; } if (NULL == pNode->pParent || (QUERY_NODE_LOGIC_PLAN_WINDOW != nodeType(pNode->pParent) && @@ -226,6 +227,7 @@ static void setScanWindowInfo(SScanLogicNode* pScan) { pScan->triggerType = ((SWindowLogicNode*)pScan->node.pParent)->triggerType; pScan->watermark = ((SWindowLogicNode*)pScan->node.pParent)->watermark; pScan->tsColId = ((SColumnNode*)((SWindowLogicNode*)pScan->node.pParent)->pTspk)->colId; + pScan->filesFactor = ((SWindowLogicNode*)pScan->node.pParent)->filesFactor; } } diff --git a/source/libs/planner/src/planPhysiCreater.c b/source/libs/planner/src/planPhysiCreater.c index a45eabefb9..62fde889da 100644 --- a/source/libs/planner/src/planPhysiCreater.c +++ b/source/libs/planner/src/planPhysiCreater.c @@ -506,6 +506,7 @@ static int32_t createTableScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSubp pTableScan->triggerType = pScanLogicNode->triggerType; pTableScan->watermark = pScanLogicNode->watermark; pTableScan->tsColId = pScanLogicNode->tsColId; + pTableScan->filesFactor = pScanLogicNode->filesFactor; return createScanPhysiNodeFinalize(pCxt, pSubplan, pScanLogicNode, (SScanPhysiNode*)pTableScan, pPhyNode); } @@ -917,6 +918,7 @@ static int32_t createWindowPhysiNodeFinalize(SPhysiPlanContext* pCxt, SNodeList* pWindow->triggerType = pWindowLogicNode->triggerType; pWindow->watermark = pWindowLogicNode->watermark; + pWindow->filesFactor = pWindowLogicNode->filesFactor; if (TSDB_CODE_SUCCESS == code) { *pPhyNode = (SPhysiNode*)pWindow; diff --git a/source/libs/stream/src/tstreamUpdate.c b/source/libs/stream/src/tstreamUpdate.c index 7587fcecc9..6935355a93 100644 --- a/source/libs/stream/src/tstreamUpdate.c +++ b/source/libs/stream/src/tstreamUpdate.c @@ -73,8 +73,8 @@ static int64_t adjustInterval(int64_t interval, int32_t precision) { } static int64_t adjustWatermark(int64_t adjInterval, int64_t originInt, int64_t watermark) { - if (watermark <= 0) { - watermark = TMIN(originInt/adjInterval, 1) * adjInterval; + if (watermark <= adjInterval) { + watermark = TMAX(originInt/adjInterval, 1) * adjInterval; } else if (watermark > MAX_NUM_SCALABLE_BF * adjInterval) { watermark = MAX_NUM_SCALABLE_BF * adjInterval; }/* else if (watermark < MIN_NUM_SCALABLE_BF * adjInterval) { diff --git a/tests/script/tsim/sma/tsmaCreateInsertData.sim b/tests/script/tsim/sma/tsmaCreateInsertData.sim index 07c5adef5d..0202c53800 100644 --- a/tests/script/tsim/sma/tsmaCreateInsertData.sim +++ b/tests/script/tsim/sma/tsmaCreateInsertData.sim @@ -5,7 +5,7 @@ sleep 50 sql connect print =============== create database -sql create database d1 +sql create database d1 vgroups 1 sql use d1 print =============== create super table, include column type for count/sum/min/max/first diff --git a/tests/script/tsim/stream/session0.sim b/tests/script/tsim/stream/session0.sim index 46b343632a..41a8b33710 100644 --- a/tests/script/tsim/stream/session0.sim +++ b/tests/script/tsim/stream/session0.sim @@ -23,7 +23,7 @@ sql insert into t1 values(1648791223001,10,2,3,1.1,2); sql insert into t1 values(1648791233002,3,2,3,2.1,3); sql insert into t1 values(1648791243003,NULL,NULL,NULL,NULL,4); sql insert into t1 values(1648791213002,NULL,NULL,NULL,NULL,5) (1648791233012,NULL,NULL,NULL,NULL,6); - +sleep 300 sql select * from streamt order by s desc; # row 0 @@ -115,7 +115,7 @@ sql insert into t1 values(1648791233002,3,2,3,2.1,9); sql insert into t1 values(1648791243003,4,2,3,3.1,10); sql insert into t1 values(1648791213002,4,2,3,4.1,11) ; sql insert into t1 values(1648791213002,4,2,3,4.1,12) (1648791223009,4,2,3,4.1,13); - +sleep 300 sql select * from streamt order by s desc ; # row 0 diff --git a/tests/script/tsim/stream/session1.sim b/tests/script/tsim/stream/session1.sim index a44639ba7a..fb31818f98 100644 --- a/tests/script/tsim/stream/session1.sim +++ b/tests/script/tsim/stream/session1.sim @@ -22,7 +22,7 @@ sql insert into t1 values(1648791210000,1,1,1,1.1,1); sql insert into t1 values(1648791220000,2,2,2,2.1,2); sql insert into t1 values(1648791230000,3,3,3,3.1,3); sql insert into t1 values(1648791240000,4,4,4,4.1,4); - +sleep 300 sql select * from streamt order by s desc; # row 0 @@ -50,7 +50,7 @@ sql insert into t1 values(1648791250005,5,5,5,5.1,5); sql insert into t1 values(1648791260006,6,6,6,6.1,6); sql insert into t1 values(1648791270007,7,7,7,7.1,7); sql insert into t1 values(1648791240005,5,5,5,5.1,8) (1648791250006,6,6,6,6.1,9); - +sleep 300 sql select * from streamt order by s desc; # row 0 @@ -100,7 +100,7 @@ sql insert into t1 values(1648791260007,7,7,7,7.1,12) (1648791290008,7,7,7,7.1,1 sql insert into t1 values(1648791500000,7,7,7,7.1,15) (1648791520000,8,8,8,8.1,16) (1648791540000,8,8,8,8.1,17); sql insert into t1 values(1648791530000,8,8,8,8.1,18); sql insert into t1 values(1648791220000,10,10,10,10.1,19) (1648791290008,2,2,2,2.1,20) (1648791540000,17,17,17,17.1,21) (1648791500001,22,22,22,22.1,22); - +sleep 300 sql select * from streamt order by s desc; # row 0 diff --git a/tests/script/tsim/stream/triggerInterval0.sim b/tests/script/tsim/stream/triggerInterval0.sim index 6f1d8f4b7b..756f591f3f 100644 --- a/tests/script/tsim/stream/triggerInterval0.sim +++ b/tests/script/tsim/stream/triggerInterval0.sim @@ -94,92 +94,4 @@ if $data11 != 5 then return -1 endi -sql create table t2(ts timestamp, a int, b int , c int, d double); -sql create stream streams2 trigger window_close watermark 20s into streamt2 as select _wstartts, count(*) c1, count(d) c2 , sum(a) c3 , max(b) c4, min(c) c5 from t2 interval(10s); -sql insert into t2 values(1648791213000,1,2,3,1.0); -sql insert into t2 values(1648791239999,1,2,3,1.0); -sleep 300 -sql select * from streamt2; -if $rows != 0 then - print ======$rows - return -1 -endi - -sql insert into t2 values(1648791240000,1,2,3,1.0); -sleep 300 -sql select * from streamt2; -if $rows != 1 then - print ======$rows - return -1 -endi -if $data01 != 1 then - print ======$data01 - return -1 -endi - -sql insert into t2 values(1648791250001,1,2,3,1.0) (1648791250002,1,2,3,1.0) (1648791250003,1,2,3,1.0) (1648791240000,1,2,3,1.0); -sleep 300 -sql select * from streamt2; -if $rows != 1 then - print ======$rows - return -1 -endi -if $data01 != 1 then - print ======$data01 - return -1 -endi - -sql insert into t2 values(1648791280000,1,2,3,1.0); -sleep 300 -sql select * from streamt2; -if $rows != 4 then - print ======$rows - return -1 -endi -if $data01 != 1 then - print ======$data01 - return -1 -endi -if $data11 != 1 then - print ======$data11 - return -1 -endi -if $data21 != 1 then - print ======$data21 - return -1 -endi -if $data31 != 3 then - print ======$data31 - return -1 -endi - -sql insert into t2 values(1648791250001,1,2,3,1.0) (1648791250002,1,2,3,1.0) (1648791250003,1,2,3,1.0) (1648791280000,1,2,3,1.0) (1648791280001,1,2,3,1.0) (1648791280002,1,2,3,1.0) (1648791310000,1,2,3,1.0) (1648791280001,1,2,3,1.0); -sleep 300 -sql select * from streamt2; - -if $rows != 5 then - print ======$rows - return -1 -endi -if $data01 != 1 then - print ======$data01 - return -1 -endi -if $data11 != 1 then - print ======$data11 - return -1 -endi -if $data21 != 1 then - print ======$data21 - return -1 -endi -if $data31 != 3 then - print ======$data31 - return -1 -endi -if $data41 != 3 then - print ======$data31 - return -1 -endi - system sh/exec.sh -n dnode1 -s stop -x SIGINT \ No newline at end of file From 7bcc753ae7b21c8a627964c83fc80141d1dfd324 Mon Sep 17 00:00:00 2001 From: wade zhang <95411902+gccgdb1234@users.noreply.github.com> Date: Tue, 31 May 2022 16:17:45 +0800 Subject: [PATCH 17/28] Update 12-keywords.md --- docs-en/12-taos-sql/12-keywords.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs-en/12-taos-sql/12-keywords.md b/docs-en/12-taos-sql/12-keywords.md index cbacf6cfc7..8f045f4801 100644 --- a/docs-en/12-taos-sql/12-keywords.md +++ b/docs-en/12-taos-sql/12-keywords.md @@ -80,10 +80,10 @@ taos> SELECT COUNT(tbname) FROM meters WHERE groupId > 2; Query OK, 1 row(s) in set (0.001091s) ``` ### _QSTART/_QSTOP/_QDURATION -The start, stop and duration of a query time window (Since version 2.6.0.0). +The start, stop and duration of a query time window. ### _WSTART/_WSTOP/_WDURATION -The start, stop and duration of aggegate query by time window, like interval, session window, state window (Since version 2.6.0.0). +The start, stop and duration of aggegate query by time window, like interval, session window, state window. ### _c0/_ROWTS -_c0 is equal to _ROWTS, it means the first column of a table or STable. \ No newline at end of file +_c0 is equal to _ROWTS, it means the first column of a table or STable. From 2bc9d1d7035771a8e10e7a0f9d79e0aaa1ae0735 Mon Sep 17 00:00:00 2001 From: wade zhang <95411902+gccgdb1234@users.noreply.github.com> Date: Tue, 31 May 2022 16:18:34 +0800 Subject: [PATCH 18/28] Update index.md --- docs-cn/12-taos-sql/12-keywords/index.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs-cn/12-taos-sql/12-keywords/index.md b/docs-cn/12-taos-sql/12-keywords/index.md index c6640b2f92..0e8e1edfee 100644 --- a/docs-cn/12-taos-sql/12-keywords/index.md +++ b/docs-cn/12-taos-sql/12-keywords/index.md @@ -119,10 +119,10 @@ taos> SELECT COUNT(tbname) FROM meters WHERE groupId > 2; Query OK, 1 row(s) in set (0.001091s) ``` ### _QSTART/_QSTOP/_QDURATION -表示查询过滤窗口的起始，结束以及持续时间 (从2.6.0.0版本开始支持) +表示查询过滤窗口的起始，结束以及持续时间。 ### _WSTART/_WSTOP/_WDURATION -窗口切分聚合查询（例如 interval/session window/state window）中表示每个切分窗口的起始，结束以及持续时间（从 2.6.0.0 版本开始支持） +窗口切分聚合查询（例如 interval/session window/state window）中表示每个切分窗口的起始，结束以及持续时间。 ### _c0/_ROWTS -_c0 _ROWTS 等价，表示表或超级表的第一列 \ No newline at end of file +_c0 _ROWTS 等价，表示表或超级表的第一列 From 2f7ff30101af6bed809199ed53a2c07341fa23a9 Mon Sep 17 00:00:00 2001 From: tomchon Date: Tue, 31 May 2022 16:22:10 +0800 Subject: [PATCH 19/28] test:add testcase of python connector using Statement API --- ..._query.py => test_stmt_insert_query_ex.py} | 21 +- .../1-insert/test_stmt_muti_insert_query.py | 181 ++++++++++++++++++ .../1-insert/test_stmt_set_tbname_tag.py | 176 +++++++++++++++++ tests/system-test/fulltest.sh | 2 +- 4 files changed, 374 insertions(+), 6 deletions(-) rename tests/system-test/1-insert/{test_stmt_insert_query.py => test_stmt_insert_query_ex.py} (93%) create mode 100644 tests/system-test/1-insert/test_stmt_muti_insert_query.py create mode 100644 tests/system-test/1-insert/test_stmt_set_tbname_tag.py diff --git a/tests/system-test/1-insert/test_stmt_insert_query.py b/tests/system-test/1-insert/test_stmt_insert_query_ex.py similarity index 93% rename from tests/system-test/1-insert/test_stmt_insert_query.py rename to tests/system-test/1-insert/test_stmt_insert_query_ex.py index 90f168eecf..1a286ceadc 100644 --- a/tests/system-test/1-insert/test_stmt_insert_query.py +++ b/tests/system-test/1-insert/test_stmt_insert_query_ex.py @@ -230,9 +230,20 @@ class TDTestCase: querystmt1.execute() result1=querystmt1.use_result() rows1=result1.fetch_all() - assert str(rows1[0][0]) == "2021-07-21 17:56:32.589111" - assert rows1[0][10] == 3 - assert rows1[1][10] == 4 + print(rows1) + querystmt2=conn.statement("select abs(?) from log where bu < ?") + queryparam2=new_bind_params(2) + print(type(queryparam1)) + queryparam2[0].int(5) + queryparam2[1].int(5) + querystmt2.bind_param(queryparam2) + querystmt2.execute() + result2=querystmt2.use_result() + rows2=result2.fetch_all() + print(rows2) + # assert str(rows1[0][0]) == "2021-07-21 17:56:32.589111" + # assert rows1[0][10] == 3 + # assert rows1[1][10] == 4 # conn.execute("drop database if exists %s" % dbname) conn.close() @@ -248,8 +259,8 @@ class TDTestCase: host="localhost" connectstmt=self.newcon(host,config) self.test_stmt_insert_multi(connectstmt) - # connectstmt=self.newcon(host,config) - # self.test_stmt_set_tbname_tag(connectstmt) + connectstmt=self.newcon(host,config) + self.test_stmt_set_tbname_tag(connectstmt) return diff --git a/tests/system-test/1-insert/test_stmt_muti_insert_query.py b/tests/system-test/1-insert/test_stmt_muti_insert_query.py new file mode 100644 index 0000000000..486bcd8062 --- /dev/null +++ b/tests/system-test/1-insert/test_stmt_muti_insert_query.py @@ -0,0 +1,181 @@ +################################################################### +# Copyright (c) 2016 by TAOS Technologies, Inc. +# All rights reserved. +# +# This file is proprietary and confidential to TAOS Technologies. +# No part of this file may be reproduced, stored, transmitted, +# disclosed or used in any form or by any means other than as +# expressly provided by the written permission from Jianhui Tao +# +################################################################### + +# -*- coding: utf-8 -*- + +import sys +import os +import threading as thd +import multiprocessing as mp +from numpy.lib.function_base import insert +import taos +from taos import * +from util.log import * +from util.cases import * +from util.sql import * +import numpy as np +import datetime as dt +from datetime import datetime +from ctypes import * +import time +# constant define +WAITS = 5 # wait seconds + +class TDTestCase: + # + # --------------- main frame ------------------- + def caseDescription(self): + ''' + limit and offset keyword function test cases; + case1: limit offset base function test + case2: offset return valid + ''' + return + + def getBuildPath(self): + selfPath = os.path.dirname(os.path.realpath(__file__)) + + if ("community" in selfPath): + projPath = selfPath[:selfPath.find("community")] + else: + projPath = selfPath[:selfPath.find("tests")] + + for root, dirs, files in os.walk(projPath): + if ("taosd" in files): + rootRealPath = os.path.dirname(os.path.realpath(root)) + if ("packaging" not in rootRealPath): + buildPath = root[:len(root)-len("/build/bin")] + break + return buildPath + + # init + def init(self, conn, logSql): + tdLog.debug("start to execute %s" % __file__) + tdSql.init(conn.cursor()) + # tdSql.prepare() + # self.create_tables(); + self.ts = 1500000000000 + + # stop + def stop(self): + tdSql.close() + tdLog.success("%s successfully executed" % __file__) + + + # --------------- case ------------------- + + + def newcon(self,host,cfg): + user = "root" + password = "taosdata" + port =6030 + con=taos.connect(host=host, user=user, password=password, config=cfg ,port=port) + print(con) + return con + + def test_stmt_insert_multi(self,conn): + # type: (TaosConnection) -> None + + dbname = "pytest_taos_stmt_multi" + try: + conn.execute("drop database if exists %s" % dbname) + conn.execute("create database if not exists %s" % dbname) + conn.select_db(dbname) + + conn.execute( + "create table if not exists log(ts timestamp, bo bool, nil tinyint, ti tinyint, si smallint, ii int,\ + bi bigint, tu tinyint unsigned, su smallint unsigned, iu int unsigned, bu bigint unsigned, \ + ff float, dd double, bb binary(100), nn nchar(100), tt timestamp)", + ) + # conn.load_table_info("log") + + start = datetime.now() + stmt = conn.statement("insert into log values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)") + + params = new_multi_binds(16) + params[0].timestamp((1626861392589, 1626861392590, 1626861392591)) + params[1].bool((True, None, False)) + params[2].tinyint([-128, -128, None]) # -128 is tinyint null + params[3].tinyint([0, 127, None]) + params[4].smallint([3, None, 2]) + params[5].int([3, 4, None]) + params[6].bigint([3, 4, None]) + params[7].tinyint_unsigned([3, 4, None]) + params[8].smallint_unsigned([3, 4, None]) + params[9].int_unsigned([3, 4, None]) + params[10].bigint_unsigned([3, 4, None]) + params[11].float([3, None, 1]) + params[12].double([3, None, 1.2]) + params[13].binary(["abc", "dddafadfadfadfadfa", None]) + params[14].nchar(["涛思数据", None, "a long string with 中文字符"]) + params[15].timestamp([None, None, 1626861392591]) + # print(type(stmt)) + stmt.bind_param_batch(params) + stmt.execute() + end = datetime.now() + print("elapsed time: ", end - start) + assert stmt.affected_rows == 3 + + #query + querystmt=conn.statement("select ?,bu from log") + queryparam=new_bind_params(1) + print(type(queryparam)) + queryparam[0].binary("ts") + querystmt.bind_param(queryparam) + querystmt.execute() + result=querystmt.use_result() + # rows=result.fetch_all() + # print( querystmt.use_result()) + + # result = conn.query("select * from log") + rows=result.fetch_all() + # rows=result.fetch_all() + print(rows) + assert rows[1][0] == "ts" + assert rows[0][1] == 3 + + #query + querystmt1=conn.statement("select * from log where bu < ?") + queryparam1=new_bind_params(1) + print(type(queryparam1)) + queryparam1[0].int(4) + querystmt1.bind_param(queryparam1) + querystmt1.execute() + result1=querystmt1.use_result() + rows1=result1.fetch_all() + print(rows1) + assert str(rows1[0][0]) == "2021-07-21 17:56:32.589000" + assert rows1[0][10] == 3 + + + stmt.close() + + # conn.execute("drop database if exists %s" % dbname) + conn.close() + + except Exception as err: + # conn.execute("drop database if exists %s" % dbname) + conn.close() + raise err + + def run(self): + buildPath = self.getBuildPath() + config = buildPath+ "../sim/dnode1/cfg/" + host="localhost" + connectstmt=self.newcon(host,config) + self.test_stmt_insert_multi(connectstmt) + return + + +# add case with filename +# +tdCases.addWindows(__file__, TDTestCase()) +tdCases.addLinux(__file__, TDTestCase()) \ No newline at end of file diff --git a/tests/system-test/1-insert/test_stmt_set_tbname_tag.py b/tests/system-test/1-insert/test_stmt_set_tbname_tag.py new file mode 100644 index 0000000000..54d5cfbafb --- /dev/null +++ b/tests/system-test/1-insert/test_stmt_set_tbname_tag.py @@ -0,0 +1,176 @@ +################################################################### +# Copyright (c) 2016 by TAOS Technologies, Inc. +# All rights reserved. +# +# This file is proprietary and confidential to TAOS Technologies. +# No part of this file may be reproduced, stored, transmitted, +# disclosed or used in any form or by any means other than as +# expressly provided by the written permission from Jianhui Tao +# +################################################################### + +# -*- coding: utf-8 -*- + +import sys +import os +import threading as thd +import multiprocessing as mp +from numpy.lib.function_base import insert +import taos +from taos import * +from util.log import * +from util.cases import * +from util.sql import * +import numpy as np +import datetime as dt +from datetime import datetime +from ctypes import * +import time +# constant define +WAITS = 5 # wait seconds + +class TDTestCase: + # + # --------------- main frame ------------------- + def caseDescription(self): + ''' + limit and offset keyword function test cases; + case1: limit offset base function test + case2: offset return valid + ''' + return + + def getBuildPath(self): + selfPath = os.path.dirname(os.path.realpath(__file__)) + + if ("community" in selfPath): + projPath = selfPath[:selfPath.find("community")] + else: + projPath = selfPath[:selfPath.find("tests")] + + for root, dirs, files in os.walk(projPath): + if ("taosd" in files): + rootRealPath = os.path.dirname(os.path.realpath(root)) + if ("packaging" not in rootRealPath): + buildPath = root[:len(root)-len("/build/bin")] + break + return buildPath + + # init + def init(self, conn, logSql): + tdLog.debug("start to execute %s" % __file__) + tdSql.init(conn.cursor()) + # tdSql.prepare() + # self.create_tables(); + self.ts = 1500000000000 + + # stop + def stop(self): + tdSql.close() + tdLog.success("%s successfully executed" % __file__) + + + # --------------- case ------------------- + + + def newcon(self,host,cfg): + user = "root" + password = "taosdata" + port =6030 + con=taos.connect(host=host, user=user, password=password, config=cfg ,port=port) + print(con) + return con + + def test_stmt_set_tbname_tag(self,conn): + dbname = "pytest_taos_stmt_set_tbname_tag" + + try: + conn.execute("drop database if exists %s" % dbname) + conn.execute("create database if not exists %s PRECISION 'us' " % dbname) + conn.select_db(dbname) + conn.execute("create table if not exists log(ts timestamp, bo bool, nil tinyint, ti tinyint, si smallint, ii int,\ + bi bigint, tu tinyint unsigned, su smallint unsigned, iu int unsigned, bu bigint unsigned, \ + ff float, dd double, bb binary(100), nn nchar(100), tt timestamp , vc varchar(100)) tags (t1 timestamp, t2 bool,\ + t3 tinyint, t4 tinyint, t5 smallint, t6 int, t7 bigint, t8 tinyint unsigned, t9 smallint unsigned, \ + t10 int unsigned, t11 bigint unsigned, t12 float, t13 double, t14 binary(100), t15 nchar(100), t16 timestamp)") + + stmt = conn.statement("insert into ? using log tags (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) \ + values (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)") + tags = new_bind_params(16) + tags[0].timestamp(1626861392589123, PrecisionEnum.Microseconds) + tags[1].bool(True) + tags[2].null() + tags[3].tinyint(2) + tags[4].smallint(3) + tags[5].int(4) + tags[6].bigint(5) + tags[7].tinyint_unsigned(6) + tags[8].smallint_unsigned(7) + tags[9].int_unsigned(8) + tags[10].bigint_unsigned(9) + tags[11].float(10.1) + tags[12].double(10.11) + tags[13].binary("hello") + tags[14].nchar("stmt") + tags[15].timestamp(1626861392589, PrecisionEnum.Milliseconds) + stmt.set_tbname_tags("tb1", tags) + params = new_multi_binds(16) + params[0].timestamp((1626861392589111, 1626861392590111, 1626861392591111)) + params[1].bool((True, None, False)) + params[2].tinyint([-128, -128, None]) # -128 is tinyint null + params[3].tinyint([0, 127, None]) + params[4].smallint([3, None, 2]) + params[5].int([3, 4, None]) + params[6].bigint([3, 4, None]) + params[7].tinyint_unsigned([3, 4, None]) + params[8].smallint_unsigned([3, 4, None]) + params[9].int_unsigned([3, 4, None]) + params[10].bigint_unsigned([3, 4, 5]) + params[11].float([3, None, 1]) + params[12].double([3, None, 1.2]) + params[13].binary(["abc", "dddafadfadfadfadfa", None]) + params[14].nchar(["涛思数据", None, "a long string with 中文字符"]) + params[15].timestamp([None, None, 1626861392591]) + params[16].binary(["涛思数据16", None, "a long string with 中文-字符"]) + + stmt.bind_param_batch(params) + stmt.execute() + + assert stmt.affected_rows == 3 + + #query + querystmt1=conn.statement("select * from log where bu < ?") + queryparam1=new_bind_params(1) + print(type(queryparam1)) + queryparam1[0].int(5) + querystmt1.bind_param(queryparam1) + querystmt1.execute() + result1=querystmt1.use_result() + rows1=result1.fetch_all() + print(rows1) + # assert str(rows1[0][0]) == "2021-07-21 17:56:32.589111" + # assert rows1[0][10] == 3 + # assert rows1[1][10] == 4 + + # conn.execute("drop database if exists %s" % dbname) + conn.close() + + except Exception as err: + # conn.execute("drop database if exists %s" % dbname) + conn.close() + raise err + + def run(self): + buildPath = self.getBuildPath() + config = buildPath+ "../sim/dnode1/cfg/" + host="localhost" + connectstmt=self.newcon(host,config) + self.test_stmt_set_tbname_tag(connectstmt) + + return + + +# add case with filename +# +tdCases.addWindows(__file__, TDTestCase()) +tdCases.addLinux(__file__, TDTestCase()) \ No newline at end of file diff --git a/tests/system-test/fulltest.sh b/tests/system-test/fulltest.sh index 7f41a41cc1..e68d970ab9 100644 --- a/tests/system-test/fulltest.sh +++ b/tests/system-test/fulltest.sh @@ -15,7 +15,7 @@ python3 ./test.py -f 0-others/user_control.py python3 ./test.py -f 0-others/fsync.py python3 ./test.py -f 1-insert/opentsdb_telnet_line_taosc_insert.py -python3 ./test.py -f 1-insert/test_stmt_insert_query.py +python3 ./test.py -f 1-insert/test_stmt_muti_insert_query.py python3 ./test.py -f 2-query/between.py python3 ./test.py -f 2-query/distinct.py From 527644b6dd5f538616ea511d6921e66cd246afb8 Mon Sep 17 00:00:00 2001 From: gccgdb1234 Date: Tue, 31 May 2022 16:23:09 +0800 Subject: [PATCH 20/28] docs: refine file structure for keywords --- .../12-taos-sql/12-keywords/_category_.yml | 1 - docs-cn/12-taos-sql/12-keywords/index.md | 128 ------------------ 2 files changed, 129 deletions(-) delete mode 100644 docs-cn/12-taos-sql/12-keywords/_category_.yml delete mode 100644 docs-cn/12-taos-sql/12-keywords/index.md diff --git a/docs-cn/12-taos-sql/12-keywords/_category_.yml b/docs-cn/12-taos-sql/12-keywords/_category_.yml deleted file mode 100644 index 67738650a4..0000000000 --- a/docs-cn/12-taos-sql/12-keywords/_category_.yml +++ /dev/null @@ -1 +0,0 @@ -label: 参数限制与保留关键字 \ No newline at end of file diff --git a/docs-cn/12-taos-sql/12-keywords/index.md b/docs-cn/12-taos-sql/12-keywords/index.md deleted file mode 100644 index 0e8e1edfee..0000000000 --- a/docs-cn/12-taos-sql/12-keywords/index.md +++ /dev/null @@ -1,128 +0,0 @@ ---- -sidebar_label: 参数限制与保留关键字 -title: TDengine 参数限制与保留关键字 ---- - -## 名称命名规则 - -1. 合法字符：英文字符、数字和下划线 -2. 允许英文字符或下划线开头，不允许以数字开头 -3. 不区分大小写 -4. 转义后表（列）名规则： - 为了兼容支持更多形式的表（列）名，TDengine 引入新的转义符 "`"。可用让表名与关键词不冲突，同时不受限于上述表名称合法性约束检查。 - 转义后的表（列）名同样受到长度限制要求，且长度计算的时候不计算转义符。使用转义字符以后，不再对转义字符中的内容进行大小写统一。 - - 例如：\`aBc\` 和 \`abc\` 是不同的表（列）名，但是 abc 和 aBc 是相同的表（列）名。 - 需要注意的是转义字符中的内容必须是可打印字符。 - 支持转义符的功能从 2.3.0.1 版本开始。 - -## 密码合法字符集 - -`[a-zA-Z0-9!?$%^&*()_–+={[}]:;@~#|<,>.?/]` - -去掉了 `` ‘“`\ `` (单双引号、撇号、反斜杠、空格) - -- 数据库名：不能包含“.”以及特殊字符，不能超过 32 个字符 -- 表名：不能包含“.”以及特殊字符，与所属数据库名一起，不能超过 192 个字节 ，每行数据最大长度 48KB -- 表的列名：不能包含特殊字符，不能超过 64 个字节 -- 数据库名、表名、列名，都不能以数字开头，合法的可用字符集是“英文字符、数字和下划线” -- 表的列数：不能超过 1024 列，最少需要 2 列，第一列必须是时间戳（从 2.1.7.0 版本开始，改为最多支持 4096 列） -- 记录的最大长度：包括时间戳 8 字节，不能超过 48KB（每个 BINARY/NCHAR 类型的列还会额外占用 2 个 字节 的存储位置） -- 单条 SQL 语句默认最大字符串长度：1048576 字节，但可通过系统配置参数 maxSQLLength 修改，取值范围 65480 ~ 1048576 字节 -- 数据库副本数：不能超过 3 -- 用户名：不能超过 23 个 字节 -- 用户密码：不能超过 15 个 字节 -- 标签(Tags)数量：不能超过 128 个，可以 0 个 -- 标签的总长度：不能超过 16KB -- 记录条数：仅受存储空间限制 -- 表的个数：仅受节点个数限制 -- 库的个数：仅受节点个数限制 -- 单个库上虚拟节点个数：不能超过 64 个 -- 库的数目，超级表的数目、表的数目，系统不做限制，仅受系统资源限制 -- SELECT 语句的查询结果，最多允许返回 1024 列（语句中的函数调用可能也会占用一些列空间），超限时需要显式指定较少的返回数据列，以避免语句执行报错。（从 2.1.7.0 版本开始，改为最多允许 4096 列） - -## 保留关键字 - -目前 TDengine 有将近 200 个内部保留关键字，这些关键字无论大小写均不可以用作库名、表名、STable 名、数据列名及标签列名等。这些关键字列表如下： - -| 关键字列表 | | | | | -| ----------- | ---------- | --------- | ---------- | ------------ | -| ABORT | CREATE | IGNORE | NULL | STAR | -| ACCOUNT | CTIME | IMMEDIATE | OF | STATE | -| ACCOUNTS | DATABASE | IMPORT | OFFSET | STATEMENT | -| ADD | DATABASES | IN | OR | STATE_WINDOW | -| AFTER | DAYS | INITIALLY | ORDER | STORAGE | -| ALL | DBS | INSERT | PARTITIONS | STREAM | -| ALTER | DEFERRED | INSTEAD | PASS | STREAMS | -| AND | DELIMITERS | INT | PLUS | STRING | -| AS | DESC | INTEGER | PPS | SYNCDB | -| ASC | DESCRIBE | INTERVAL | PRECISION | TABLE | -| ATTACH | DETACH | INTO | PREV | TABLES | -| BEFORE | DISTINCT | IS | PRIVILEGE | TAG | -| BEGIN | DIVIDE | ISNULL | QTIME | TAGS | -| BETWEEN | DNODE | JOIN | QUERIES | TBNAME | -| BIGINT | DNODES | KEEP | QUERY | TIMES | -| BINARY | DOT | KEY | QUORUM | TIMESTAMP | -| BITAND | DOUBLE | KILL | RAISE | TINYINT | -| BITNOT | DROP | LE | REM | TOPIC | -| BITOR | EACH | LIKE | REPLACE | TOPICS | -| BLOCKS | END | LIMIT | REPLICA | TRIGGER | -| BOOL | EQ | LINEAR | RESET | TSERIES | -| BY | EXISTS | LOCAL | RESTRICT | UMINUS | -| CACHE | EXPLAIN | LP | ROW | UNION | -| CACHELAST | FAIL | LSHIFT | RP | UNSIGNED | -| CASCADE | FILE | LT | RSHIFT | UPDATE | -| CHANGE | FILL | MATCH | SCORES | UPLUS | -| CLUSTER | FLOAT | MAXROWS | SELECT | USE | -| COLON | FOR | MINROWS | SEMI | USER | -| COLUMN | FROM | MINUS | SESSION | USERS | -| COMMA | FSYNC | MNODES | SET | USING | -| COMP | GE | MODIFY | SHOW | VALUES | -| COMPACT | GLOB | MODULES | SLASH | VARIABLE | -| CONCAT | GRANTS | NCHAR | SLIDING | VARIABLES | -| CONFLICT | GROUP | NE | SLIMIT | VGROUPS | -| CONNECTION | GT | NONE | SMALLINT | VIEW | -| CONNECTIONS | HAVING | NOT | SOFFSET | VNODES | -| CONNS | ID | NOTNULL | STABLE | WAL | -| COPY | IF | NOW | STABLES | WHERE | -| _C0 | _QSTART | _QSTOP | _QDURATION | _WSTART | -| _WSTOP | _WDURATION | _ROWTS | - -## 特殊说明 -### TBNAME -`TBNAME` 可以视为超级表中一个特殊的标签，代表子表的表名。 - -获取一个超级表所有的子表名及相关的标签信息： -```mysql -SELECT TBNAME, location FROM meters; - -统计超级表下辖子表数量： -```mysql -SELECT COUNT(TBNAME) FROM meters; -``` - -以上两个查询均只支持在WHERE条件子句中添加针对标签（TAGS）的过滤条件。例如： -```mysql -taos> SELECT TBNAME, location FROM meters; - tbname | location | -================================================================== - d1004 | California.SanFrancisco | - d1003 | California.SanFrancisco | - d1002 | California.LosAngeles | - d1001 | California.LosAngeles | -Query OK, 4 row(s) in set (0.000881s) - -taos> SELECT COUNT(tbname) FROM meters WHERE groupId > 2; - count(tbname) | -======================== - 2 | -Query OK, 1 row(s) in set (0.001091s) -``` -### _QSTART/_QSTOP/_QDURATION -表示查询过滤窗口的起始，结束以及持续时间。 - -### _WSTART/_WSTOP/_WDURATION -窗口切分聚合查询（例如 interval/session window/state window）中表示每个切分窗口的起始，结束以及持续时间。 - -### _c0/_ROWTS -_c0 _ROWTS 等价，表示表或超级表的第一列 From bcfcc6baad78b1b10115a2149d23eab918e3b571 Mon Sep 17 00:00:00 2001 From: gccgdb1234 Date: Tue, 31 May 2022 16:28:11 +0800 Subject: [PATCH 21/28] docs: add 12-keywords.md --- docs-cn/12-taos-sql/12-keywords.md | 128 +++++++++++++++++++++++++++++ 1 file changed, 128 insertions(+) create mode 100644 docs-cn/12-taos-sql/12-keywords.md diff --git a/docs-cn/12-taos-sql/12-keywords.md b/docs-cn/12-taos-sql/12-keywords.md new file mode 100644 index 0000000000..0e8e1edfee --- /dev/null +++ b/docs-cn/12-taos-sql/12-keywords.md @@ -0,0 +1,128 @@ +--- +sidebar_label: 参数限制与保留关键字 +title: TDengine 参数限制与保留关键字 +--- + +## 名称命名规则 + +1. 合法字符：英文字符、数字和下划线 +2. 允许英文字符或下划线开头，不允许以数字开头 +3. 不区分大小写 +4. 转义后表（列）名规则： + 为了兼容支持更多形式的表（列）名，TDengine 引入新的转义符 "`"。可用让表名与关键词不冲突，同时不受限于上述表名称合法性约束检查。 + 转义后的表（列）名同样受到长度限制要求，且长度计算的时候不计算转义符。使用转义字符以后，不再对转义字符中的内容进行大小写统一。 + + 例如：\`aBc\` 和 \`abc\` 是不同的表（列）名，但是 abc 和 aBc 是相同的表（列）名。 + 需要注意的是转义字符中的内容必须是可打印字符。 + 支持转义符的功能从 2.3.0.1 版本开始。 + +## 密码合法字符集 + +`[a-zA-Z0-9!?$%^&*()_–+={[}]:;@~#|<,>.?/]` + +去掉了 `` ‘“`\ `` (单双引号、撇号、反斜杠、空格) + +- 数据库名：不能包含“.”以及特殊字符，不能超过 32 个字符 +- 表名：不能包含“.”以及特殊字符，与所属数据库名一起，不能超过 192 个字节 ，每行数据最大长度 48KB +- 表的列名：不能包含特殊字符，不能超过 64 个字节 +- 数据库名、表名、列名，都不能以数字开头，合法的可用字符集是“英文字符、数字和下划线” +- 表的列数：不能超过 1024 列，最少需要 2 列，第一列必须是时间戳（从 2.1.7.0 版本开始，改为最多支持 4096 列） +- 记录的最大长度：包括时间戳 8 字节，不能超过 48KB（每个 BINARY/NCHAR 类型的列还会额外占用 2 个 字节 的存储位置） +- 单条 SQL 语句默认最大字符串长度：1048576 字节，但可通过系统配置参数 maxSQLLength 修改，取值范围 65480 ~ 1048576 字节 +- 数据库副本数：不能超过 3 +- 用户名：不能超过 23 个 字节 +- 用户密码：不能超过 15 个 字节 +- 标签(Tags)数量：不能超过 128 个，可以 0 个 +- 标签的总长度：不能超过 16KB +- 记录条数：仅受存储空间限制 +- 表的个数：仅受节点个数限制 +- 库的个数：仅受节点个数限制 +- 单个库上虚拟节点个数：不能超过 64 个 +- 库的数目，超级表的数目、表的数目，系统不做限制，仅受系统资源限制 +- SELECT 语句的查询结果，最多允许返回 1024 列（语句中的函数调用可能也会占用一些列空间），超限时需要显式指定较少的返回数据列，以避免语句执行报错。（从 2.1.7.0 版本开始，改为最多允许 4096 列） + +## 保留关键字 + +目前 TDengine 有将近 200 个内部保留关键字，这些关键字无论大小写均不可以用作库名、表名、STable 名、数据列名及标签列名等。这些关键字列表如下： + +| 关键字列表 | | | | | +| ----------- | ---------- | --------- | ---------- | ------------ | +| ABORT | CREATE | IGNORE | NULL | STAR | +| ACCOUNT | CTIME | IMMEDIATE | OF | STATE | +| ACCOUNTS | DATABASE | IMPORT | OFFSET | STATEMENT | +| ADD | DATABASES | IN | OR | STATE_WINDOW | +| AFTER | DAYS | INITIALLY | ORDER | STORAGE | +| ALL | DBS | INSERT | PARTITIONS | STREAM | +| ALTER | DEFERRED | INSTEAD | PASS | STREAMS | +| AND | DELIMITERS | INT | PLUS | STRING | +| AS | DESC | INTEGER | PPS | SYNCDB | +| ASC | DESCRIBE | INTERVAL | PRECISION | TABLE | +| ATTACH | DETACH | INTO | PREV | TABLES | +| BEFORE | DISTINCT | IS | PRIVILEGE | TAG | +| BEGIN | DIVIDE | ISNULL | QTIME | TAGS | +| BETWEEN | DNODE | JOIN | QUERIES | TBNAME | +| BIGINT | DNODES | KEEP | QUERY | TIMES | +| BINARY | DOT | KEY | QUORUM | TIMESTAMP | +| BITAND | DOUBLE | KILL | RAISE | TINYINT | +| BITNOT | DROP | LE | REM | TOPIC | +| BITOR | EACH | LIKE | REPLACE | TOPICS | +| BLOCKS | END | LIMIT | REPLICA | TRIGGER | +| BOOL | EQ | LINEAR | RESET | TSERIES | +| BY | EXISTS | LOCAL | RESTRICT | UMINUS | +| CACHE | EXPLAIN | LP | ROW | UNION | +| CACHELAST | FAIL | LSHIFT | RP | UNSIGNED | +| CASCADE | FILE | LT | RSHIFT | UPDATE | +| CHANGE | FILL | MATCH | SCORES | UPLUS | +| CLUSTER | FLOAT | MAXROWS | SELECT | USE | +| COLON | FOR | MINROWS | SEMI | USER | +| COLUMN | FROM | MINUS | SESSION | USERS | +| COMMA | FSYNC | MNODES | SET | USING | +| COMP | GE | MODIFY | SHOW | VALUES | +| COMPACT | GLOB | MODULES | SLASH | VARIABLE | +| CONCAT | GRANTS | NCHAR | SLIDING | VARIABLES | +| CONFLICT | GROUP | NE | SLIMIT | VGROUPS | +| CONNECTION | GT | NONE | SMALLINT | VIEW | +| CONNECTIONS | HAVING | NOT | SOFFSET | VNODES | +| CONNS | ID | NOTNULL | STABLE | WAL | +| COPY | IF | NOW | STABLES | WHERE | +| _C0 | _QSTART | _QSTOP | _QDURATION | _WSTART | +| _WSTOP | _WDURATION | _ROWTS | + +## 特殊说明 +### TBNAME +`TBNAME` 可以视为超级表中一个特殊的标签，代表子表的表名。 + +获取一个超级表所有的子表名及相关的标签信息： +```mysql +SELECT TBNAME, location FROM meters; + +统计超级表下辖子表数量： +```mysql +SELECT COUNT(TBNAME) FROM meters; +``` + +以上两个查询均只支持在WHERE条件子句中添加针对标签（TAGS）的过滤条件。例如： +```mysql +taos> SELECT TBNAME, location FROM meters; + tbname | location | +================================================================== + d1004 | California.SanFrancisco | + d1003 | California.SanFrancisco | + d1002 | California.LosAngeles | + d1001 | California.LosAngeles | +Query OK, 4 row(s) in set (0.000881s) + +taos> SELECT COUNT(tbname) FROM meters WHERE groupId > 2; + count(tbname) | +======================== + 2 | +Query OK, 1 row(s) in set (0.001091s) +``` +### _QSTART/_QSTOP/_QDURATION +表示查询过滤窗口的起始，结束以及持续时间。 + +### _WSTART/_WSTOP/_WDURATION +窗口切分聚合查询（例如 interval/session window/state window）中表示每个切分窗口的起始，结束以及持续时间。 + +### _c0/_ROWTS +_c0 _ROWTS 等价，表示表或超级表的第一列 From f8d29a12abc223f0a3b963725d44a6147919813a Mon Sep 17 00:00:00 2001 From: plum-lihui Date: Tue, 31 May 2022 16:46:01 +0800 Subject: [PATCH 22/28] test: support taosc run by valgrind to python cases --- tests/pytest/util/dnodes.py | 38 +++++++++++++++++++++---------------- tests/system-test/test.py | 10 ++++++++-- 2 files changed, 30 insertions(+), 18 deletions(-) diff --git a/tests/pytest/util/dnodes.py b/tests/pytest/util/dnodes.py index b8cb73cb44..2e11b93e5f 100644 --- a/tests/pytest/util/dnodes.py +++ b/tests/pytest/util/dnodes.py @@ -494,6 +494,7 @@ class TDDnodes: self.simDeployed = False self.testCluster = False self.valgrind = 0 + self.killValgrind = 1 def init(self, path, remoteIP = ""): psCmd = "ps -ef|grep -w taosd| grep -v grep| grep -v defunct | awk '{print $2}'" @@ -505,14 +506,15 @@ class TDDnodes: processID = subprocess.check_output( psCmd, shell=True).decode("utf-8") - psCmd = "ps -ef|grep -w valgrind.bin| grep -v grep | awk '{print $2}'" - processID = subprocess.check_output(psCmd, shell=True).decode("utf-8") - while(processID): - killCmd = "kill -9 %s > /dev/null 2>&1" % processID - os.system(killCmd) - time.sleep(1) - processID = subprocess.check_output( - psCmd, shell=True).decode("utf-8") + if self.killValgrind == 1: + psCmd = "ps -ef|grep -w valgrind.bin| grep -v grep | awk '{print $2}'" + processID = subprocess.check_output(psCmd, shell=True).decode("utf-8") + while(processID): + killCmd = "kill -9 %s > /dev/null 2>&1" % processID + os.system(killCmd) + time.sleep(1) + processID = subprocess.check_output( + psCmd, shell=True).decode("utf-8") binPath = self.dnodes[0].getPath() + "/../../../" # tdLog.debug("binPath %s" % (binPath)) @@ -549,6 +551,9 @@ class TDDnodes: def setValgrind(self, value): self.valgrind = value + def setKillValgrind(self, value): + self.killValgrind = value + def deploy(self, index, *updatecfgDict): self.sim.setTestCluster(self.testCluster) @@ -622,14 +627,15 @@ class TDDnodes: processID = subprocess.check_output( psCmd, shell=True).decode("utf-8") - psCmd = "ps -ef|grep -w valgrind.bin| grep -v grep | awk '{print $2}'" - processID = subprocess.check_output(psCmd, shell=True).decode("utf-8") - while(processID): - killCmd = "kill -TERM %s > /dev/null 2>&1" % processID - os.system(killCmd) - time.sleep(1) - processID = subprocess.check_output( - psCmd, shell=True).decode("utf-8") + if self.killValgrind == 1: + psCmd = "ps -ef|grep -w valgrind.bin| grep -v grep | awk '{print $2}'" + processID = subprocess.check_output(psCmd, shell=True).decode("utf-8") + while(processID): + killCmd = "kill -TERM %s > /dev/null 2>&1" % processID + os.system(killCmd) + time.sleep(1) + processID = subprocess.check_output( + psCmd, shell=True).decode("utf-8") # if os.system(cmd) != 0 : # tdLog.exit(cmd) diff --git a/tests/system-test/test.py b/tests/system-test/test.py index 6b6487918c..a11085708c 100644 --- a/tests/system-test/test.py +++ b/tests/system-test/test.py @@ -37,6 +37,7 @@ if __name__ == "__main__": masterIp = "" testCluster = False valgrind = 0 + killValgrind = 1 logSql = True stop = 0 restart = False @@ -45,8 +46,8 @@ if __name__ == "__main__": windows = 1 updateCfgDict = {} execCmd = "" - opts, args = getopt.gnu_getopt(sys.argv[1:], 'f:p:m:l:scghrd:e:', [ - 'file=', 'path=', 'master', 'logSql', 'stop', 'cluster', 'valgrind', 'help', 'restart', 'updateCfgDict', 'execCmd']) + opts, args = getopt.gnu_getopt(sys.argv[1:], 'f:p:m:l:scghrd:k:e:', [ + 'file=', 'path=', 'master', 'logSql', 'stop', 'cluster', 'valgrind', 'help', 'restart', 'updateCfgDict', 'killv', 'execCmd']) for key, value in opts: if key in ['-h', '--help']: tdLog.printNoPrefix( @@ -60,6 +61,7 @@ if __name__ == "__main__": tdLog.printNoPrefix('-g valgrind Test Flag') tdLog.printNoPrefix('-r taosd restart test') tdLog.printNoPrefix('-d update cfg dict, base64 json str') + tdLog.printNoPrefix('-k not kill valgrind processer') tdLog.printNoPrefix('-e eval str to run') sys.exit(0) @@ -100,6 +102,9 @@ if __name__ == "__main__": print('updateCfgDict convert fail.') sys.exit(0) + if key in ['-k', '--killValgrind']: + killValgrind = 0 + if key in ['-e', '--execCmd']: try: execCmd = base64.b64decode(value.encode()).decode() @@ -189,6 +194,7 @@ if __name__ == "__main__": else: tdCases.runAllWindows(conn) else: + tdDnodes.setKillValgrind(killValgrind) tdDnodes.init(deployPath, masterIp) tdDnodes.setTestCluster(testCluster) tdDnodes.setValgrind(valgrind) From 18ca6d93e7dc0af7dd530b8db8ce6f2e50eaadbb Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Tue, 31 May 2022 16:55:16 +0800 Subject: [PATCH 23/28] refactor: make trans support multi steps --- source/dnode/mnode/impl/inc/mndDef.h | 2 +- source/dnode/mnode/impl/inc/mndTrans.h | 2 +- source/dnode/mnode/impl/src/mndMnode.c | 4 +- source/dnode/mnode/impl/src/mndSma.c | 2 +- source/dnode/mnode/impl/src/mndTrans.c | 114 ++++++++++++++----------- 5 files changed, 70 insertions(+), 54 deletions(-) diff --git a/source/dnode/mnode/impl/inc/mndDef.h b/source/dnode/mnode/impl/inc/mndDef.h index fd0f54c66b..9a60ad860f 100644 --- a/source/dnode/mnode/impl/inc/mndDef.h +++ b/source/dnode/mnode/impl/inc/mndDef.h @@ -129,7 +129,7 @@ typedef enum { typedef enum { TRN_EXEC_PARALLEL = 0, - TRN_EXEC_ONE_BY_ONE = 1, + TRN_EXEC_NO_PARALLEL = 1, } ETrnExecType; typedef enum { diff --git a/source/dnode/mnode/impl/inc/mndTrans.h b/source/dnode/mnode/impl/inc/mndTrans.h index a7e1f7cd02..ba6f5faf1e 100644 --- a/source/dnode/mnode/impl/inc/mndTrans.h +++ b/source/dnode/mnode/impl/inc/mndTrans.h @@ -62,7 +62,7 @@ int32_t mndTransAppendUndoAction(STrans *pTrans, STransAction *pAction); void mndTransSetRpcRsp(STrans *pTrans, void *pCont, int32_t contLen); void mndTransSetCb(STrans *pTrans, ETrnFunc startFunc, ETrnFunc stopFunc, void *param, int32_t paramLen); void mndTransSetDbInfo(STrans *pTrans, SDbObj *pDb); -void mndTransSetExecOneByOne(STrans *pTrans); +void mndTransSetNoParallel(STrans *pTrans); int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans); void mndTransProcessRsp(SRpcMsg *pRsp); diff --git a/source/dnode/mnode/impl/src/mndMnode.c b/source/dnode/mnode/impl/src/mndMnode.c index 8c5ea840af..5b8ba6deaa 100644 --- a/source/dnode/mnode/impl/src/mndMnode.c +++ b/source/dnode/mnode/impl/src/mndMnode.c @@ -367,7 +367,7 @@ static int32_t mndCreateMnode(SMnode *pMnode, SRpcMsg *pReq, SDnodeObj *pDnode, if (pTrans == NULL) goto _OVER; mDebug("trans:%d, used to create mnode:%d", pTrans->id, pCreate->dnodeId); - mndTransSetExecOneByOne(pTrans); + mndTransSetNoParallel(pTrans); if (mndSetCreateMnodeRedoLogs(pMnode, pTrans, &mnodeObj) != 0) goto _OVER; if (mndSetCreateMnodeCommitLogs(pMnode, pTrans, &mnodeObj) != 0) goto _OVER; if (mndSetCreateMnodeRedoActions(pMnode, pTrans, pDnode, &mnodeObj) != 0) goto _OVER; @@ -539,7 +539,7 @@ static int32_t mndDropMnode(SMnode *pMnode, SRpcMsg *pReq, SMnodeObj *pObj) { if (pTrans == NULL) goto _OVER; mDebug("trans:%d, used to drop mnode:%d", pTrans->id, pObj->id); - mndTransSetExecOneByOne(pTrans); + mndTransSetNoParallel(pTrans); if (mndSetDropMnodeRedoLogs(pMnode, pTrans, pObj) != 0) goto _OVER; if (mndSetDropMnodeCommitLogs(pMnode, pTrans, pObj) != 0) goto _OVER; if (mndSetDropMnodeRedoActions(pMnode, pTrans, pObj->pDnode, pObj) != 0) goto _OVER; diff --git a/source/dnode/mnode/impl/src/mndSma.c b/source/dnode/mnode/impl/src/mndSma.c index 7b5d1b6c32..0493b00d33 100644 --- a/source/dnode/mnode/impl/src/mndSma.c +++ b/source/dnode/mnode/impl/src/mndSma.c @@ -507,7 +507,7 @@ static int32_t mndCreateSma(SMnode *pMnode, SRpcMsg *pReq, SMCreateSmaReq *pCrea mDebug("trans:%d, used to create sma:%s", pTrans->id, pCreate->name); mndTransSetDbInfo(pTrans, pDb); - mndTransSetExecOneByOne(pTrans); + mndTransSetNoParallel(pTrans); if (mndSetCreateSmaRedoLogs(pMnode, pTrans, &smaObj) != 0) goto _OVER; if (mndSetCreateSmaVgroupRedoLogs(pMnode, pTrans, &streamObj.fixedSinkVg) != 0) goto _OVER; diff --git a/source/dnode/mnode/impl/src/mndTrans.c b/source/dnode/mnode/impl/src/mndTrans.c index c5a1e0ba5a..ad6388c585 100644 --- a/source/dnode/mnode/impl/src/mndTrans.c +++ b/source/dnode/mnode/impl/src/mndTrans.c @@ -120,8 +120,8 @@ static SSdbRaw *mndTransActionEncode(STrans *pTrans) { SDB_SET_INT16(pRaw, dataPos, pTrans->type, _OVER) SDB_SET_INT16(pRaw, dataPos, pTrans->parallel, _OVER) SDB_SET_INT64(pRaw, dataPos, pTrans->createdTime, _OVER) - SDB_SET_INT64(pRaw, dataPos, pTrans->dbUid, _OVER) SDB_SET_BINARY(pRaw, dataPos, pTrans->dbname, TSDB_DB_FNAME_LEN, _OVER) + SDB_SET_INT32(pRaw, dataPos, pTrans->redoActionPos, _OVER) int32_t redoActionNum = taosArrayGetSize(pTrans->redoActions); int32_t undoActionNum = taosArrayGetSize(pTrans->undoActions); @@ -261,8 +261,8 @@ static SSdbRow *mndTransActionDecode(SSdbRaw *pRaw) { pTrans->type = type; pTrans->parallel = parallel; SDB_GET_INT64(pRaw, dataPos, &pTrans->createdTime, _OVER) - SDB_GET_INT64(pRaw, dataPos, &pTrans->dbUid, _OVER) SDB_GET_BINARY(pRaw, dataPos, pTrans->dbname, TSDB_DB_FNAME_LEN, _OVER) + SDB_GET_INT32(pRaw, dataPos, &pTrans->redoActionPos, _OVER) SDB_GET_INT32(pRaw, dataPos, &redoActionNum, _OVER) SDB_GET_INT32(pRaw, dataPos, &undoActionNum, _OVER) SDB_GET_INT32(pRaw, dataPos, &commitActionNum, _OVER) @@ -567,6 +567,7 @@ static int32_t mndTransActionUpdate(SSdb *pSdb, STrans *pOld, STrans *pNew) { mndTransUpdateActions(pOld->undoActions, pNew->undoActions); mndTransUpdateActions(pOld->commitActions, pNew->commitActions); pOld->stage = pNew->stage; + pOld->redoActionPos = pNew->redoActionPos; if (pOld->stage == TRN_STAGE_COMMIT) { pOld->stage = TRN_STAGE_COMMIT_ACTION; @@ -694,11 +695,10 @@ void mndTransSetCb(STrans *pTrans, ETrnFunc startFunc, ETrnFunc stopFunc, void * } void mndTransSetDbInfo(STrans *pTrans, SDbObj *pDb) { - pTrans->dbUid = pDb->uid; memcpy(pTrans->dbname, pDb->name, TSDB_DB_FNAME_LEN); } -void mndTransSetExecOneByOne(STrans *pTrans) { pTrans->parallel = TRN_EXEC_ONE_BY_ONE; } +void mndTransSetNoParallel(STrans *pTrans) { pTrans->parallel = TRN_EXEC_NO_PARALLEL; } static int32_t mndTransSync(SMnode *pMnode, STrans *pTrans) { SSdbRaw *pRaw = mndTransActionEncode(pTrans); @@ -708,7 +708,7 @@ static int32_t mndTransSync(SMnode *pMnode, STrans *pTrans) { } sdbSetRawStatus(pRaw, SDB_STATUS_READY); - mDebug("trans:%d, sync to other nodes", pTrans->id); + mDebug("trans:%d, sync to other mnodes", pTrans->id); int32_t code = mndSyncPropose(pMnode, pRaw, pTrans->id); if (code != 0) { mError("trans:%d, failed to sync since %s", pTrans->id, terrstr()); @@ -761,7 +761,7 @@ static bool mndCheckTransConflict(SMnode *pMnode, STrans *pNewTrans) { mError("trans:%d, can't execute since trans:%d in progress", pNewTrans->id, pTrans->id); conflict = true; } else if (mndIsDbTrans(pTrans) || mndIsStbTrans(pTrans)) { - if (pNewTrans->dbUid == pTrans->dbUid) { + if (strcmp(pNewTrans->dbname, pTrans->dbname) == 0) { mError("trans:%d, can't execute since trans:%d in progress db:%s", pNewTrans->id, pTrans->id, pTrans->dbname); conflict = true; } @@ -774,7 +774,7 @@ static bool mndCheckTransConflict(SMnode *pMnode, STrans *pNewTrans) { mError("trans:%d, can't execute since trans:%d in progress", pNewTrans->id, pTrans->id); conflict = true; } else if (mndIsDbTrans(pTrans)) { - if (pNewTrans->dbUid == pTrans->dbUid) { + if (strcmp(pNewTrans->dbname, pTrans->dbname) == 0) { mError("trans:%d, can't execute since trans:%d in progress db:%s", pNewTrans->id, pTrans->id, pTrans->dbname); conflict = true; } @@ -856,7 +856,7 @@ static void mndTransSendRpcRsp(SMnode *pMnode, STrans *pTrans) { } if (pTrans->policy == TRN_POLICY_ROLLBACK) { - if (pTrans->stage == pTrans->stage == TRN_STAGE_UNDO_ACTION || pTrans->stage == TRN_STAGE_ROLLBACK) { + if (pTrans->stage == TRN_STAGE_UNDO_ACTION || pTrans->stage == TRN_STAGE_ROLLBACK) { if (code == 0) code = TSDB_CODE_MND_TRANS_UNKNOW_ERROR; sendRsp = true; } @@ -876,12 +876,7 @@ static void mndTransSendRpcRsp(SMnode *pMnode, STrans *pTrans) { mDebug("trans:%d, send rsp, code:0x%x stage:%s app:%p", pTrans->id, code, mndTransStr(pTrans->stage), pTrans->rpcInfo.ahandle); - SRpcMsg rspMsg = { - .code = code, - .pCont = rpcCont, - .contLen = pTrans->rpcRspLen, - .info = pTrans->rpcInfo, - }; + SRpcMsg rspMsg = {.code = code, .pCont = rpcCont, .contLen = pTrans->rpcRspLen, .info = pTrans->rpcInfo}; tmsgSendRsp(&rspMsg); pTrans->rpcInfo.handle = NULL; pTrans->rpcRsp = NULL; @@ -944,7 +939,6 @@ static void mndTransResetActions(SMnode *pMnode, STrans *pTrans, SArray *pArray) for (int32_t action = 0; action < numOfActions; ++action) { STransAction *pAction = taosArrayGet(pArray, action); - if (pAction == NULL) continue; if (pAction->msgSent && pAction->msgReceived && (pAction->errCode == 0 || pAction->errCode == pAction->acceptableCode)) continue; @@ -1017,16 +1011,14 @@ static int32_t mndTransExecSingleAction(SMnode *pMnode, STrans *pTrans, STransAc } } -static int32_t mndTransSendActionMsg(SMnode *pMnode, STrans *pTrans, SArray *pArray) { +static int32_t mndTransExecSingleActions(SMnode *pMnode, STrans *pTrans, SArray *pArray) { int32_t numOfActions = taosArrayGetSize(pArray); int32_t code = 0; for (int32_t action = 0; action < numOfActions; ++action) { STransAction *pAction = taosArrayGet(pArray, action); code = mndTransExecSingleAction(pMnode, pTrans, pAction); - if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) { - break; - } + if (code != 0) break; } return code; @@ -1036,7 +1028,7 @@ static int32_t mndTransExecuteActions(SMnode *pMnode, STrans *pTrans, SArray *pA int32_t numOfActions = taosArrayGetSize(pArray); if (numOfActions == 0) return 0; - if (mndTransSendActionMsg(pMnode, pTrans, pArray) != 0) { + if (mndTransExecSingleActions(pMnode, pTrans, pArray) != 0) { return -1; } @@ -1044,8 +1036,7 @@ static int32_t mndTransExecuteActions(SMnode *pMnode, STrans *pTrans, SArray *pA int32_t errCode = 0; for (int32_t action = 0; action < numOfActions; ++action) { STransAction *pAction = taosArrayGet(pArray, action); - if (pAction == NULL) continue; - if ((pAction->msgSent && pAction->msgReceived) || pAction->rawWritten) { + if (pAction->msgReceived || pAction->rawWritten) { numOfExecuted++; if (pAction->errCode != 0 && pAction->errCode != pAction->acceptableCode) { errCode = pAction->errCode; @@ -1087,12 +1078,61 @@ static int32_t mndTransExecuteUndoActions(SMnode *pMnode, STrans *pTrans) { static int32_t mndTransExecuteCommitActions(SMnode *pMnode, STrans *pTrans) { int32_t code = mndTransExecuteActions(pMnode, pTrans, pTrans->commitActions); - if (code != 0) { + if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) { mError("failed to execute commitActions since %s", terrstr()); } return code; } +static int32_t mndTransExecuteRedoActionsNoParallel(SMnode *pMnode, STrans *pTrans) { + int32_t code = 0; + int32_t numOfActions = taosArrayGetSize(pTrans->redoActions); + if (numOfActions == 0) return code; + if (pTrans->redoActionPos >= numOfActions) return code; + + for (int32_t action = pTrans->redoActionPos; action < numOfActions; ++action) { + STransAction *pAction = taosArrayGet(pTrans->redoActions, pTrans->redoActionPos); + + code = mndTransExecSingleAction(pMnode, pTrans, pAction); + if (code == 0) { + if (pAction->msgSent) { + if (pAction->msgReceived) { + if (pAction->errCode != 0 && pAction->errCode != pAction->acceptableCode) { + code = pAction->errCode; + } + } else { + code = TSDB_CODE_ACTION_IN_PROGRESS; + } + } + if (pAction->rawWritten) { + if (pAction->errCode != 0 && pAction->errCode != pAction->acceptableCode) { + code = pAction->errCode; + } + } + } + + if (code == 0) { + pTrans->redoActionPos++; + mDebug("trans:%d, %s:%d is executed and need sync to other mnodes", pTrans->id, mndTransStr(pAction->stage), + pAction->id); + code = mndTransSync(pMnode, pTrans); + if (code != 0) { + mError("trans:%d, failed to sync redoActionPos since %s", pTrans->id, terrstr()); + break; + } + } else if (code == TSDB_CODE_ACTION_IN_PROGRESS) { + mDebug("trans:%d, %s:%d is in progress and wait it finish", pTrans->id, mndTransStr(pAction->stage), pAction->id); + break; + } else { + mError("trans:%d, %s:%d failed to execute since %s", pTrans->id, mndTransStr(pAction->stage), pAction->id, + terrstr()); + break; + } + } + + return code; +} + static bool mndTransPerformPrepareStage(SMnode *pMnode, STrans *pTrans) { bool continueExec = true; pTrans->stage = TRN_STAGE_REDO_ACTION; @@ -1100,36 +1140,12 @@ static bool mndTransPerformPrepareStage(SMnode *pMnode, STrans *pTrans) { return continueExec; } -static bool mndTransExecuteRedoActionsOneByOne(SMnode *pMnode, STrans *pTrans) { - bool continueExec = true; - if (pTrans->redoActionPos >= taosArrayGetSize(pTrans->redoActions)) return continueExec; - - STransAction *pAction = taosArrayGet(pTrans->redoActions, pTrans->redoActionPos); - int32_t code = mndTransExecSingleAction(pMnode, pTrans, pAction); - if (code == 0) { - pTrans->redoActionPos++; - mDebug("trans:%d, %s:%d is executed and need sync to other mnodes", pTrans->id, mndTransStr(pAction->stage), - pAction->id); - - // todo sync these infos - } else if (code == TSDB_CODE_ACTION_IN_PROGRESS) { - mDebug("trans:%d, %s:%d is in progress and wait it finish", pTrans->id, mndTransStr(pAction->stage), pAction->id); - continueExec = false; - } else { - mError("trans:%d, %s:%d failed to execute since %s", pTrans->id, mndTransStr(pAction->stage), pAction->id, - terrstr()); - continueExec = false; - } - - return continueExec; -} - static bool mndTransPerformRedoActionStage(SMnode *pMnode, STrans *pTrans) { bool continueExec = true; int32_t code = 0; - if (pTrans->parallel == TRN_EXEC_ONE_BY_ONE) { - code = mndTransExecuteRedoActionsOneByOne(pMnode, pTrans); + if (pTrans->parallel == TRN_EXEC_NO_PARALLEL) { + code = mndTransExecuteRedoActionsNoParallel(pMnode, pTrans); } else { code = mndTransExecuteRedoActions(pMnode, pTrans); } From d595b5a0808e2ce586bc7039104b998b785ebc5b Mon Sep 17 00:00:00 2001 From: Zhengmao Zhu <70138133+fenghuazzm@users.noreply.github.com> Date: Tue, 31 May 2022 16:05:24 +0800 Subject: [PATCH 24/28] docs: Correction of typos in the taosdump page --- docs-cn/14-reference/06-taosdump.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs-cn/14-reference/06-taosdump.md b/docs-cn/14-reference/06-taosdump.md index 7131493ec9..3a9f2e9acd 100644 --- a/docs-cn/14-reference/06-taosdump.md +++ b/docs-cn/14-reference/06-taosdump.md @@ -38,7 +38,7 @@ taosdump 有两种安装方式: :::tip - taosdump 1.4.1 之后的版本提供 `-I` 参数，用于解析 avro 文件 schema 和数据，如果指定 `-s` 参数将只解析 schema。 -- taosdump 1.4.2 之后的备份使用 `-B` 参数指定的批次数，默认值为 16384，如果在某些环境下由于网络速度或磁盘性能不足导致 "Error actual dump .. batch .." 可以通过 `-B` 参数挑战为更小的值进行尝试。 +- taosdump 1.4.2 之后的备份使用 `-B` 参数指定的批次数，默认值为 16384，如果在某些环境下由于网络速度或磁盘性能不足导致 "Error actual dump .. batch .." 可以通过 `-B` 参数调整为更小的值进行尝试。 ::: From 3eb4afd82e81ab1bdeb98faff6291da8d6ec5c51 Mon Sep 17 00:00:00 2001 From: tomchon Date: Tue, 31 May 2022 17:06:33 +0800 Subject: [PATCH 25/28] test:modify testcase of python connector using Statement API --- .../1-insert/test_stmt_insert_query_ex.py | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/tests/system-test/1-insert/test_stmt_insert_query_ex.py b/tests/system-test/1-insert/test_stmt_insert_query_ex.py index 1a286ceadc..376b60d615 100644 --- a/tests/system-test/1-insert/test_stmt_insert_query_ex.py +++ b/tests/system-test/1-insert/test_stmt_insert_query_ex.py @@ -213,7 +213,7 @@ class TDTestCase: params[11].float([3, None, 1]) params[12].double([3, None, 1.2]) params[13].binary(["abc", "dddafadfadfadfadfa", None]) - params[14].nchar(["涛思数据", None, "a long string with 中文字符"]) + params[14].nchar(["涛思数据", None, "a? long string with 中文字符"]) params[15].timestamp([None, None, 1626861392591]) stmt.bind_param_batch(params) @@ -230,17 +230,28 @@ class TDTestCase: querystmt1.execute() result1=querystmt1.use_result() rows1=result1.fetch_all() - print(rows1) + print("1",rows1) + querystmt2=conn.statement("select abs(?) from log where bu < ?") queryparam2=new_bind_params(2) - print(type(queryparam1)) + print(type(queryparam2)) queryparam2[0].int(5) queryparam2[1].int(5) querystmt2.bind_param(queryparam2) querystmt2.execute() result2=querystmt2.use_result() rows2=result2.fetch_all() - print(rows2) + print("2",rows2) + + querystmt3=conn.statement("select abs(?) from log where nn= 'a? long string with 中文字符' ") + queryparam3=new_bind_params(1) + print(type(queryparam3)) + queryparam3[0].int(5) + querystmt3.bind_param(queryparam3) + querystmt3.execute() + result3=querystmt3.use_result() + rows3=result3.fetch_all() + print("3",rows3) # assert str(rows1[0][0]) == "2021-07-21 17:56:32.589111" # assert rows1[0][10] == 3 # assert rows1[1][10] == 4 From 870f24a0c9ee7a29d78686cbea97e0e65a54a36e Mon Sep 17 00:00:00 2001 From: 54liuyao <54liuyao@163.com> Date: Tue, 31 May 2022 17:15:43 +0800 Subject: [PATCH 26/28] feat(stream):adjust bloom filter --- source/libs/stream/src/tstreamUpdate.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/libs/stream/src/tstreamUpdate.c b/source/libs/stream/src/tstreamUpdate.c index 6935355a93..ada391b40a 100644 --- a/source/libs/stream/src/tstreamUpdate.c +++ b/source/libs/stream/src/tstreamUpdate.c @@ -42,7 +42,7 @@ static void windowSBfAdd(SUpdateInfo *pInfo, uint64_t count) { } static void windowSBfDelete(SUpdateInfo *pInfo, uint64_t count) { - if (count < pInfo->numSBFs - 1) { + if (count < pInfo->numSBFs) { for (uint64_t i = 0; i < count; ++i) { SScalableBf *pTsSBFs = taosArrayGetP(pInfo->pTsSBFs, 0); tScalableBfDestroy(pTsSBFs); From aa6569fa690ec474a2e280b5bd1e007a2e6a84b1 Mon Sep 17 00:00:00 2001 From: gccgdb1234 Date: Tue, 31 May 2022 17:28:54 +0800 Subject: [PATCH 27/28] docs: add chapter for operators --- docs-cn/12-taos-sql/07-function.md | 29 ------------ docs-cn/12-taos-sql/13-operators.md | 71 +++++++++++++++++++++++++++++ 2 files changed, 71 insertions(+), 29 deletions(-) create mode 100644 docs-cn/12-taos-sql/13-operators.md diff --git a/docs-cn/12-taos-sql/07-function.md b/docs-cn/12-taos-sql/07-function.md index 2349e6aa3c..b924aad042 100644 --- a/docs-cn/12-taos-sql/07-function.md +++ b/docs-cn/12-taos-sql/07-function.md @@ -1464,35 +1464,6 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause]; - 该函数适用于内层查询和外层查询。 - 版本2.6.0.x后支持 -### 四则运算 - -``` -SELECT field_name [+|-|*|/|%][Value|field_name] FROM { tb_name | stb_name } [WHERE clause]; -``` - -**功能说明**：统计表/超级表中某列或多列间的值加、减、乘、除、取余计算结果。 - -**返回数据类型**：双精度浮点数。 - -**应用字段**：不能应用在 timestamp、binary、nchar、bool 类型字段。 - -**适用于**：表、超级表。 - -**使用说明**： - -- 支持两列或多列之间进行计算，可使用括号控制计算优先级； -- NULL 字段不参与计算，如果参与计算的某行中包含 NULL，该行的计算结果为 NULL。 - -``` -taos> SELECT current + voltage * phase FROM d1001; -(current+(voltage*phase)) | -============================ - 78.190000713 | - 84.540003240 | - 80.810000718 | -Query OK, 3 row(s) in set (0.001046s) -``` - ### STATECOUNT ``` diff --git a/docs-cn/12-taos-sql/13-operators.md b/docs-cn/12-taos-sql/13-operators.md new file mode 100644 index 0000000000..4480988286 --- /dev/null +++ b/docs-cn/12-taos-sql/13-operators.md @@ -0,0 +1,71 @@ +--- +sidebar_label: 运算符 +title: 运算符 +--- + +## 算术运算符 + +| # | **运算符** | **支持的类型** | **说明** | +| --- | :--------: | -------------- | -------------------------- | +| 1 | +, - | 数值类型 | 表达正数和负数，一元运算符 | +| 2 | +, - | 数值类型 | 表示加法和减法，二元运算符 | +| 3 | \*, / | 数值类型 | 表示乘法和除法，二元运算符 | +| 4 | % | 数值类型 | 表示取余运算，二元运算符 | + +## 位运算符 + +| # | **运算符** | **支持的类型** | **说明** | +| --- | :--------: | -------------- | ------------------ | +| 1 | & | 数值类型 | 按位与，二元运算符 | +| 2 | \| | 数值类型 | 按位或，二元运算符 | + +## JSON 运算符 + +`->` 运算符可以对 JSON 类型的列按键取值。->左侧是列标识符，右侧是键的字符串常量，如 col->'name'，返回键'name'的值。 + +## 集合运算符 + +集合运算符将两个查询的结果合并为一个结果。包含集合运算符的查询称之为复合查询。复合查询中每条查询的选择列表中的相应表达式在数量上必须匹配，并且必须位于同一数据类型组中（如数值类型或字符串类型）。 + +- 对于字符串类型数据，返回值的数据类型按如下方式确定： + - 如果具有相同的类型（都为 BINARY 或都为 NCHAR），则返回此类型，并以较大的长度作为返回值长度。 + - 如果具有不同的类型，则返回 BINARY 类型，并以较大的长度（NCHAR 类型长度按四倍计算）作为返回值长度。 +- 对于数值类型数据，返回值的数据类型是数字表达范围较大的那个。 + +TDengine 支持 `UNION ALL` 操作符。UNION ALL 将查询返回的结果集合并返回，并不去重。在同一个 SQL 语句中，UNION ALL 最多支持 100 个。 + +## 比较运算符 + +| # | **运算符** | **支持的类型** | **说明** | +| --- | :---------------: | -------------------------------------------------------------------- | -------------------- | +| 1 | = | 除 BLOB、MEDIUMBLOB 和 JSON 外的所有类型 | 相等 | +| 2 | <\>, != | 除 BLOB、MEDIUMBLOB 和 JSON 外的所有类型，且不可以为表的时间戳主键列 | 不相等 | +| 3 | \>, \< | 除 BLOB、MEDIUMBLOB 和 JSON 外的所有类型 | 大于，小于 | +| 4 | \>=, \<= | 除 BLOB、MEDIUMBLOB 和 JSON 外的所有类型 | 大于等于，小于等于 | +| 5 | IS [NOT] NULL | 所有类型 | 是否为空值 | +| 6 | [NOT] BETWEEN AND | 除 BOOL、BLOB、MEDIUMBLOB 和 JSON 外的所有类型 | 闭区间比较 | +| 7 | IN | 除 BLOB、MEDIUMBLOB 和 JSON 外的所有类型，且不可以为表的时间戳主键列 | 与列表内的任意值相等 | +| 8 | LIKE | BINARY、NCHAR 和 VARCHAR | 通配符匹配 | +| 9 | MATCH, NMATCH | BINARY、NCHAR 和 VARCHAR | 正则表达式匹配 | +| 10 | CONTAINS | JSON | JSON 中是否存在某键 | + +LIKE 条件使用通配符字符串进行匹配检查，规则如下： + +- '%'（百分号）匹配 0 到任意个字符；'\_'（下划线）匹配单个任意 ASCII 字符。 +- 如果希望匹配字符串中原本就带有的 \_（下划线）字符，那么可以在通配符字符串中写作 \_，即加一个反斜线来进行转义。 +- 通配符字符串最长不能超过 100 字节。不建议使用太长的通配符字符串，否则将有可能严重影响 LIKE 操作的执行性能。 + +MATCH 条件和 NMATCH 条件使用正则表达式进行匹配，规则如下： + +- 支持符合 POSIX 规范的正则表达式，具体规范内容可参见 Regular Expressions。 +- 只能针对子表名（即 tbname）、字符串类型的标签值进行正则表达式过滤，不支持普通列的过滤。 +- 正则匹配字符串长度不能超过 128 字节。可以通过参数 maxRegexStringLen 设置和调整最大允许的正则匹配字符串，该参数是客户端配置参数，需要重启客户端才能生效 + +## 逻辑运算符 + +| # | **运算符** | **支持的类型** | **说明** | +| --- | :--------: | -------------- | --------------------------------------------------------------------------- | +| 1 | AND | BOOL | 逻辑与，如果两个条件均为 TRUE， 则返回 TRUE。如果任一为 FALSE，则返回 FALSE | +| 2 | OR | BOOL | 逻辑或，如果任一条件为 TRUE， 则返回 TRUE。如果两者都是 FALSE，则返回 FALSE | + +TDengine 在计算逻辑条件时，会进行短路径优化，即对于 AND，第一个条件为 FALSE，则不再计算第二个条件，直接返回 FALSE；对于 OR，第一个条件为 TRUE，则不再计算第二个条件，直接返回 TRUE。 From 7322f92ad63194df5b3c15786e71472e6edadb28 Mon Sep 17 00:00:00 2001 From: Xiaoyu Wang <59301069+xiao-yu-wang@users.noreply.github.com> Date: Tue, 31 May 2022 17:56:03 +0800 Subject: [PATCH 28/28] Update 13-operators.md --- docs-cn/12-taos-sql/13-operators.md | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/docs-cn/12-taos-sql/13-operators.md b/docs-cn/12-taos-sql/13-operators.md index 4480988286..65b1a65dcb 100644 --- a/docs-cn/12-taos-sql/13-operators.md +++ b/docs-cn/12-taos-sql/13-operators.md @@ -25,14 +25,9 @@ title: 运算符 ## 集合运算符 -集合运算符将两个查询的结果合并为一个结果。包含集合运算符的查询称之为复合查询。复合查询中每条查询的选择列表中的相应表达式在数量上必须匹配，并且必须位于同一数据类型组中（如数值类型或字符串类型）。 +集合运算符将两个查询的结果合并为一个结果。包含集合运算符的查询称之为复合查询。复合查询中每条查询的选择列表中的相应表达式在数量上必须匹配，且结果类型以第一条查询为准，后续查询的结果类型必须可转换到第一条查询的结果类型，转换规则同 CAST 函数。 -- 对于字符串类型数据，返回值的数据类型按如下方式确定： - - 如果具有相同的类型（都为 BINARY 或都为 NCHAR），则返回此类型，并以较大的长度作为返回值长度。 - - 如果具有不同的类型，则返回 BINARY 类型，并以较大的长度（NCHAR 类型长度按四倍计算）作为返回值长度。 -- 对于数值类型数据，返回值的数据类型是数字表达范围较大的那个。 - -TDengine 支持 `UNION ALL` 操作符。UNION ALL 将查询返回的结果集合并返回，并不去重。在同一个 SQL 语句中，UNION ALL 最多支持 100 个。 +TDengine 支持 `UNION ALL` 和 `UNION` 操作符。UNION ALL 将查询返回的结果集合并返回，并不去重。UNION 将查询返回的结果集合并并去重后返回。在同一个 SQL 语句中，集合操作符最多支持 100 个。 ## 比较运算符