From 08cb51801b93494cc3696fba4484f5e2f05e3ef3 Mon Sep 17 00:00:00 2001 From: jiacy-jcy <714897623@qq.com> Date: Wed, 24 Aug 2022 10:24:29 +0800 Subject: [PATCH 001/138] update test case --- tests/system-test/1-insert/update_data.py | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/tests/system-test/1-insert/update_data.py b/tests/system-test/1-insert/update_data.py index deff4b42a1..417adc39ac 100644 --- a/tests/system-test/1-insert/update_data.py +++ b/tests/system-test/1-insert/update_data.py @@ -154,10 +154,12 @@ class TDTestCase: up_bool = random.randint(0,100)%2 up_float = random.uniform(constant.FLOAT_MIN,constant.FLOAT_MAX) up_double = random.uniform(constant.DOUBLE_MIN*(1E-300),constant.DOUBLE_MAX*(1E-300)) - binary_length = random.randint(0,self.str_length) - nchar_length = random.randint(0,self.str_length) - up_binary = tdCom.getLongName(binary_length) - up_nchar = tdCom.getLongName(nchar_length) + binary_length = [] + for i in range(self.str_length+1): + binary_length.append(i) + nchar_length = [] + for i in range(self.str_length+1): + nchar_length.append(i) for col_name,col_type in column_dict.items(): if tb_type == 'ntb': tdSql.execute(f'create table {tbname} (ts timestamp,{col_name} {col_type})') @@ -188,9 +190,13 @@ class TDTestCase: elif col_type.lower() == 'double': self.update_and_check_data(tbname,col_name,col_type,up_double,dbname) elif 'binary' in col_type.lower(): - self.update_and_check_data(tbname,col_name,col_type,up_binary,dbname) + for i in binary_length: + up_binary = tdCom.getLongName(i) + self.update_and_check_data(tbname,col_name,col_type,up_binary,dbname) elif 'nchar' in col_type.lower(): - self.update_and_check_data(tbname,col_name,col_type,up_nchar,dbname) + for i in nchar_length: + up_nchar = tdCom.getLongName(i) + self.update_and_check_data(tbname,col_name,col_type,up_nchar,dbname) elif col_type.lower() == 'timestamp': self.update_and_check_data(tbname,col_name,col_type,self.ts+1,dbname) tdSql.execute(f'insert into {tbname} values({self.ts},null)') From 52bff98f344c15c6cb374a624cb5194ae561a8a1 Mon Sep 17 00:00:00 2001 From: Shuduo Sang Date: Fri, 2 Sep 2022 12:16:03 +0800 Subject: [PATCH 002/138] feat: update taos-tools f169c0f for 3.0 --- cmake/taostools_CMakeLists.txt.in | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/taostools_CMakeLists.txt.in b/cmake/taostools_CMakeLists.txt.in index 74c2dbca30..3c7067a9f8 100644 --- a/cmake/taostools_CMakeLists.txt.in +++ b/cmake/taostools_CMakeLists.txt.in @@ -2,7 +2,7 @@ # taos-tools ExternalProject_Add(taos-tools GIT_REPOSITORY https://github.com/taosdata/taos-tools.git - GIT_TAG 212c34d + GIT_TAG f169c0f SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools" BINARY_DIR "" #BUILD_IN_SOURCE TRUE From c1cdf9fec2b0ce65ed3307ab604e936ae7f9e36e Mon Sep 17 00:00:00 2001 From: Shuduo Sang Date: Fri, 2 Sep 2022 16:51:49 +0800 Subject: [PATCH 003/138] feat: update taos-tools a4d9b92 for 3.0 --- cmake/taostools_CMakeLists.txt.in | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/taostools_CMakeLists.txt.in b/cmake/taostools_CMakeLists.txt.in index 3c7067a9f8..b905e30489 100644 --- a/cmake/taostools_CMakeLists.txt.in +++ b/cmake/taostools_CMakeLists.txt.in @@ -2,7 +2,7 @@ # taos-tools ExternalProject_Add(taos-tools GIT_REPOSITORY https://github.com/taosdata/taos-tools.git - GIT_TAG f169c0f + GIT_TAG a4d9b92 SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools" BINARY_DIR "" #BUILD_IN_SOURCE TRUE From 2b94231e693e2a89b08e4fdbd2fce5a2d00ae130 Mon Sep 17 00:00:00 2001 From: Shuduo Sang Date: Wed, 7 Sep 2022 10:19:15 +0800 Subject: [PATCH 004/138] feat: update taostools 0fa3a66 for 3.0 --- cmake/taostools_CMakeLists.txt.in | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/taostools_CMakeLists.txt.in b/cmake/taostools_CMakeLists.txt.in index b905e30489..74cdd2a6ad 100644 --- a/cmake/taostools_CMakeLists.txt.in +++ b/cmake/taostools_CMakeLists.txt.in @@ -2,7 +2,7 @@ # taos-tools ExternalProject_Add(taos-tools GIT_REPOSITORY https://github.com/taosdata/taos-tools.git - GIT_TAG a4d9b92 + GIT_TAG 0fa3a66 SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools" BINARY_DIR "" #BUILD_IN_SOURCE TRUE From 28a6865ddaf8ef67792b2d2b00c1a1aa23bb81fd Mon Sep 17 00:00:00 2001 From: Shuduo Sang Date: Wed, 7 Sep 2022 11:21:32 +0800 Subject: [PATCH 005/138] feat: udpate taos-tools 023a01e for 3.0 --- cmake/taostools_CMakeLists.txt.in | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/taostools_CMakeLists.txt.in b/cmake/taostools_CMakeLists.txt.in index 74cdd2a6ad..0cdbb5d60a 100644 --- a/cmake/taostools_CMakeLists.txt.in +++ b/cmake/taostools_CMakeLists.txt.in @@ -2,7 +2,7 @@ # taos-tools ExternalProject_Add(taos-tools GIT_REPOSITORY https://github.com/taosdata/taos-tools.git - GIT_TAG 0fa3a66 + GIT_TAG 023a01e SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools" BINARY_DIR "" #BUILD_IN_SOURCE TRUE From 52cc999ed180a3189b45ea06f378857c7a959f34 Mon Sep 17 00:00:00 2001 From: Shuduo Sang Date: Wed, 7 Sep 2022 11:32:26 +0800 Subject: [PATCH 006/138] feat: update taos-tools 7d5c1c0 for 3.0 --- cmake/taostools_CMakeLists.txt.in | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/taostools_CMakeLists.txt.in b/cmake/taostools_CMakeLists.txt.in index 0cdbb5d60a..adefacc6af 100644 --- a/cmake/taostools_CMakeLists.txt.in +++ b/cmake/taostools_CMakeLists.txt.in @@ -2,7 +2,7 @@ # taos-tools ExternalProject_Add(taos-tools GIT_REPOSITORY https://github.com/taosdata/taos-tools.git - GIT_TAG 023a01e + GIT_TAG 7d5c1c0 SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools" BINARY_DIR "" #BUILD_IN_SOURCE TRUE From 823605fb5469027b9c9a220476c7da115e01988c Mon Sep 17 00:00:00 2001 From: Hui Li <52318143+plum-lihui@users.noreply.github.com> Date: Thu, 8 Sep 2022 16:46:52 +0800 Subject: [PATCH 007/138] Update fulltest.sh --- tests/system-test/fulltest.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/system-test/fulltest.sh b/tests/system-test/fulltest.sh index 11df13d451..9916de6a6e 100755 --- a/tests/system-test/fulltest.sh +++ b/tests/system-test/fulltest.sh @@ -2,7 +2,7 @@ set -e set -x -python3 ./test.py -f 0-others/taosShell.py +#python3 ./test.py -f 0-others/taosShell.py python3 ./test.py -f 0-others/taosShellError.py python3 ./test.py -f 0-others/taosShellNetChk.py python3 ./test.py -f 0-others/telemetry.py From 00a974cfa0b4fed6d3abaa1114141dc16c1c122b Mon Sep 17 00:00:00 2001 From: Shuduo Sang Date: Sun, 11 Sep 2022 14:06:04 +0800 Subject: [PATCH 008/138] feat: update taos-tools 2.2.0 (2dba49c) for 3.0 --- cmake/taostools_CMakeLists.txt.in | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/taostools_CMakeLists.txt.in b/cmake/taostools_CMakeLists.txt.in index adefacc6af..c273e9889f 100644 --- a/cmake/taostools_CMakeLists.txt.in +++ b/cmake/taostools_CMakeLists.txt.in @@ -2,7 +2,7 @@ # taos-tools ExternalProject_Add(taos-tools GIT_REPOSITORY https://github.com/taosdata/taos-tools.git - GIT_TAG 7d5c1c0 + GIT_TAG 2dba49c SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools" BINARY_DIR "" #BUILD_IN_SOURCE TRUE From 4fd0bc409d2177a77148a502546e590179496bcb Mon Sep 17 00:00:00 2001 From: dapan1121 Date: Tue, 13 Sep 2022 09:09:21 +0800 Subject: [PATCH 009/138] fix: fix client/server memory leak issues --- source/client/src/clientImpl.c | 1 + source/client/src/clientMain.c | 2 ++ source/client/src/clientRawBlockWrite.c | 6 ++++++ source/common/src/tmsg.c | 2 ++ source/libs/catalog/src/ctgUtil.c | 11 ++++++++++- source/libs/parser/src/parTranslater.c | 25 ++++++------------------- 6 files changed, 27 insertions(+), 20 deletions(-) diff --git a/source/client/src/clientImpl.c b/source/client/src/clientImpl.c index 5ebc2729f8..1c18812509 100644 --- a/source/client/src/clientImpl.c +++ b/source/client/src/clientImpl.c @@ -854,6 +854,7 @@ void schedulerExecCb(SExecResult* pResult, void* param, int32_t code) { pRequest->metric.resultReady = taosGetTimestampUs(); if (pResult) { + destroyQueryExecRes(&pRequest->body.resInfo.execRes); memcpy(&pRequest->body.resInfo.execRes, pResult, sizeof(*pResult)); } diff --git a/source/client/src/clientMain.c b/source/client/src/clientMain.c index 3086078080..73636e7372 100644 --- a/source/client/src/clientMain.c +++ b/source/client/src/clientMain.c @@ -870,11 +870,13 @@ static void fetchCallback(void *pResult, void *param, int32_t code) { if (code != TSDB_CODE_SUCCESS) { pRequest->code = code; + taosMemoryFreeClear(pResultInfo->pData); pRequest->body.fetchFp(pRequest->body.param, pRequest, 0); return; } if (pRequest->code != TSDB_CODE_SUCCESS) { + taosMemoryFreeClear(pResultInfo->pData); pRequest->body.fetchFp(pRequest->body.param, pRequest, 0); return; } diff --git a/source/client/src/clientRawBlockWrite.c b/source/client/src/clientRawBlockWrite.c index c135965f07..6e9711f57b 100644 --- a/source/client/src/clientRawBlockWrite.c +++ b/source/client/src/clientRawBlockWrite.c @@ -701,6 +701,12 @@ typedef struct SVgroupCreateTableBatch { static void destroyCreateTbReqBatch(void* data) { SVgroupCreateTableBatch* pTbBatch = (SVgroupCreateTableBatch*)data; + size_t size = taosArrayGetSize(pTbBatch->req.pArray); + for (int32_t i = 0; i < size; ++i) { + SVCreateTbReq* pTableReq = taosArrayGet(pTbBatch->req.pArray, i); + tdDestroySVCreateTbReq(pTableReq); + } + taosArrayDestroy(pTbBatch->req.pArray); } diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index ea25094d10..f96462945f 100644 --- a/source/common/src/tmsg.c +++ b/source/common/src/tmsg.c @@ -5436,6 +5436,8 @@ void tFreeSSubmitRsp(SSubmitRsp *pRsp) { for (int32_t i = 0; i < pRsp->nBlocks; ++i) { SSubmitBlkRsp *sRsp = pRsp->pBlocks + i; taosMemoryFree(sRsp->tblFName); + tFreeSTableMetaRsp(sRsp->pMeta); + taosMemoryFree(sRsp->pMeta); } taosMemoryFree(pRsp->pBlocks); diff --git a/source/libs/catalog/src/ctgUtil.c b/source/libs/catalog/src/ctgUtil.c index 296100ce6d..97b174de1c 100644 --- a/source/libs/catalog/src/ctgUtil.c +++ b/source/libs/catalog/src/ctgUtil.c @@ -99,7 +99,16 @@ char *ctgTaskTypeStr(CTG_TASK_TYPE type) { } void ctgFreeQNode(SCtgQNode *node) { - //TODO + if (NULL == node) { + return; + } + + if (node->op) { + taosMemoryFree(node->op->data); + taosMemoryFree(node->op); + } + + taosMemoryFree(node); } void ctgFreeSTableIndex(void *info) { diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index ad9a467dee..7d49e3d7c5 100644 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -5922,12 +5922,6 @@ typedef struct SVgroupCreateTableBatch { char dbName[TSDB_DB_NAME_LEN]; } SVgroupCreateTableBatch; -static void destroyCreateTbReq(SVCreateTbReq* pReq) { - taosMemoryFreeClear(pReq->name); - taosMemoryFreeClear(pReq->comment); - taosMemoryFreeClear(pReq->ntb.schemaRow.pSchema); -} - static int32_t buildNormalTableBatchReq(int32_t acctId, const SCreateTableStmt* pStmt, const SVgroupInfo* pVgroupInfo, SVgroupCreateTableBatch* pBatch) { char dbFName[TSDB_DB_FNAME_LEN] = {0}; @@ -5942,7 +5936,7 @@ static int32_t buildNormalTableBatchReq(int32_t acctId, const SCreateTableStmt* if (pStmt->pOptions->commentNull == false) { req.comment = strdup(pStmt->pOptions->comment); if (NULL == req.comment) { - destroyCreateTbReq(&req); + tdDestroySVCreateTbReq(&req); return TSDB_CODE_OUT_OF_MEMORY; } req.commentLen = strlen(pStmt->pOptions->comment); @@ -5953,7 +5947,7 @@ static int32_t buildNormalTableBatchReq(int32_t acctId, const SCreateTableStmt* req.ntb.schemaRow.version = 1; req.ntb.schemaRow.pSchema = taosMemoryCalloc(req.ntb.schemaRow.nCols, sizeof(SSchema)); if (NULL == req.name || NULL == req.ntb.schemaRow.pSchema) { - destroyCreateTbReq(&req); + tdDestroySVCreateTbReq(&req); return TSDB_CODE_OUT_OF_MEMORY; } if (pStmt->ignoreExists) { @@ -5969,7 +5963,7 @@ static int32_t buildNormalTableBatchReq(int32_t acctId, const SCreateTableStmt* strcpy(pBatch->dbName, pStmt->dbName); pBatch->req.pArray = taosArrayInit(1, sizeof(struct SVCreateTbReq)); if (NULL == pBatch->req.pArray) { - destroyCreateTbReq(&req); + tdDestroySVCreateTbReq(&req); return TSDB_CODE_OUT_OF_MEMORY; } taosArrayPush(pBatch->req.pArray, &req); @@ -6014,16 +6008,7 @@ static void destroyCreateTbReqBatch(void* data) { size_t size = taosArrayGetSize(pTbBatch->req.pArray); for (int32_t i = 0; i < size; ++i) { SVCreateTbReq* pTableReq = taosArrayGet(pTbBatch->req.pArray, i); - taosMemoryFreeClear(pTableReq->name); - taosMemoryFreeClear(pTableReq->comment); - - if (pTableReq->type == TSDB_NORMAL_TABLE) { - taosMemoryFreeClear(pTableReq->ntb.schemaRow.pSchema); - } else if (pTableReq->type == TSDB_CHILD_TABLE) { - taosMemoryFreeClear(pTableReq->ctb.pTag); - taosMemoryFreeClear(pTableReq->ctb.name); - taosArrayDestroy(pTableReq->ctb.tagName); - } + tdDestroySVCreateTbReq(pTableReq); } taosArrayDestroy(pTbBatch->req.pArray); @@ -6384,6 +6369,8 @@ static int32_t rewriteCreateSubTable(STranslateContext* pCxt, SCreateSubTableCla if (TSDB_CODE_SUCCESS == code) { addCreateTbReqIntoVgroup(pCxt->pParseCxt->acctId, pVgroupHashmap, pStmt, pTag, pSuperTableMeta->uid, pStmt->useTableName, &info, tagName, pSuperTableMeta->tableInfo.numOfTags); + } else { + taosMemoryFree(pTag); } taosArrayDestroy(tagName); From ff9d673489b1c67042f47fe47656a5905d4ab8bb Mon Sep 17 00:00:00 2001 From: Xiaoyu Wang Date: Tue, 13 Sep 2022 10:48:39 +0800 Subject: [PATCH 010/138] enh: add binary serialization method to node structure --- include/libs/planner/planner.h | 6 +- source/libs/nodes/src/nodesMsgFuncs.c | 274 ++++++++++++++++---------- source/libs/planner/src/planner.c | 15 ++ source/libs/qworker/src/qworker.c | 4 +- source/libs/scheduler/src/schTask.c | 2 +- 5 files changed, 191 insertions(+), 110 deletions(-) diff --git a/include/libs/planner/planner.h b/include/libs/planner/planner.h index 05caa7a7bb..e03ac3811a 100644 --- a/include/libs/planner/planner.h +++ b/include/libs/planner/planner.h @@ -52,10 +52,14 @@ int32_t qSetSubplanExecutionNode(SSubplan* pSubplan, int32_t groupId, SDownstrea void qClearSubplanExecutionNode(SSubplan* pSubplan); -// Convert to subplan to string for the scheduler to send to the executor +// Convert to subplan to display string for the scheduler to send to the executor int32_t qSubPlanToString(const SSubplan* pSubplan, char** pStr, int32_t* pLen); int32_t qStringToSubplan(const char* pStr, SSubplan** pSubplan); +// Convert to subplan to msg for the scheduler to send to the executor +int32_t qSubPlanToMsg(const SSubplan* pSubplan, char** pStr, int32_t* pLen); +int32_t qMsgToSubplan(const char* pStr, int32_t len, SSubplan** pSubplan); + char* qQueryPlanToString(const SQueryPlan* pPlan); SQueryPlan* qStringToQueryPlan(const char* pStr); diff --git a/source/libs/nodes/src/nodesMsgFuncs.c b/source/libs/nodes/src/nodesMsgFuncs.c index 5fe31ed78e..b0be001e56 100644 --- a/source/libs/nodes/src/nodesMsgFuncs.c +++ b/source/libs/nodes/src/nodesMsgFuncs.c @@ -1082,6 +1082,170 @@ static int32_t msgToSlotDescNode(STlvDecoder* pDecoder, void* pObj) { return code; } +enum { EP_CODE_FQDN = 1, EP_CODE_port }; + +static int32_t epToMsg(const void* pObj, STlvEncoder* pEncoder) { + const SEp* pNode = (const SEp*)pObj; + + int32_t code = tlvEncodeCStr(pEncoder, EP_CODE_FQDN, pNode->fqdn); + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeU16(pEncoder, EP_CODE_port, pNode->port); + } + + return code; +} + +static int32_t msgToEp(STlvDecoder* pDecoder, void* pObj) { + SEp* pNode = (SEp*)pObj; + + int32_t code = TSDB_CODE_SUCCESS; + STlv* pTlv = NULL; + tlvForEach(pDecoder, pTlv, code) { + switch (pTlv->type) { + case EP_CODE_FQDN: + code = tlvDecodeCStr(pTlv, pNode->fqdn); + break; + case EP_CODE_port: + code = tlvDecodeU16(pTlv, &pNode->port); + break; + default: + break; + } + } + + return code; +} + +enum { EP_SET_CODE_IN_USE = 1, EP_SET_CODE_NUM_OF_EPS, EP_SET_CODE_EPS }; + +static int32_t epSetToMsg(const void* pObj, STlvEncoder* pEncoder) { + const SEpSet* pNode = (const SEpSet*)pObj; + + int32_t code = tlvEncodeI8(pEncoder, EP_SET_CODE_IN_USE, pNode->inUse); + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeI8(pEncoder, EP_SET_CODE_NUM_OF_EPS, pNode->numOfEps); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeObjArray(pEncoder, EP_SET_CODE_EPS, epToMsg, pNode->eps, sizeof(SEp), pNode->numOfEps); + } + + return code; +} + +static int32_t msgToEpSet(STlvDecoder* pDecoder, void* pObj) { + SEpSet* pNode = (SEpSet*)pObj; + + int32_t code = TSDB_CODE_SUCCESS; + STlv* pTlv = NULL; + tlvForEach(pDecoder, pTlv, code) { + switch (pTlv->type) { + case EP_SET_CODE_IN_USE: + code = tlvDecodeI8(pTlv, &pNode->inUse); + break; + case EP_SET_CODE_NUM_OF_EPS: + code = tlvDecodeI8(pTlv, &pNode->numOfEps); + break; + case EP_SET_CODE_EPS: + code = tlvDecodeObjArrayFromTlv(pTlv, msgToEp, pNode->eps, sizeof(SEp)); + break; + default: + break; + } + } + + return code; +} + +enum { QUERY_NODE_ADDR_CODE_NODE_ID = 1, QUERY_NODE_ADDR_CODE_EP_SET }; + +static int32_t queryNodeAddrToMsg(const void* pObj, STlvEncoder* pEncoder) { + const SQueryNodeAddr* pNode = (const SQueryNodeAddr*)pObj; + + int32_t code = tlvEncodeI32(pEncoder, QUERY_NODE_ADDR_CODE_NODE_ID, pNode->nodeId); + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeObj(pEncoder, QUERY_NODE_ADDR_CODE_EP_SET, epSetToMsg, &pNode->epSet); + } + + return code; +} + +static int32_t msgToQueryNodeAddr(STlvDecoder* pDecoder, void* pObj) { + SQueryNodeAddr* pNode = (SQueryNodeAddr*)pObj; + + int32_t code = TSDB_CODE_SUCCESS; + STlv* pTlv = NULL; + tlvForEach(pDecoder, pTlv, code) { + switch (pTlv->type) { + case QUERY_NODE_ADDR_CODE_NODE_ID: + code = tlvDecodeI32(pTlv, &pNode->nodeId); + break; + case QUERY_NODE_ADDR_CODE_EP_SET: + code = tlvDecodeObjFromTlv(pTlv, msgToEpSet, &pNode->epSet); + break; + } + } + + return code; +} + +enum { + DOWNSTREAM_SOURCE_CODE_ADDR = 1, + DOWNSTREAM_SOURCE_CODE_TASK_ID, + DOWNSTREAM_SOURCE_CODE_SCHED_ID, + DOWNSTREAM_SOURCE_CODE_EXEC_ID, + DOWNSTREAM_SOURCE_CODE_FETCH_MSG_TYPE +}; + +static int32_t downstreamSourceNodeToMsg(const void* pObj, STlvEncoder* pEncoder) { + const SDownstreamSourceNode* pNode = (const SDownstreamSourceNode*)pObj; + + int32_t code = tlvEncodeObj(pEncoder, DOWNSTREAM_SOURCE_CODE_ADDR, queryNodeAddrToMsg, &pNode->addr); + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeU64(pEncoder, DOWNSTREAM_SOURCE_CODE_TASK_ID, pNode->taskId); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeU64(pEncoder, DOWNSTREAM_SOURCE_CODE_SCHED_ID, pNode->schedId); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeI32(pEncoder, DOWNSTREAM_SOURCE_CODE_EXEC_ID, pNode->execId); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeI32(pEncoder, DOWNSTREAM_SOURCE_CODE_FETCH_MSG_TYPE, pNode->fetchMsgType); + } + + return code; +} + +static int32_t msgToDownstreamSourceNode(STlvDecoder* pDecoder, void* pObj) { + SDownstreamSourceNode* pNode = (SDownstreamSourceNode*)pObj; + + int32_t code = TSDB_CODE_SUCCESS; + STlv* pTlv = NULL; + tlvForEach(pDecoder, pTlv, code) { + switch (pTlv->type) { + case DOWNSTREAM_SOURCE_CODE_ADDR: + code = tlvDecodeObjFromTlv(pTlv, msgToQueryNodeAddr, &pNode->addr); + break; + case DOWNSTREAM_SOURCE_CODE_TASK_ID: + code = tlvDecodeU64(pTlv, &pNode->taskId); + break; + case DOWNSTREAM_SOURCE_CODE_SCHED_ID: + code = tlvDecodeU64(pTlv, &pNode->schedId); + break; + case DOWNSTREAM_SOURCE_CODE_EXEC_ID: + code = tlvDecodeI32(pTlv, &pNode->execId); + break; + case DOWNSTREAM_SOURCE_CODE_FETCH_MSG_TYPE: + code = tlvDecodeI32(pTlv, &pNode->fetchMsgType); + break; + default: + break; + } + } + + return code; +} + enum { PHY_NODE_CODE_OUTPUT_DESC = 1, PHY_NODE_CODE_CONDITIONS, @@ -1401,80 +1565,6 @@ static int32_t msgToPhysiTableScanNode(STlvDecoder* pDecoder, void* pObj) { return code; } -enum { EP_CODE_FQDN = 1, EP_CODE_port }; - -static int32_t epToMsg(const void* pObj, STlvEncoder* pEncoder) { - const SEp* pNode = (const SEp*)pObj; - - int32_t code = tlvEncodeCStr(pEncoder, EP_CODE_FQDN, pNode->fqdn); - if (TSDB_CODE_SUCCESS == code) { - code = tlvEncodeU16(pEncoder, EP_CODE_port, pNode->port); - } - - return code; -} - -static int32_t msgToEp(STlvDecoder* pDecoder, void* pObj) { - SEp* pNode = (SEp*)pObj; - - int32_t code = TSDB_CODE_SUCCESS; - STlv* pTlv = NULL; - tlvForEach(pDecoder, pTlv, code) { - switch (pTlv->type) { - case EP_CODE_FQDN: - code = tlvDecodeCStr(pTlv, pNode->fqdn); - break; - case EP_CODE_port: - code = tlvDecodeU16(pTlv, &pNode->port); - break; - default: - break; - } - } - - return code; -} - -enum { EP_SET_CODE_IN_USE = 1, EP_SET_CODE_NUM_OF_EPS, EP_SET_CODE_EPS }; - -static int32_t epSetToMsg(const void* pObj, STlvEncoder* pEncoder) { - const SEpSet* pNode = (const SEpSet*)pObj; - - int32_t code = tlvEncodeI8(pEncoder, EP_SET_CODE_IN_USE, pNode->inUse); - if (TSDB_CODE_SUCCESS == code) { - code = tlvEncodeI8(pEncoder, EP_SET_CODE_NUM_OF_EPS, pNode->numOfEps); - } - if (TSDB_CODE_SUCCESS == code) { - code = tlvEncodeObjArray(pEncoder, EP_SET_CODE_EPS, epToMsg, pNode->eps, sizeof(SEp), pNode->numOfEps); - } - - return code; -} - -static int32_t msgToEpSet(STlvDecoder* pDecoder, void* pObj) { - SEpSet* pNode = (SEpSet*)pObj; - - int32_t code = TSDB_CODE_SUCCESS; - STlv* pTlv = NULL; - tlvForEach(pDecoder, pTlv, code) { - switch (pTlv->type) { - case EP_SET_CODE_IN_USE: - code = tlvDecodeI8(pTlv, &pNode->inUse); - break; - case EP_SET_CODE_NUM_OF_EPS: - code = tlvDecodeI8(pTlv, &pNode->numOfEps); - break; - case EP_SET_CODE_EPS: - code = tlvDecodeObjArrayFromTlv(pTlv, msgToEp, pNode->eps, sizeof(SEp)); - break; - default: - break; - } - } - - return code; -} - enum { PHY_SYSTABLE_SCAN_CODE_SCAN = 1, PHY_SYSTABLE_SCAN_CODE_MGMT_EP_SET, @@ -2594,38 +2684,6 @@ static int32_t msgToSubplanId(STlvDecoder* pDecoder, void* pObj) { return code; } -enum { QUERY_NODE_ADDR_CODE_NODE_ID = 1, QUERY_NODE_ADDR_CODE_EP_SET }; - -static int32_t queryNodeAddrToMsg(const void* pObj, STlvEncoder* pEncoder) { - const SQueryNodeAddr* pNode = (const SQueryNodeAddr*)pObj; - - int32_t code = tlvEncodeI32(pEncoder, QUERY_NODE_ADDR_CODE_NODE_ID, pNode->nodeId); - if (TSDB_CODE_SUCCESS == code) { - code = tlvEncodeObj(pEncoder, QUERY_NODE_ADDR_CODE_EP_SET, epSetToMsg, &pNode->epSet); - } - - return code; -} - -static int32_t msgToQueryNodeAddr(STlvDecoder* pDecoder, void* pObj) { - SQueryNodeAddr* pNode = (SQueryNodeAddr*)pObj; - - int32_t code = TSDB_CODE_SUCCESS; - STlv* pTlv = NULL; - tlvForEach(pDecoder, pTlv, code) { - switch (pTlv->type) { - case QUERY_NODE_ADDR_CODE_NODE_ID: - code = tlvDecodeI32(pTlv, &pNode->nodeId); - break; - case QUERY_NODE_ADDR_CODE_EP_SET: - code = tlvDecodeObjFromTlv(pTlv, msgToEpSet, &pNode->epSet); - break; - } - } - - return code; -} - enum { SUBPLAN_CODE_SUBPLAN_ID = 1, SUBPLAN_CODE_SUBPLAN_TYPE, @@ -2802,6 +2860,8 @@ static int32_t specificNodeToMsg(const void* pObj, STlvEncoder* pEncoder) { case QUERY_NODE_SLOT_DESC: code = slotDescNodeToMsg(pObj, pEncoder); break; + case QUERY_NODE_DOWNSTREAM_SOURCE: + return downstreamSourceNodeToMsg(pObj, pEncoder); case QUERY_NODE_LEFT_VALUE: break; case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN: @@ -2929,6 +2989,8 @@ static int32_t msgToSpecificNode(STlvDecoder* pDecoder, void* pObj) { case QUERY_NODE_SLOT_DESC: code = msgToSlotDescNode(pDecoder, pObj); break; + case QUERY_NODE_DOWNSTREAM_SOURCE: + return msgToDownstreamSourceNode(pDecoder, pObj); case QUERY_NODE_LEFT_VALUE: break; case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN: diff --git a/source/libs/planner/src/planner.c b/source/libs/planner/src/planner.c index baa1d1074c..35903d45b1 100644 --- a/source/libs/planner/src/planner.c +++ b/source/libs/planner/src/planner.c @@ -123,6 +123,21 @@ int32_t qSubPlanToString(const SSubplan* pSubplan, char** pStr, int32_t* pLen) { int32_t qStringToSubplan(const char* pStr, SSubplan** pSubplan) { return nodesStringToNode(pStr, (SNode**)pSubplan); } +int32_t qSubPlanToMsg(const SSubplan* pSubplan, char** pStr, int32_t* pLen) { + if (SUBPLAN_TYPE_MODIFY == pSubplan->subplanType && NULL == pSubplan->pNode) { + SDataInserterNode* insert = (SDataInserterNode*)pSubplan->pDataSink; + *pLen = insert->size; + *pStr = insert->pData; + insert->pData = NULL; + return TSDB_CODE_SUCCESS; + } + return nodesNodeToMsg((const SNode*)pSubplan, pStr, pLen); +} + +int32_t qMsgToSubplan(const char* pStr, int32_t len, SSubplan** pSubplan) { + return nodesMsgToNode(pStr, len, (SNode**)pSubplan); +} + char* qQueryPlanToString(const SQueryPlan* pPlan) { char* pStr = NULL; int32_t len = 0; diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c index f006096ce2..61c38f59db 100644 --- a/source/libs/qworker/src/qworker.c +++ b/source/libs/qworker/src/qworker.c @@ -559,7 +559,7 @@ int32_t qwProcessQuery(QW_FPARAMS_DEF, SQWMsg *qwMsg, char *sql) { // QW_TASK_DLOGL("subplan json string, len:%d, %s", qwMsg->msgLen, qwMsg->msg); - code = qStringToSubplan(qwMsg->msg, &plan); + code = qMsgToSubplan(qwMsg->msg, qwMsg->msgLen, &plan); if (TSDB_CODE_SUCCESS != code) { code = TSDB_CODE_INVALID_MSG; QW_TASK_ELOG("task physical plan to subplan failed, code:%x - %s", code, tstrerror(code)); @@ -968,7 +968,7 @@ int32_t qwProcessDelete(QW_FPARAMS_DEF, SQWMsg *qwMsg, SDeleteRes *pRes) { DataSinkHandle sinkHandle = NULL; SQWTaskCtx ctx = {0}; - code = qStringToSubplan(qwMsg->msg, &plan); + code = qMsgToSubplan(qwMsg->msg, qwMsg->msgLen, &plan); if (TSDB_CODE_SUCCESS != code) { code = TSDB_CODE_INVALID_MSG; QW_TASK_ELOG("task physical plan to subplan failed, code:%x - %s", code, tstrerror(code)); diff --git a/source/libs/scheduler/src/schTask.c b/source/libs/scheduler/src/schTask.c index c5f161b66a..969c6fc8a6 100644 --- a/source/libs/scheduler/src/schTask.c +++ b/source/libs/scheduler/src/schTask.c @@ -860,7 +860,7 @@ int32_t schLaunchTaskImpl(void *param) { SSubplan *plan = pTask->plan; if (NULL == pTask->msg) { // TODO add more detailed reason for failure - code = qSubPlanToString(plan, &pTask->msg, &pTask->msgLen); + code = qSubPlanToMsg(plan, &pTask->msg, &pTask->msgLen); if (TSDB_CODE_SUCCESS != code) { SCH_TASK_ELOG("failed to create physical plan, code:%s, msg:%p, len:%d", tstrerror(code), pTask->msg, pTask->msgLen); From 508c7abb6819ca78fdbdf3a824e072994edade07 Mon Sep 17 00:00:00 2001 From: Minglei Jin Date: Tue, 13 Sep 2022 10:51:15 +0800 Subject: [PATCH 011/138] fix(tdb): use rbtree with dirty pages' list --- source/libs/tdb/src/db/tdbPager.c | 55 ++++++++++++++++++++++++++++--- source/libs/tdb/src/inc/tdbInt.h | 7 ++-- 2 files changed, 55 insertions(+), 7 deletions(-) diff --git a/source/libs/tdb/src/db/tdbPager.c b/source/libs/tdb/src/db/tdbPager.c index bec07b935e..bb2151ed9d 100644 --- a/source/libs/tdb/src/db/tdbPager.c +++ b/source/libs/tdb/src/db/tdbPager.c @@ -34,6 +34,22 @@ static int tdbPagerInitPage(SPager *pPager, SPage *pPage, int (*initPage)(SPage static int tdbPagerWritePageToJournal(SPager *pPager, SPage *pPage); static int tdbPagerWritePageToDB(SPager *pPager, SPage *pPage); +static FORCE_INLINE int32_t pageCmpFn(const void *lhs, const void *rhs) { + SPage *pPageL = (SPage *)(((uint8_t *)lhs) - sizeof(SRBTreeNode)); + SPage *pPageR = (SPage *)(((uint8_t *)rhs) - sizeof(SRBTreeNode)); + + SPgno pgnoL = TDB_PAGE_PGNO(pPageL); + SPgno pgnoR = TDB_PAGE_PGNO(pPageR); + + if (pgnoL < pgnoR) { + return -1; + } else if (pgnoL > pgnoR) { + return 1; + } else { + return 0; + } +} + int tdbPagerOpen(SPCache *pCache, const char *fileName, SPager **ppPager) { uint8_t *pPtr; SPager *pPager; @@ -83,6 +99,8 @@ int tdbPagerOpen(SPCache *pCache, const char *fileName, SPager **ppPager) { ret = tdbGetFileSize(pPager->fd, pPager->pageSize, &(pPager->dbOrigSize)); pPager->dbFileSize = pPager->dbOrigSize; + tRBTreeCreate(&pPager->rbt, pageCmpFn); + *ppPager = pPager; return 0; } @@ -167,7 +185,7 @@ int tdbPagerWrite(SPager *pPager, SPage *pPage) { // ref page one more time so the page will not be release tdbRefPage(pPage); tdbDebug("pcache/mdirty page %p/%d/%d", pPage, TDB_PAGE_PGNO(pPage), pPage->id); - + /* // Set page as dirty pPage->isDirty = 1; @@ -185,6 +203,8 @@ int tdbPagerWrite(SPager *pPager, SPage *pPage) { ASSERT(*ppPage == NULL || TDB_PAGE_PGNO(*ppPage) > TDB_PAGE_PGNO(pPage)); pPage->pDirtyNext = *ppPage; *ppPage = pPage; + */ + tRBTreePut(&pPager->rbt, (SRBTreeNode *)pPage); // Write page to journal if neccessary if (TDB_PAGE_PGNO(pPage) <= pPager->dbOrigSize) { @@ -228,6 +248,23 @@ int tdbPagerCommit(SPager *pPager, TXN *pTxn) { return 0; } + SRBTreeIter iter = tRBTreeIterCreate(&pPager->rbt, 1); + SRBTreeNode *pNode = NULL; + while ((pNode = tRBTreeIterNext(&iter)) != NULL) { + pPage = (SPage *)pNode; + ret = tdbPagerWritePageToDB(pPager, pPage); + if (ret < 0) { + ASSERT(0); + return -1; + } + + pPage->isDirty = 0; + + tdbPCacheRelease(pPager->pCache, pPage, pTxn); + } + + tRBTreeCreate(&pPager->rbt, pageCmpFn); + /* // loop to write the dirty pages to file for (pPage = pPager->pDirty; pPage; pPage = pPage->pDirtyNext) { // TODO: update the page footer @@ -238,9 +275,6 @@ int tdbPagerCommit(SPager *pPager, TXN *pTxn) { } } - tdbTrace("tdbttl commit:%p, %d", pPager, pPager->dbOrigSize); - pPager->dbOrigSize = pPager->dbFileSize; - // release the page for (pPage = pPager->pDirty; pPage; pPage = pPager->pDirty) { pPager->pDirty = pPage->pDirtyNext; @@ -250,6 +284,9 @@ int tdbPagerCommit(SPager *pPager, TXN *pTxn) { tdbPCacheRelease(pPager->pCache, pPage, pTxn); } + */ + tdbTrace("tdbttl commit:%p, %d", pPager, pPager->dbOrigSize); + pPager->dbOrigSize = pPager->dbFileSize; // sync the db file tdbOsFSync(pPager->fd); @@ -497,7 +534,14 @@ static int tdbPagerWritePageToJournal(SPager *pPager, SPage *pPage) { return 0; } - +/* +struct TdFile { + TdThreadRwlock rwlock; + int refId; + int fd; + FILE *fp; +} TdFile; +*/ static int tdbPagerWritePageToDB(SPager *pPager, SPage *pPage) { i64 offset; int ret; @@ -514,6 +558,7 @@ static int tdbPagerWritePageToDB(SPager *pPager, SPage *pPage) { return -1; } + // pwrite(pPager->fd->fd, pPage->pData, pPage->pageSize, offset); return 0; } diff --git a/source/libs/tdb/src/inc/tdbInt.h b/source/libs/tdb/src/inc/tdbInt.h index 6a694cf8f1..df6ba8b35f 100644 --- a/source/libs/tdb/src/inc/tdbInt.h +++ b/source/libs/tdb/src/inc/tdbInt.h @@ -19,6 +19,7 @@ #include "tdb.h" #include "tlog.h" +#include "trbtree.h" #ifdef __cplusplus extern "C" { @@ -256,6 +257,7 @@ typedef struct { #pragma pack(pop) struct SPage { + SRBTreeNode node; // must be the first field for pageCmpFn to work tdb_spinlock_t lock; int pageSize; u8 *pData; @@ -280,13 +282,13 @@ struct SPage { static inline i32 tdbRefPage(SPage *pPage) { i32 nRef = atomic_add_fetch_32(&((pPage)->nRef), 1); - tdbTrace("ref page %p/%d, nRef %d", pPage, pPage->id, nRef); + // tdbTrace("ref page %p/%d, nRef %d", pPage, pPage->id, nRef); return nRef; } static inline i32 tdbUnrefPage(SPage *pPage) { i32 nRef = atomic_sub_fetch_32(&((pPage)->nRef), 1); - tdbTrace("unref page %p/%d, nRef %d", pPage, pPage->id, nRef); + // tdbTrace("unref page %p/%d, nRef %d", pPage, pPage->id, nRef); return nRef; } @@ -389,6 +391,7 @@ struct SPager { SPgno dbFileSize; SPgno dbOrigSize; SPage *pDirty; + SRBTree rbt; u8 inTran; SPager *pNext; // used by TDB SPager *pHashNext; // used by TDB From 51799dde9703eb7de30feff87f91dbf2449c3d60 Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Tue, 13 Sep 2022 11:25:14 +0800 Subject: [PATCH 012/138] fix: fix mem leak --- source/libs/catalog/src/ctgCache.c | 936 ++++++++++++++--------------- 1 file changed, 440 insertions(+), 496 deletions(-) diff --git a/source/libs/catalog/src/ctgCache.c b/source/libs/catalog/src/ctgCache.c index 6935489ff4..ee0577523d 100644 --- a/source/libs/catalog/src/ctgCache.c +++ b/source/libs/catalog/src/ctgCache.c @@ -13,96 +13,46 @@ * along with this program. If not, see . */ -#include "trpc.h" -#include "query.h" -#include "tname.h" #include "catalogInt.h" +#include "query.h" #include "systable.h" +#include "tname.h" +#include "trpc.h" -SCtgOperation gCtgCacheOperation[CTG_OP_MAX] = { - { - CTG_OP_UPDATE_VGROUP, - "update vgInfo", - ctgOpUpdateVgroup - }, - { - CTG_OP_UPDATE_TB_META, - "update tbMeta", - ctgOpUpdateTbMeta - }, - { - CTG_OP_DROP_DB_CACHE, - "drop DB", - ctgOpDropDbCache - }, - { - CTG_OP_DROP_DB_VGROUP, - "drop DBVgroup", - ctgOpDropDbVgroup - }, - { - CTG_OP_DROP_STB_META, - "drop stbMeta", - ctgOpDropStbMeta - }, - { - CTG_OP_DROP_TB_META, - "drop tbMeta", - ctgOpDropTbMeta - }, - { - CTG_OP_UPDATE_USER, - "update user", - ctgOpUpdateUser - }, - { - CTG_OP_UPDATE_VG_EPSET, - "update epset", - ctgOpUpdateEpset - }, - { - CTG_OP_UPDATE_TB_INDEX, - "update tbIndex", - ctgOpUpdateTbIndex - }, - { - CTG_OP_DROP_TB_INDEX, - "drop tbIndex", - ctgOpDropTbIndex - }, - { - CTG_OP_CLEAR_CACHE, - "clear cache", - ctgOpClearCache - } -}; - - - +SCtgOperation gCtgCacheOperation[CTG_OP_MAX] = {{CTG_OP_UPDATE_VGROUP, "update vgInfo", ctgOpUpdateVgroup}, + {CTG_OP_UPDATE_TB_META, "update tbMeta", ctgOpUpdateTbMeta}, + {CTG_OP_DROP_DB_CACHE, "drop DB", ctgOpDropDbCache}, + {CTG_OP_DROP_DB_VGROUP, "drop DBVgroup", ctgOpDropDbVgroup}, + {CTG_OP_DROP_STB_META, "drop stbMeta", ctgOpDropStbMeta}, + {CTG_OP_DROP_TB_META, "drop tbMeta", ctgOpDropTbMeta}, + {CTG_OP_UPDATE_USER, "update user", ctgOpUpdateUser}, + {CTG_OP_UPDATE_VG_EPSET, "update epset", ctgOpUpdateEpset}, + {CTG_OP_UPDATE_TB_INDEX, "update tbIndex", ctgOpUpdateTbIndex}, + {CTG_OP_DROP_TB_INDEX, "drop tbIndex", ctgOpDropTbIndex}, + {CTG_OP_CLEAR_CACHE, "clear cache", ctgOpClearCache}}; int32_t ctgRLockVgInfo(SCatalog *pCtg, SCtgDBCache *dbCache, bool *inCache) { CTG_LOCK(CTG_READ, &dbCache->vgCache.vgLock); - + if (dbCache->deleted) { CTG_UNLOCK(CTG_READ, &dbCache->vgCache.vgLock); - ctgDebug("db is dropping, dbId:0x%"PRIx64, dbCache->dbId); - + ctgDebug("db is dropping, dbId:0x%" PRIx64, dbCache->dbId); + *inCache = false; return TSDB_CODE_SUCCESS; } - if (NULL == dbCache->vgCache.vgInfo) { CTG_UNLOCK(CTG_READ, &dbCache->vgCache.vgLock); *inCache = false; - ctgDebug("db vgInfo is empty, dbId:0x%"PRIx64, dbCache->dbId); + ctgDebug("db vgInfo is empty, dbId:0x%" PRIx64, dbCache->dbId); return TSDB_CODE_SUCCESS; } *inCache = true; - + return TSDB_CODE_SUCCESS; } @@ -110,7 +60,7 @@ int32_t ctgWLockVgInfo(SCatalog *pCtg, SCtgDBCache *dbCache) { CTG_LOCK(CTG_WRITE, &dbCache->vgCache.vgLock); if (dbCache->deleted) { - ctgDebug("db is dropping, dbId:0x%"PRIx64, dbCache->dbId); + ctgDebug("db is dropping, dbId:0x%" PRIx64, dbCache->dbId); CTG_UNLOCK(CTG_WRITE, &dbCache->vgCache.vgLock); CTG_ERR_RET(TSDB_CODE_CTG_DB_DROPPED); } @@ -118,19 +68,13 @@ int32_t ctgWLockVgInfo(SCatalog *pCtg, SCtgDBCache *dbCache) { return TSDB_CODE_SUCCESS; } -void ctgRUnlockVgInfo(SCtgDBCache *dbCache) { - CTG_UNLOCK(CTG_READ, &dbCache->vgCache.vgLock); -} +void ctgRUnlockVgInfo(SCtgDBCache *dbCache) { CTG_UNLOCK(CTG_READ, &dbCache->vgCache.vgLock); } -void ctgWUnlockVgInfo(SCtgDBCache *dbCache) { - CTG_UNLOCK(CTG_WRITE, &dbCache->vgCache.vgLock); -} +void ctgWUnlockVgInfo(SCtgDBCache *dbCache) { CTG_UNLOCK(CTG_WRITE, &dbCache->vgCache.vgLock); } -void ctgReleaseDBCache(SCatalog *pCtg, SCtgDBCache *dbCache) { - CTG_UNLOCK(CTG_READ, &dbCache->dbLock); -} +void ctgReleaseDBCache(SCatalog *pCtg, SCtgDBCache *dbCache) { CTG_UNLOCK(CTG_READ, &dbCache->dbLock); } -int32_t ctgAcquireDBCacheImpl(SCatalog* pCtg, const char *dbFName, SCtgDBCache **pCache, bool acquire) { +int32_t ctgAcquireDBCacheImpl(SCatalog *pCtg, const char *dbFName, SCtgDBCache **pCache, bool acquire) { char *p = strchr(dbFName, '.'); if (p && IS_SYS_DBNAME(p + 1)) { dbFName = p + 1; @@ -150,35 +94,35 @@ int32_t ctgAcquireDBCacheImpl(SCatalog* pCtg, const char *dbFName, SCtgDBCache * if (dbCache->deleted) { if (acquire) { ctgReleaseDBCache(pCtg, dbCache); - } - + } + *pCache = NULL; ctgDebug("db is removing from cache, dbFName:%s", dbFName); return TSDB_CODE_SUCCESS; } *pCache = dbCache; - + return TSDB_CODE_SUCCESS; } -int32_t ctgAcquireDBCache(SCatalog* pCtg, const char *dbFName, SCtgDBCache **pCache) { +int32_t ctgAcquireDBCache(SCatalog *pCtg, const char *dbFName, SCtgDBCache **pCache) { CTG_RET(ctgAcquireDBCacheImpl(pCtg, dbFName, pCache, true)); } -int32_t ctgGetDBCache(SCatalog* pCtg, const char *dbFName, SCtgDBCache **pCache) { +int32_t ctgGetDBCache(SCatalog *pCtg, const char *dbFName, SCtgDBCache **pCache) { CTG_RET(ctgAcquireDBCacheImpl(pCtg, dbFName, pCache, false)); } -void ctgReleaseVgInfoToCache(SCatalog* pCtg, SCtgDBCache *dbCache) { +void ctgReleaseVgInfoToCache(SCatalog *pCtg, SCtgDBCache *dbCache) { ctgRUnlockVgInfo(dbCache); ctgReleaseDBCache(pCtg, dbCache); } -void ctgReleaseTbMetaToCache(SCatalog* pCtg, SCtgDBCache *dbCache, SCtgTbCache* pCache) { +void ctgReleaseTbMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, SCtgTbCache *pCache) { if (pCache) { CTG_UNLOCK(CTG_READ, &pCache->metaLock); - taosHashRelease(dbCache->tbCache, pCache); + taosHashRelease(dbCache->tbCache, pCache); } if (dbCache) { @@ -186,10 +130,10 @@ void ctgReleaseTbMetaToCache(SCatalog* pCtg, SCtgDBCache *dbCache, SCtgTbCache* } } -void ctgReleaseTbIndexToCache(SCatalog* pCtg, SCtgDBCache *dbCache, SCtgTbCache* pCache) { +void ctgReleaseTbIndexToCache(SCatalog *pCtg, SCtgDBCache *dbCache, SCtgTbCache *pCache) { if (pCache) { CTG_UNLOCK(CTG_READ, &pCache->indexLock); - taosHashRelease(dbCache->tbCache, pCache); + taosHashRelease(dbCache->tbCache, pCache); } if (dbCache) { @@ -197,10 +141,10 @@ void ctgReleaseTbIndexToCache(SCatalog* pCtg, SCtgDBCache *dbCache, SCtgTbCache* } } -int32_t ctgAcquireVgInfoFromCache(SCatalog* pCtg, const char *dbFName, SCtgDBCache **pCache) { +int32_t ctgAcquireVgInfoFromCache(SCatalog *pCtg, const char *dbFName, SCtgDBCache **pCache) { SCtgDBCache *dbCache = NULL; ctgAcquireDBCache(pCtg, dbFName, &dbCache); - if (NULL == dbCache) { + if (NULL == dbCache) { ctgDebug("db %s not in cache", dbFName); goto _return; } @@ -217,7 +161,7 @@ int32_t ctgAcquireVgInfoFromCache(SCatalog* pCtg, const char *dbFName, SCtgDBCac CTG_CACHE_STAT_INC(numOfVgHit, 1); ctgDebug("Got db vgInfo from cache, dbFName:%s", dbFName); - + return TSDB_CODE_SUCCESS; _return: @@ -229,19 +173,19 @@ _return: *pCache = NULL; CTG_CACHE_STAT_INC(numOfVgMiss, 1); - + return TSDB_CODE_SUCCESS; } -int32_t ctgAcquireTbMetaFromCache(SCatalog* pCtg, char *dbFName, char* tbName, SCtgDBCache **pDb, SCtgTbCache** pTb) { +int32_t ctgAcquireTbMetaFromCache(SCatalog *pCtg, char *dbFName, char *tbName, SCtgDBCache **pDb, SCtgTbCache **pTb) { SCtgDBCache *dbCache = NULL; - SCtgTbCache* pCache = NULL; + SCtgTbCache *pCache = NULL; ctgAcquireDBCache(pCtg, dbFName, &dbCache); if (NULL == dbCache) { ctgDebug("db %s not in cache", dbFName); goto _return; } - + pCache = taosHashAcquire(dbCache->tbCache, tbName, strlen(tbName)); if (NULL == pCache) { ctgDebug("tb %s not in cache, dbFName:%s", tbName, dbFName); @@ -258,7 +202,7 @@ int32_t ctgAcquireTbMetaFromCache(SCatalog* pCtg, char *dbFName, char* tbName, S *pTb = pCache; ctgDebug("tb %s meta got in cache, dbFName:%s", tbName, dbFName); - + CTG_CACHE_STAT_INC(numOfMetaHit, 1); return TSDB_CODE_SUCCESS; @@ -268,20 +212,20 @@ _return: ctgReleaseTbMetaToCache(pCtg, dbCache, pCache); CTG_CACHE_STAT_INC(numOfMetaMiss, 1); - + return TSDB_CODE_SUCCESS; } -int32_t ctgAcquireStbMetaFromCache(SCatalog* pCtg, char *dbFName, uint64_t suid, SCtgDBCache **pDb, SCtgTbCache** pTb) { - SCtgDBCache* dbCache = NULL; - SCtgTbCache* pCache = NULL; +int32_t ctgAcquireStbMetaFromCache(SCatalog *pCtg, char *dbFName, uint64_t suid, SCtgDBCache **pDb, SCtgTbCache **pTb) { + SCtgDBCache *dbCache = NULL; + SCtgTbCache *pCache = NULL; ctgAcquireDBCache(pCtg, dbFName, &dbCache); if (NULL == dbCache) { ctgDebug("db %s not in cache", dbFName); goto _return; } - - char* stName = taosHashAcquire(dbCache->stbCache, &suid, sizeof(suid)); + + char *stName = taosHashAcquire(dbCache->stbCache, &suid, sizeof(suid)); if (NULL == stName) { ctgDebug("stb 0x%" PRIx64 " not in cache, dbFName:%s", suid, dbFName); goto _return; @@ -304,7 +248,7 @@ int32_t ctgAcquireStbMetaFromCache(SCatalog* pCtg, char *dbFName, uint64_t suid, *pTb = pCache; ctgDebug("stb 0x%" PRIx64 " meta got in cache, dbFName:%s", suid, dbFName); - + CTG_CACHE_STAT_INC(numOfMetaHit, 1); return TSDB_CODE_SUCCESS; @@ -317,20 +261,19 @@ _return: *pDb = NULL; *pTb = NULL; - + return TSDB_CODE_SUCCESS; } - -int32_t ctgAcquireTbIndexFromCache(SCatalog* pCtg, char *dbFName, char* tbName, SCtgDBCache **pDb, SCtgTbCache** pTb) { +int32_t ctgAcquireTbIndexFromCache(SCatalog *pCtg, char *dbFName, char *tbName, SCtgDBCache **pDb, SCtgTbCache **pTb) { SCtgDBCache *dbCache = NULL; - SCtgTbCache* pCache = NULL; + SCtgTbCache *pCache = NULL; ctgAcquireDBCache(pCtg, dbFName, &dbCache); if (NULL == dbCache) { ctgDebug("db %s not in cache", dbFName); goto _return; } - + int32_t sz = 0; pCache = taosHashAcquire(dbCache->tbCache, tbName, strlen(tbName)); if (NULL == pCache) { @@ -348,7 +291,7 @@ int32_t ctgAcquireTbIndexFromCache(SCatalog* pCtg, char *dbFName, char* tbName, *pTb = pCache; ctgDebug("tb %s index got in cache, dbFName:%s", tbName, dbFName); - + CTG_CACHE_STAT_INC(numOfIndexHit, 1); return TSDB_CODE_SUCCESS; @@ -358,32 +301,31 @@ _return: ctgReleaseTbIndexToCache(pCtg, dbCache, pCache); CTG_CACHE_STAT_INC(numOfIndexMiss, 1); - + return TSDB_CODE_SUCCESS; } - -int32_t ctgTbMetaExistInCache(SCatalog* pCtg, char *dbFName, char* tbName, int32_t *exist) { +int32_t ctgTbMetaExistInCache(SCatalog *pCtg, char *dbFName, char *tbName, int32_t *exist) { SCtgDBCache *dbCache = NULL; SCtgTbCache *tbCache = NULL; ctgAcquireTbMetaFromCache(pCtg, dbFName, tbName, &dbCache, &tbCache); if (NULL == tbCache) { ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache); - + *exist = 0; return TSDB_CODE_SUCCESS; } *exist = 1; ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache); - + return TSDB_CODE_SUCCESS; } -int32_t ctgReadTbMetaFromCache(SCatalog* pCtg, SCtgTbMetaCtx* ctx, STableMeta** pTableMeta) { - int32_t code = 0; +int32_t ctgReadTbMetaFromCache(SCatalog *pCtg, SCtgTbMetaCtx *ctx, STableMeta **pTableMeta) { + int32_t code = 0; SCtgDBCache *dbCache = NULL; - SCtgTbCache *tbCache = NULL; + SCtgTbCache *tbCache = NULL; *pTableMeta = NULL; char dbFName[TSDB_DB_FNAME_LEN] = {0}; @@ -399,12 +341,12 @@ int32_t ctgReadTbMetaFromCache(SCatalog* pCtg, SCtgTbMetaCtx* ctx, STableMeta** return TSDB_CODE_SUCCESS; } - STableMeta* tbMeta = tbCache->pMeta; + STableMeta *tbMeta = tbCache->pMeta; ctx->tbInfo.inCache = true; ctx->tbInfo.dbId = dbCache->dbId; ctx->tbInfo.suid = tbMeta->suid; ctx->tbInfo.tbType = tbMeta->tableType; - + if (tbMeta->tableType != TSDB_CHILD_TABLE) { int32_t metaSize = CTG_META_SIZE(tbMeta); *pTableMeta = taosMemoryCalloc(1, metaSize); @@ -414,14 +356,14 @@ int32_t ctgReadTbMetaFromCache(SCatalog* pCtg, SCtgTbMetaCtx* ctx, STableMeta** } memcpy(*pTableMeta, tbMeta, metaSize); - + ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache); ctgDebug("Got tb %s meta from cache, type:%d, dbFName:%s", ctx->pName->tname, tbMeta->tableType, dbFName); return TSDB_CODE_SUCCESS; } // PROCESS FOR CHILD TABLE - + int32_t metaSize = sizeof(SCTableMeta); *pTableMeta = taosMemoryCalloc(1, metaSize); if (NULL == *pTableMeta) { @@ -429,10 +371,10 @@ int32_t ctgReadTbMetaFromCache(SCatalog* pCtg, SCtgTbMetaCtx* ctx, STableMeta** } memcpy(*pTableMeta, tbMeta, metaSize); - + ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache); - ctgDebug("Got ctb %s meta from cache, will continue to get its stb meta, type:%d, dbFName:%s", - ctx->pName->tname, ctx->tbInfo.tbType, dbFName); + ctgDebug("Got ctb %s meta from cache, will continue to get its stb meta, type:%d, dbFName:%s", ctx->pName->tname, + ctx->tbInfo.tbType, dbFName); ctgAcquireStbMetaFromCache(pCtg, dbFName, ctx->tbInfo.suid, &dbCache, &tbCache); if (NULL == tbCache) { @@ -441,17 +383,17 @@ int32_t ctgReadTbMetaFromCache(SCatalog* pCtg, SCtgTbMetaCtx* ctx, STableMeta** ctgDebug("stb 0x%" PRIx64 " meta not in cache", ctx->tbInfo.suid); return TSDB_CODE_SUCCESS; } - - STableMeta* stbMeta = tbCache->pMeta; - if (stbMeta->suid != ctx->tbInfo.suid) { + + STableMeta *stbMeta = tbCache->pMeta; + if (stbMeta->suid != ctx->tbInfo.suid) { ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache); - ctgError("stb suid 0x%" PRIx64 " in stbCache mis-match, expected suid 0x%"PRIx64 , stbMeta->suid, ctx->tbInfo.suid); + ctgError("stb suid 0x%" PRIx64 " in stbCache mis-match, expected suid 0x%" PRIx64, stbMeta->suid, ctx->tbInfo.suid); CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR); } metaSize = CTG_META_SIZE(stbMeta); *pTableMeta = taosMemoryRealloc(*pTableMeta, metaSize); - if (NULL == *pTableMeta) { + if (NULL == *pTableMeta) { ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache); CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); } @@ -461,24 +403,24 @@ int32_t ctgReadTbMetaFromCache(SCatalog* pCtg, SCtgTbMetaCtx* ctx, STableMeta** ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache); ctgDebug("Got tb %s meta from cache, dbFName:%s", ctx->pName->tname, dbFName); - + return TSDB_CODE_SUCCESS; _return: ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache); taosMemoryFreeClear(*pTableMeta); - + CTG_RET(code); } -int32_t ctgReadTbVerFromCache(SCatalog *pCtg, SName *pTableName, int32_t *sver, int32_t *tver, int32_t *tbType, uint64_t *suid, - char *stbName) { +int32_t ctgReadTbVerFromCache(SCatalog *pCtg, SName *pTableName, int32_t *sver, int32_t *tver, int32_t *tbType, + uint64_t *suid, char *stbName) { *sver = -1; *tver = -1; SCtgDBCache *dbCache = NULL; - SCtgTbCache *tbCache = NULL; + SCtgTbCache *tbCache = NULL; char dbFName[TSDB_DB_FNAME_LEN] = {0}; tNameGetFullDbName(pTableName, dbFName); @@ -488,7 +430,7 @@ int32_t ctgReadTbVerFromCache(SCatalog *pCtg, SName *pTableName, int32_t *sver, return TSDB_CODE_SUCCESS; } - STableMeta* tbMeta = tbCache->pMeta; + STableMeta *tbMeta = tbCache->pMeta; *tbType = tbMeta->tableType; *suid = tbMeta->suid; @@ -496,29 +438,29 @@ int32_t ctgReadTbVerFromCache(SCatalog *pCtg, SName *pTableName, int32_t *sver, *sver = tbMeta->sversion; *tver = tbMeta->tversion; - ctgDebug("Got tb %s ver from cache, dbFName:%s, tbType:%d, sver:%d, tver:%d, suid:0x%" PRIx64, - pTableName->tname, dbFName, *tbType, *sver, *tver, *suid); + ctgDebug("Got tb %s ver from cache, dbFName:%s, tbType:%d, sver:%d, tver:%d, suid:0x%" PRIx64, pTableName->tname, + dbFName, *tbType, *sver, *tver, *suid); ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache); return TSDB_CODE_SUCCESS; } // PROCESS FOR CHILD TABLE - + ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache); ctgDebug("Got ctb %s ver from cache, will continue to get its stb ver, dbFName:%s", pTableName->tname, dbFName); - + ctgAcquireStbMetaFromCache(pCtg, dbFName, *suid, &dbCache, &tbCache); if (NULL == tbCache) { ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache); ctgDebug("stb 0x%" PRIx64 " meta not in cache", *suid); return TSDB_CODE_SUCCESS; } - - STableMeta* stbMeta = tbCache->pMeta; + + STableMeta *stbMeta = tbCache->pMeta; if (stbMeta->suid != *suid) { ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache); - ctgError("stb suid 0x%" PRIx64 " in stbCache mis-match, expected suid:0x%" PRIx64 , stbMeta->suid, *suid); + ctgError("stb suid 0x%" PRIx64 " in stbCache mis-match, expected suid:0x%" PRIx64, stbMeta->suid, *suid); CTG_ERR_RET(TSDB_CODE_CTG_INTERNAL_ERROR); } @@ -533,15 +475,15 @@ int32_t ctgReadTbVerFromCache(SCatalog *pCtg, SName *pTableName, int32_t *sver, ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache); - ctgDebug("Got tb %s sver %d tver %d from cache, type:%d, dbFName:%s", pTableName->tname, *sver, *tver, *tbType, dbFName); + ctgDebug("Got tb %s sver %d tver %d from cache, type:%d, dbFName:%s", pTableName->tname, *sver, *tver, *tbType, + dbFName); return TSDB_CODE_SUCCESS; } - -int32_t ctgReadTbTypeFromCache(SCatalog* pCtg, char* dbFName, char *tbName, int32_t *tbType) { +int32_t ctgReadTbTypeFromCache(SCatalog *pCtg, char *dbFName, char *tbName, int32_t *tbType) { SCtgDBCache *dbCache = NULL; - SCtgTbCache *tbCache = NULL; + SCtgTbCache *tbCache = NULL; CTG_ERR_RET(ctgAcquireTbMetaFromCache(pCtg, dbFName, tbName, &dbCache, &tbCache)); if (NULL == tbCache) { ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache); @@ -551,15 +493,15 @@ int32_t ctgReadTbTypeFromCache(SCatalog* pCtg, char* dbFName, char *tbName, int3 *tbType = tbCache->pMeta->tableType; ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache); - ctgDebug("Got tb %s tbType %d from cache, dbFName:%s", tbName, *tbType, dbFName); - + ctgDebug("Got tb %s tbType %d from cache, dbFName:%s", tbName, *tbType, dbFName); + return TSDB_CODE_SUCCESS; } -int32_t ctgReadTbIndexFromCache(SCatalog* pCtg, SName* pTableName, SArray** pRes) { - int32_t code = 0; +int32_t ctgReadTbIndexFromCache(SCatalog *pCtg, SName *pTableName, SArray **pRes) { + int32_t code = 0; SCtgDBCache *dbCache = NULL; - SCtgTbCache *tbCache = NULL; + SCtgTbCache *tbCache = NULL; char dbFName[TSDB_DB_FNAME_LEN] = {0}; tNameGetFullDbName(pTableName, dbFName); @@ -580,14 +522,14 @@ _return: CTG_RET(code); } -int32_t ctgChkAuthFromCache(SCatalog* pCtg, char* user, char* dbFName, AUTH_TYPE type, bool *inCache, bool *pass) { +int32_t ctgChkAuthFromCache(SCatalog *pCtg, char *user, char *dbFName, AUTH_TYPE type, bool *inCache, bool *pass) { char *p = strchr(dbFName, '.'); if (p) { ++p; } else { p = dbFName; } - + if (IS_SYS_DBNAME(p)) { *inCache = true; *pass = true; @@ -605,7 +547,7 @@ int32_t ctgChkAuthFromCache(SCatalog* pCtg, char* user, char* dbFName, AUTH_TYPE ctgDebug("Got user from cache, user:%s", user); CTG_CACHE_STAT_INC(numOfUserHit, 1); - + if (pUser->superUser) { *pass = true; return TSDB_CODE_SUCCESS; @@ -617,54 +559,53 @@ int32_t ctgChkAuthFromCache(SCatalog* pCtg, char* user, char* dbFName, AUTH_TYPE CTG_UNLOCK(CTG_READ, &pUser->lock); return TSDB_CODE_SUCCESS; } - + if (pUser->readDbs && taosHashGet(pUser->readDbs, dbFName, strlen(dbFName)) && type == AUTH_TYPE_READ) { *pass = true; } - + if (pUser->writeDbs && taosHashGet(pUser->writeDbs, dbFName, strlen(dbFName)) && type == AUTH_TYPE_WRITE) { *pass = true; } CTG_UNLOCK(CTG_READ, &pUser->lock); - + return TSDB_CODE_SUCCESS; _return: *inCache = false; CTG_CACHE_STAT_INC(numOfUserMiss, 1); - + return TSDB_CODE_SUCCESS; } void ctgDequeue(SCtgCacheOperation **op) { SCtgQNode *orig = gCtgMgmt.queue.head; - + SCtgQNode *node = gCtgMgmt.queue.head->next; gCtgMgmt.queue.head = gCtgMgmt.queue.head->next; CTG_QUEUE_DEC(); - + taosMemoryFreeClear(orig); *op = node->op; } - -int32_t ctgEnqueue(SCatalog* pCtg, SCtgCacheOperation *operation) { +int32_t ctgEnqueue(SCatalog *pCtg, SCtgCacheOperation *operation) { SCtgQNode *node = taosMemoryCalloc(1, sizeof(SCtgQNode)); if (NULL == node) { qError("calloc %d failed", (int32_t)sizeof(SCtgQNode)); CTG_RET(TSDB_CODE_OUT_OF_MEMORY); } - bool syncOp = operation->syncOp; - char* opName = gCtgCacheOperation[operation->opId].name; + bool syncOp = operation->syncOp; + char *opName = gCtgCacheOperation[operation->opId].name; if (operation->syncOp) { tsem_init(&operation->rspSem, 0, 0); } - + node->op = operation; CTG_LOCK(CTG_WRITE, &gCtgMgmt.queue.qlock); @@ -699,12 +640,11 @@ int32_t ctgEnqueue(SCatalog* pCtg, SCtgCacheOperation *operation) { return TSDB_CODE_SUCCESS; } - -int32_t ctgDropDbCacheEnqueue(SCatalog* pCtg, const char *dbFName, int64_t dbId) { - int32_t code = 0; +int32_t ctgDropDbCacheEnqueue(SCatalog *pCtg, const char *dbFName, int64_t dbId) { + int32_t code = 0; SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation)); op->opId = CTG_OP_DROP_DB_CACHE; - + SCtgDropDBMsg *msg = taosMemoryMalloc(sizeof(SCtgDropDBMsg)); if (NULL == msg) { ctgError("malloc %d failed", (int32_t)sizeof(SCtgDropDBMsg)); @@ -732,12 +672,12 @@ _return: CTG_RET(code); } -int32_t ctgDropDbVgroupEnqueue(SCatalog* pCtg, const char *dbFName, bool syncOp) { - int32_t code = 0; +int32_t ctgDropDbVgroupEnqueue(SCatalog *pCtg, const char *dbFName, bool syncOp) { + int32_t code = 0; SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation)); op->opId = CTG_OP_DROP_DB_VGROUP; op->syncOp = syncOp; - + SCtgDropDbVgroupMsg *msg = taosMemoryMalloc(sizeof(SCtgDropDbVgroupMsg)); if (NULL == msg) { ctgError("malloc %d failed", (int32_t)sizeof(SCtgDropDbVgroupMsg)); @@ -764,14 +704,13 @@ _return: CTG_RET(code); } - - -int32_t ctgDropStbMetaEnqueue(SCatalog* pCtg, const char *dbFName, int64_t dbId, const char *stbName, uint64_t suid, bool syncOp) { - int32_t code = 0; +int32_t ctgDropStbMetaEnqueue(SCatalog *pCtg, const char *dbFName, int64_t dbId, const char *stbName, uint64_t suid, + bool syncOp) { + int32_t code = 0; SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation)); op->opId = CTG_OP_DROP_STB_META; op->syncOp = syncOp; - + SCtgDropStbMetaMsg *msg = taosMemoryMalloc(sizeof(SCtgDropStbMetaMsg)); if (NULL == msg) { ctgError("malloc %d failed", (int32_t)sizeof(SCtgDropStbMetaMsg)); @@ -796,14 +735,12 @@ _return: CTG_RET(code); } - - -int32_t ctgDropTbMetaEnqueue(SCatalog* pCtg, const char *dbFName, int64_t dbId, const char *tbName, bool syncOp) { - int32_t code = 0; +int32_t ctgDropTbMetaEnqueue(SCatalog *pCtg, const char *dbFName, int64_t dbId, const char *tbName, bool syncOp) { + int32_t code = 0; SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation)); op->opId = CTG_OP_DROP_TB_META; op->syncOp = syncOp; - + SCtgDropTblMetaMsg *msg = taosMemoryMalloc(sizeof(SCtgDropTblMetaMsg)); if (NULL == msg) { ctgError("malloc %d failed", (int32_t)sizeof(SCtgDropTblMetaMsg)); @@ -827,12 +764,12 @@ _return: CTG_RET(code); } -int32_t ctgUpdateVgroupEnqueue(SCatalog* pCtg, const char *dbFName, int64_t dbId, SDBVgInfo* dbInfo, bool syncOp) { - int32_t code = 0; +int32_t ctgUpdateVgroupEnqueue(SCatalog *pCtg, const char *dbFName, int64_t dbId, SDBVgInfo *dbInfo, bool syncOp) { + int32_t code = 0; SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation)); op->opId = CTG_OP_UPDATE_VGROUP; op->syncOp = syncOp; - + SCtgUpdateVgMsg *msg = taosMemoryMalloc(sizeof(SCtgUpdateVgMsg)); if (NULL == msg) { ctgError("malloc %d failed", (int32_t)sizeof(SCtgUpdateVgMsg)); @@ -864,12 +801,12 @@ _return: CTG_RET(code); } -int32_t ctgUpdateTbMetaEnqueue(SCatalog* pCtg, STableMetaOutput *output, bool syncOp) { - int32_t code = 0; +int32_t ctgUpdateTbMetaEnqueue(SCatalog *pCtg, STableMetaOutput *output, bool syncOp) { + int32_t code = 0; SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation)); op->opId = CTG_OP_UPDATE_TB_META; op->syncOp = syncOp; - + SCtgUpdateTbMetaMsg *msg = taosMemoryMalloc(sizeof(SCtgUpdateTbMetaMsg)); if (NULL == msg) { ctgError("malloc %d failed", (int32_t)sizeof(SCtgUpdateTbMetaMsg)); @@ -889,7 +826,7 @@ int32_t ctgUpdateTbMetaEnqueue(SCatalog* pCtg, STableMetaOutput *output, bool sy CTG_ERR_JRET(ctgEnqueue(pCtg, op)); return TSDB_CODE_SUCCESS; - + _return: if (output) { @@ -898,15 +835,15 @@ _return: } taosMemoryFreeClear(msg); - + CTG_RET(code); } -int32_t ctgUpdateVgEpsetEnqueue(SCatalog* pCtg, char *dbFName, int32_t vgId, SEpSet* pEpSet) { - int32_t code = 0; +int32_t ctgUpdateVgEpsetEnqueue(SCatalog *pCtg, char *dbFName, int32_t vgId, SEpSet *pEpSet) { + int32_t code = 0; SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation)); op->opId = CTG_OP_UPDATE_VG_EPSET; - + SCtgUpdateEpsetMsg *msg = taosMemoryMalloc(sizeof(SCtgUpdateEpsetMsg)); if (NULL == msg) { ctgError("malloc %d failed", (int32_t)sizeof(SCtgUpdateEpsetMsg)); @@ -923,22 +860,20 @@ int32_t ctgUpdateVgEpsetEnqueue(SCatalog* pCtg, char *dbFName, int32_t vgId, SEp CTG_ERR_JRET(ctgEnqueue(pCtg, op)); return TSDB_CODE_SUCCESS; - + _return: taosMemoryFreeClear(msg); - + CTG_RET(code); } - - -int32_t ctgUpdateUserEnqueue(SCatalog* pCtg, SGetUserAuthRsp *pAuth, bool syncOp) { - int32_t code = 0; +int32_t ctgUpdateUserEnqueue(SCatalog *pCtg, SGetUserAuthRsp *pAuth, bool syncOp) { + int32_t code = 0; SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation)); op->opId = CTG_OP_UPDATE_USER; op->syncOp = syncOp; - + SCtgUpdateUserMsg *msg = taosMemoryMalloc(sizeof(SCtgUpdateUserMsg)); if (NULL == msg) { ctgError("malloc %d failed", (int32_t)sizeof(SCtgUpdateUserMsg)); @@ -951,23 +886,23 @@ int32_t ctgUpdateUserEnqueue(SCatalog* pCtg, SGetUserAuthRsp *pAuth, bool syncOp op->data = msg; CTG_ERR_JRET(ctgEnqueue(pCtg, op)); - + return TSDB_CODE_SUCCESS; - + _return: tFreeSGetUserAuthRsp(pAuth); taosMemoryFreeClear(msg); - + CTG_RET(code); } -int32_t ctgUpdateTbIndexEnqueue(SCatalog* pCtg, STableIndex **pIndex, bool syncOp) { - int32_t code = 0; +int32_t ctgUpdateTbIndexEnqueue(SCatalog *pCtg, STableIndex **pIndex, bool syncOp) { + int32_t code = 0; SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation)); op->opId = CTG_OP_UPDATE_TB_INDEX; op->syncOp = syncOp; - + SCtgUpdateTbIndexMsg *msg = taosMemoryMalloc(sizeof(SCtgUpdateTbIndexMsg)); if (NULL == msg) { ctgError("malloc %d failed", (int32_t)sizeof(SCtgUpdateTbIndexMsg)); @@ -983,22 +918,22 @@ int32_t ctgUpdateTbIndexEnqueue(SCatalog* pCtg, STableIndex **pIndex, bool syncO *pIndex = NULL; return TSDB_CODE_SUCCESS; - + _return: taosArrayDestroyEx((*pIndex)->pIndex, tFreeSTableIndexInfo); taosMemoryFreeClear(*pIndex); taosMemoryFreeClear(msg); - + CTG_RET(code); } -int32_t ctgDropTbIndexEnqueue(SCatalog* pCtg, SName* pName, bool syncOp) { - int32_t code = 0; +int32_t ctgDropTbIndexEnqueue(SCatalog *pCtg, SName *pName, bool syncOp) { + int32_t code = 0; SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation)); op->opId = CTG_OP_DROP_TB_INDEX; op->syncOp = syncOp; - + SCtgDropTbIndexMsg *msg = taosMemoryMalloc(sizeof(SCtgDropTbIndexMsg)); if (NULL == msg) { ctgError("malloc %d failed", (int32_t)sizeof(SCtgDropTbIndexMsg)); @@ -1012,25 +947,24 @@ int32_t ctgDropTbIndexEnqueue(SCatalog* pCtg, SName* pName, bool syncOp) { op->data = msg; CTG_ERR_JRET(ctgEnqueue(pCtg, op)); - + return TSDB_CODE_SUCCESS; - + _return: taosMemoryFreeClear(msg); - + CTG_RET(code); } - -int32_t ctgClearCacheEnqueue(SCatalog* pCtg, bool freeCtg, bool stopQueue, bool syncOp) { - int32_t code = 0; +int32_t ctgClearCacheEnqueue(SCatalog *pCtg, bool freeCtg, bool stopQueue, bool syncOp) { + int32_t code = 0; SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation)); op->opId = CTG_OP_CLEAR_CACHE; op->syncOp = syncOp; op->stopQueue = stopQueue; op->unLocked = true; - + SCtgClearCacheMsg *msg = taosMemoryMalloc(sizeof(SCtgClearCacheMsg)); if (NULL == msg) { ctgError("malloc %d failed", (int32_t)sizeof(SCtgClearCacheMsg)); @@ -1042,24 +976,23 @@ int32_t ctgClearCacheEnqueue(SCatalog* pCtg, bool freeCtg, bool stopQueue, bool op->data = msg; CTG_ERR_JRET(ctgEnqueue(pCtg, op)); - + return TSDB_CODE_SUCCESS; - + _return: taosMemoryFreeClear(msg); - + CTG_RET(code); } - int32_t ctgMetaRentInit(SCtgRentMgmt *mgmt, uint32_t rentSec, int8_t type) { mgmt->slotRIdx = 0; mgmt->slotNum = rentSec / CTG_RENT_SLOT_SECOND; mgmt->type = type; size_t msgSize = sizeof(SCtgRentSlot) * mgmt->slotNum; - + mgmt->slots = taosMemoryCalloc(1, msgSize); if (NULL == mgmt->slots) { qError("calloc %d failed", (int32_t)msgSize); @@ -1067,34 +1000,34 @@ int32_t ctgMetaRentInit(SCtgRentMgmt *mgmt, uint32_t rentSec, int8_t type) { } qDebug("meta rent initialized, type:%d, slotNum:%d", type, mgmt->slotNum); - + return TSDB_CODE_SUCCESS; } - int32_t ctgMetaRentAdd(SCtgRentMgmt *mgmt, void *meta, int64_t id, int32_t size) { int16_t widx = abs((int)(id % mgmt->slotNum)); SCtgRentSlot *slot = &mgmt->slots[widx]; - int32_t code = 0; - + int32_t code = 0; + CTG_LOCK(CTG_WRITE, &slot->lock); if (NULL == slot->meta) { slot->meta = taosArrayInit(CTG_DEFAULT_RENT_SLOT_SIZE, size); if (NULL == slot->meta) { - qError("taosArrayInit %d failed, id:0x%"PRIx64", slot idx:%d, type:%d", CTG_DEFAULT_RENT_SLOT_SIZE, id, widx, mgmt->type); + qError("taosArrayInit %d failed, id:0x%" PRIx64 ", slot idx:%d, type:%d", CTG_DEFAULT_RENT_SLOT_SIZE, id, widx, + mgmt->type); CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); } } if (NULL == taosArrayPush(slot->meta, meta)) { - qError("taosArrayPush meta to rent failed, id:0x%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type); + qError("taosArrayPush meta to rent failed, id:0x%" PRIx64 ", slot idx:%d, type:%d", id, widx, mgmt->type); CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); } slot->needSort = true; - qDebug("add meta to rent, id:0x%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type); + qDebug("add meta to rent, id:0x%" PRIx64 ", slot idx:%d, type:%d", id, widx, mgmt->type); _return: @@ -1102,20 +1035,22 @@ _return: CTG_RET(code); } -int32_t ctgMetaRentUpdate(SCtgRentMgmt *mgmt, void *meta, int64_t id, int32_t size, __compar_fn_t sortCompare, __compar_fn_t searchCompare) { +int32_t ctgMetaRentUpdate(SCtgRentMgmt *mgmt, void *meta, int64_t id, int32_t size, __compar_fn_t sortCompare, + __compar_fn_t searchCompare) { int16_t widx = abs((int)(id % mgmt->slotNum)); SCtgRentSlot *slot = &mgmt->slots[widx]; - int32_t code = 0; + int32_t code = 0; CTG_LOCK(CTG_WRITE, &slot->lock); if (NULL == slot->meta) { - qDebug("empty meta slot, id:0x%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type); + qDebug("empty meta slot, id:0x%" PRIx64 ", slot idx:%d, type:%d", id, widx, mgmt->type); CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR); } if (slot->needSort) { - qDebug("meta slot before sorte, slot idx:%d, type:%d, size:%d", widx, mgmt->type, (int32_t)taosArrayGetSize(slot->meta)); + qDebug("meta slot before sorte, slot idx:%d, type:%d, size:%d", widx, mgmt->type, + (int32_t)taosArrayGetSize(slot->meta)); taosArraySort(slot->meta, sortCompare); slot->needSort = false; qDebug("meta slot sorted, slot idx:%d, type:%d, size:%d", widx, mgmt->type, (int32_t)taosArrayGetSize(slot->meta)); @@ -1123,20 +1058,22 @@ int32_t ctgMetaRentUpdate(SCtgRentMgmt *mgmt, void *meta, int64_t id, int32_t si void *orig = taosArraySearch(slot->meta, &id, searchCompare, TD_EQ); if (NULL == orig) { - qDebug("meta not found in slot, id:0x%"PRIx64", slot idx:%d, type:%d, size:%d", id, widx, mgmt->type, (int32_t)taosArrayGetSize(slot->meta)); + qDebug("meta not found in slot, id:0x%" PRIx64 ", slot idx:%d, type:%d, size:%d", id, widx, mgmt->type, + (int32_t)taosArrayGetSize(slot->meta)); CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR); } memcpy(orig, meta, size); - qDebug("meta in rent updated, id:0x%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type); + qDebug("meta in rent updated, id:0x%" PRIx64 ", slot idx:%d, type:%d", id, widx, mgmt->type); _return: CTG_UNLOCK(CTG_WRITE, &slot->lock); if (code) { - qDebug("meta in rent update failed, will try to add it, code:%x, id:0x%"PRIx64", slot idx:%d, type:%d", code, id, widx, mgmt->type); + qDebug("meta in rent update failed, will try to add it, code:%x, id:0x%" PRIx64 ", slot idx:%d, type:%d", code, id, + widx, mgmt->type); CTG_RET(ctgMetaRentAdd(mgmt, meta, id, size)); } @@ -1147,11 +1084,11 @@ int32_t ctgMetaRentRemove(SCtgRentMgmt *mgmt, int64_t id, __compar_fn_t sortComp int16_t widx = abs((int)(id % mgmt->slotNum)); SCtgRentSlot *slot = &mgmt->slots[widx]; - int32_t code = 0; - + int32_t code = 0; + CTG_LOCK(CTG_WRITE, &slot->lock); if (NULL == slot->meta) { - qError("empty meta slot, id:0x%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type); + qError("empty meta slot, id:0x%" PRIx64 ", slot idx:%d, type:%d", id, widx, mgmt->type); CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR); } @@ -1163,13 +1100,13 @@ int32_t ctgMetaRentRemove(SCtgRentMgmt *mgmt, int64_t id, __compar_fn_t sortComp int32_t idx = taosArraySearchIdx(slot->meta, &id, searchCompare, TD_EQ); if (idx < 0) { - qError("meta not found in slot, id:0x%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type); + qError("meta not found in slot, id:0x%" PRIx64 ", slot idx:%d, type:%d", id, widx, mgmt->type); CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR); } taosArrayRemove(slot->meta, idx); - qDebug("meta in rent removed, id:0x%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type); + qDebug("meta in rent removed, id:0x%" PRIx64 ", slot idx:%d, type:%d", id, widx, mgmt->type); _return: @@ -1178,7 +1115,6 @@ _return: CTG_RET(code); } - int32_t ctgMetaRentGetImpl(SCtgRentMgmt *mgmt, void **res, uint32_t *num, int32_t size) { int16_t ridx = atomic_add_fetch_16(&mgmt->slotRIdx, 1); if (ridx >= mgmt->slotNum) { @@ -1187,8 +1123,8 @@ int32_t ctgMetaRentGetImpl(SCtgRentMgmt *mgmt, void **res, uint32_t *num, int32_ } SCtgRentSlot *slot = &mgmt->slots[ridx]; - int32_t code = 0; - + int32_t code = 0; + CTG_LOCK(CTG_READ, &slot->lock); if (NULL == slot->meta) { qDebug("empty meta in slot:%d, type:%d", ridx, mgmt->type); @@ -1254,13 +1190,15 @@ int32_t ctgAddNewDBCache(SCatalog *pCtg, const char *dbFName, uint64_t dbId) { SCtgDBCache newDBCache = {0}; newDBCache.dbId = dbId; - newDBCache.tbCache = taosHashInit(gCtgMgmt.cfg.maxTblCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK); + newDBCache.tbCache = taosHashInit(gCtgMgmt.cfg.maxTblCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), + true, HASH_ENTRY_LOCK); if (NULL == newDBCache.tbCache) { ctgError("taosHashInit %d metaCache failed", gCtgMgmt.cfg.maxTblCacheNum); CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); } - newDBCache.stbCache = taosHashInit(gCtgMgmt.cfg.maxTblCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), true, HASH_ENTRY_LOCK); + newDBCache.stbCache = taosHashInit(gCtgMgmt.cfg.maxTblCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), + true, HASH_ENTRY_LOCK); if (NULL == newDBCache.stbCache) { ctgError("taosHashInit %d stbCache failed", gCtgMgmt.cfg.maxTblCacheNum); CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); @@ -1272,21 +1210,21 @@ int32_t ctgAddNewDBCache(SCatalog *pCtg, const char *dbFName, uint64_t dbId) { ctgDebug("db already in cache, dbFName:%s", dbFName); goto _return; } - + ctgError("taosHashPut db to cache failed, dbFName:%s", dbFName); CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); } CTG_CACHE_STAT_INC(numOfDb, 1); - + SDbVgVersion vgVersion = {.dbId = newDBCache.dbId, .vgVersion = -1}; strncpy(vgVersion.dbFName, dbFName, sizeof(vgVersion.dbFName)); - ctgDebug("db added to cache, dbFName:%s, dbId:0x%"PRIx64, dbFName, dbId); + ctgDebug("db added to cache, dbFName:%s, dbId:0x%" PRIx64, dbFName, dbId); CTG_ERR_RET(ctgMetaRentAdd(&pCtg->dbRent, &vgVersion, dbId, sizeof(SDbVgVersion))); - ctgDebug("db added to rent, dbFName:%s, vgVersion:%d, dbId:0x%"PRIx64, dbFName, vgVersion.vgVersion, dbId); + ctgDebug("db added to rent, dbFName:%s, vgVersion:%d, dbId:0x%" PRIx64, dbFName, vgVersion.vgVersion, dbId); return TSDB_CODE_SUCCESS; @@ -1297,30 +1235,29 @@ _return: CTG_RET(code); } - -void ctgRemoveStbRent(SCatalog* pCtg, SCtgDBCache *dbCache) { +void ctgRemoveStbRent(SCatalog *pCtg, SCtgDBCache *dbCache) { if (NULL == dbCache->stbCache) { return; } - + void *pIter = taosHashIterate(dbCache->stbCache, NULL); while (pIter) { uint64_t *suid = NULL; suid = taosHashGetKey(pIter, NULL); - if (TSDB_CODE_SUCCESS == ctgMetaRentRemove(&pCtg->stbRent, *suid, ctgStbVersionSortCompare, ctgStbVersionSearchCompare)) { - ctgDebug("stb removed from rent, suid:0x%"PRIx64, *suid); + if (TSDB_CODE_SUCCESS == + ctgMetaRentRemove(&pCtg->stbRent, *suid, ctgStbVersionSortCompare, ctgStbVersionSearchCompare)) { + ctgDebug("stb removed from rent, suid:0x%" PRIx64, *suid); } - + pIter = taosHashIterate(dbCache->stbCache, pIter); } } - -int32_t ctgRemoveDBFromCache(SCatalog* pCtg, SCtgDBCache *dbCache, const char* dbFName) { +int32_t ctgRemoveDBFromCache(SCatalog *pCtg, SCtgDBCache *dbCache, const char *dbFName) { uint64_t dbId = dbCache->dbId; - - ctgInfo("start to remove db from cache, dbFName:%s, dbId:0x%"PRIx64, dbFName, dbCache->dbId); + + ctgInfo("start to remove db from cache, dbFName:%s, dbId:0x%" PRIx64, dbFName, dbCache->dbId); CTG_LOCK(CTG_WRITE, &dbCache->dbLock); @@ -1331,7 +1268,7 @@ int32_t ctgRemoveDBFromCache(SCatalog* pCtg, SCtgDBCache *dbCache, const char* d CTG_UNLOCK(CTG_WRITE, &dbCache->dbLock); CTG_ERR_RET(ctgMetaRentRemove(&pCtg->dbRent, dbId, ctgDbVgVersionSortCompare, ctgDbVgVersionSearchCompare)); - ctgDebug("db removed from rent, dbFName:%s, dbId:0x%"PRIx64, dbFName, dbId); + ctgDebug("db removed from rent, dbFName:%s, dbId:0x%" PRIx64, dbFName, dbId); if (taosHashRemove(pCtg->dbCache, dbFName, strlen(dbFName))) { ctgInfo("taosHashRemove from dbCache failed, may be removed, dbFName:%s", dbFName); @@ -1339,19 +1276,18 @@ int32_t ctgRemoveDBFromCache(SCatalog* pCtg, SCtgDBCache *dbCache, const char* d } CTG_CACHE_STAT_DEC(numOfDb, 1); - ctgInfo("db removed from cache, dbFName:%s, dbId:0x%"PRIx64, dbFName, dbId); - + ctgInfo("db removed from cache, dbFName:%s, dbId:0x%" PRIx64, dbFName, dbId); + return TSDB_CODE_SUCCESS; } - -int32_t ctgGetAddDBCache(SCatalog* pCtg, const char *dbFName, uint64_t dbId, SCtgDBCache **pCache) { - int32_t code = 0; +int32_t ctgGetAddDBCache(SCatalog *pCtg, const char *dbFName, uint64_t dbId, SCtgDBCache **pCache) { + int32_t code = 0; SCtgDBCache *dbCache = NULL; ctgGetDBCache(pCtg, dbFName, &dbCache); - + if (dbCache) { - // TODO OPEN IT + // TODO OPEN IT #if 0 if (dbCache->dbId == dbId) { *pCache = dbCache; @@ -1368,7 +1304,7 @@ int32_t ctgGetAddDBCache(SCatalog* pCtg, const char *dbFName, uint64_t dbId, SCt *pCache = dbCache; return TSDB_CODE_SUCCESS; } - + if (dbCache->dbId == dbId) { *pCache = dbCache; return TSDB_CODE_SUCCESS; @@ -1376,7 +1312,7 @@ int32_t ctgGetAddDBCache(SCatalog* pCtg, const char *dbFName, uint64_t dbId, SCt #endif CTG_ERR_RET(ctgRemoveDBFromCache(pCtg, dbCache, dbFName)); } - + CTG_ERR_RET(ctgAddNewDBCache(pCtg, dbFName, dbId)); ctgGetDBCache(pCtg, dbFName, &dbCache); @@ -1386,7 +1322,8 @@ int32_t ctgGetAddDBCache(SCatalog* pCtg, const char *dbFName, uint64_t dbId, SCt return TSDB_CODE_SUCCESS; } -int32_t ctgUpdateRentStbVersion(SCatalog *pCtg, char* dbFName, char* tbName, uint64_t dbId, uint64_t suid, SCtgTbCache* pCache) { +int32_t ctgUpdateRentStbVersion(SCatalog *pCtg, char *dbFName, char *tbName, uint64_t dbId, uint64_t suid, + SCtgTbCache *pCache) { SSTableVersion metaRent = {.dbId = dbId, .suid = suid}; if (pCache->pMeta) { metaRent.sversion = pCache->pMeta->sversion; @@ -1396,49 +1333,51 @@ int32_t ctgUpdateRentStbVersion(SCatalog *pCtg, char* dbFName, char* tbName, uin if (pCache->pIndex) { metaRent.smaVer = pCache->pIndex->version; } - + strcpy(metaRent.dbFName, dbFName); strcpy(metaRent.stbName, tbName); - - CTG_ERR_RET(ctgMetaRentUpdate(&pCtg->stbRent, &metaRent, metaRent.suid, sizeof(SSTableVersion), ctgStbVersionSortCompare, ctgStbVersionSearchCompare)); - ctgDebug("db %s,0x%" PRIx64 " stb %s,0x%" PRIx64 " sver %d tver %d smaVer %d updated to stbRent", - dbFName, dbId, tbName, suid, metaRent.sversion, metaRent.tversion, metaRent.smaVer); + CTG_ERR_RET(ctgMetaRentUpdate(&pCtg->stbRent, &metaRent, metaRent.suid, sizeof(SSTableVersion), + ctgStbVersionSortCompare, ctgStbVersionSearchCompare)); - return TSDB_CODE_SUCCESS; + ctgDebug("db %s,0x%" PRIx64 " stb %s,0x%" PRIx64 " sver %d tver %d smaVer %d updated to stbRent", dbFName, dbId, + tbName, suid, metaRent.sversion, metaRent.tversion, metaRent.smaVer); + + return TSDB_CODE_SUCCESS; } - -int32_t ctgWriteTbMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFName, uint64_t dbId, char *tbName, STableMeta *meta, int32_t metaSize) { +int32_t ctgWriteTbMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFName, uint64_t dbId, char *tbName, + STableMeta *meta, int32_t metaSize) { if (NULL == dbCache->tbCache || NULL == dbCache->stbCache) { taosMemoryFree(meta); - ctgError("db is dropping, dbId:0x%"PRIx64, dbCache->dbId); + ctgError("db is dropping, dbId:0x%" PRIx64, dbCache->dbId); CTG_ERR_RET(TSDB_CODE_CTG_DB_DROPPED); } - bool isStb = meta->tableType == TSDB_SUPER_TABLE; - SCtgTbCache* pCache = taosHashGet(dbCache->tbCache, tbName, strlen(tbName)); - STableMeta *orig = (pCache ? pCache->pMeta : NULL); - int8_t origType = 0; - uint64_t origSuid = 0; - + bool isStb = meta->tableType == TSDB_SUPER_TABLE; + SCtgTbCache *pCache = taosHashGet(dbCache->tbCache, tbName, strlen(tbName)); + STableMeta *orig = (pCache ? pCache->pMeta : NULL); + int8_t origType = 0; + uint64_t origSuid = 0; + if (orig) { origType = orig->tableType; - if (origType == meta->tableType && orig->uid == meta->uid && (origType == TSDB_CHILD_TABLE || (orig->sversion >= meta->sversion && orig->tversion >= meta->tversion))) { + if (origType == meta->tableType && orig->uid == meta->uid && + (origType == TSDB_CHILD_TABLE || (orig->sversion >= meta->sversion && orig->tversion >= meta->tversion))) { taosMemoryFree(meta); ctgDebug("ignore table %s meta update", tbName); return TSDB_CODE_SUCCESS; } - + if (origType == TSDB_SUPER_TABLE) { if (taosHashRemove(dbCache->stbCache, &orig->suid, sizeof(orig->suid))) { - ctgError("stb not exist in stbCache, dbFName:%s, stb:%s, suid:0x%"PRIx64, dbFName, tbName, orig->suid); + ctgError("stb not exist in stbCache, dbFName:%s, stb:%s, suid:0x%" PRIx64, dbFName, tbName, orig->suid); } else { CTG_CACHE_STAT_DEC(numOfStb, 1); - ctgDebug("stb removed from stbCache, dbFName:%s, stb:%s, suid:0x%"PRIx64, dbFName, tbName, orig->suid); + ctgDebug("stb removed from stbCache, dbFName:%s, stb:%s, suid:0x%" PRIx64, dbFName, tbName, orig->suid); } - + origSuid = orig->suid; } } @@ -1451,7 +1390,7 @@ int32_t ctgWriteTbMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFNam ctgError("taosHashPut new tbCache failed, dbFName:%s, tbName:%s, tbType:%d", dbFName, tbName, meta->tableType); CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); } - + pCache = taosHashGet(dbCache->tbCache, tbName, strlen(tbName)); } else { taosMemoryFree(pCache->pMeta); @@ -1469,35 +1408,37 @@ int32_t ctgWriteTbMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFNam return TSDB_CODE_SUCCESS; } - if (origSuid != meta->suid && taosHashPut(dbCache->stbCache, &meta->suid, sizeof(meta->suid), tbName, strlen(tbName) + 1) != 0) { - ctgError("taosHashPut to stable cache failed, suid:0x%"PRIx64, meta->suid); + if (origSuid != meta->suid && + taosHashPut(dbCache->stbCache, &meta->suid, sizeof(meta->suid), tbName, strlen(tbName) + 1) != 0) { + ctgError("taosHashPut to stable cache failed, suid:0x%" PRIx64, meta->suid); CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); } CTG_CACHE_STAT_INC(numOfStb, 1); - ctgDebug("stb 0x%" PRIx64 " updated to cache, dbFName:%s, tbName:%s, tbType:%d", meta->suid, dbFName, tbName, meta->tableType); + ctgDebug("stb 0x%" PRIx64 " updated to cache, dbFName:%s, tbName:%s, tbType:%d", meta->suid, dbFName, tbName, + meta->tableType); CTG_ERR_RET(ctgUpdateRentStbVersion(pCtg, dbFName, tbName, dbId, meta->suid, pCache)); - + return TSDB_CODE_SUCCESS; } -int32_t ctgWriteTbIndexToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char* dbFName, char *tbName, STableIndex **index) { +int32_t ctgWriteTbIndexToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFName, char *tbName, STableIndex **index) { if (NULL == dbCache->tbCache) { ctgFreeSTableIndex(*index); taosMemoryFreeClear(*index); - ctgError("db is dropping, dbId:0x%"PRIx64, dbCache->dbId); + ctgError("db is dropping, dbId:0x%" PRIx64, dbCache->dbId); CTG_ERR_RET(TSDB_CODE_CTG_DB_DROPPED); } - STableIndex* pIndex = *index; - uint64_t suid = pIndex->suid; - SCtgTbCache* pCache = taosHashGet(dbCache->tbCache, tbName, strlen(tbName)); + STableIndex *pIndex = *index; + uint64_t suid = pIndex->suid; + SCtgTbCache *pCache = taosHashGet(dbCache->tbCache, tbName, strlen(tbName)); if (NULL == pCache) { SCtgTbCache cache = {0}; cache.pIndex = pIndex; - + if (taosHashPut(dbCache->tbCache, tbName, strlen(tbName), &cache, sizeof(cache)) != 0) { ctgFreeSTableIndex(*index); taosMemoryFreeClear(*index); @@ -1506,12 +1447,13 @@ int32_t ctgWriteTbIndexToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char* dbFNa } *index = NULL; - ctgDebug("table %s index updated to cache, ver:%d, num:%d", tbName, pIndex->version, (int32_t)taosArrayGetSize(pIndex->pIndex)); + ctgDebug("table %s index updated to cache, ver:%d, num:%d", tbName, pIndex->version, + (int32_t)taosArrayGetSize(pIndex->pIndex)); if (suid) { CTG_ERR_RET(ctgUpdateRentStbVersion(pCtg, dbFName, tbName, dbCache->dbId, pIndex->suid, &cache)); } - + return TSDB_CODE_SUCCESS; } @@ -1526,24 +1468,25 @@ int32_t ctgWriteTbIndexToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char* dbFNa pCache->pIndex = pIndex; *index = NULL; - ctgDebug("table %s index updated to cache, ver:%d, num:%d", tbName, pIndex->version, (int32_t)taosArrayGetSize(pIndex->pIndex)); + ctgDebug("table %s index updated to cache, ver:%d, num:%d", tbName, pIndex->version, + (int32_t)taosArrayGetSize(pIndex->pIndex)); if (suid) { CTG_ERR_RET(ctgUpdateRentStbVersion(pCtg, dbFName, tbName, dbCache->dbId, suid, pCache)); } - + return TSDB_CODE_SUCCESS; } -int32_t ctgUpdateTbMetaToCache(SCatalog* pCtg, STableMetaOutput* pOut, bool syncReq) { - STableMetaOutput* pOutput = NULL; - int32_t code = 0; - +int32_t ctgUpdateTbMetaToCache(SCatalog *pCtg, STableMetaOutput *pOut, bool syncReq) { + STableMetaOutput *pOutput = NULL; + int32_t code = 0; + CTG_ERR_RET(ctgCloneMetaOutput(pOut, &pOutput)); CTG_ERR_JRET(ctgUpdateTbMetaEnqueue(pCtg, pOutput, syncReq)); return TSDB_CODE_SUCCESS; - + _return: ctgFreeSTableMetaOutput(pOutput); @@ -1551,11 +1494,11 @@ _return: } void ctgClearAllInstance(void) { - SCatalog* pCtg = NULL; + SCatalog *pCtg = NULL; - void* pIter = taosHashIterate(gCtgMgmt.pCluster, NULL); + void *pIter = taosHashIterate(gCtgMgmt.pCluster, NULL); while (pIter) { - pCtg = *(SCatalog**)pIter; + pCtg = *(SCatalog **)pIter; if (pCtg) { ctgClearHandle(pCtg); @@ -1566,11 +1509,11 @@ void ctgClearAllInstance(void) { } void ctgFreeAllInstance(void) { - SCatalog* pCtg = NULL; + SCatalog *pCtg = NULL; - void* pIter = taosHashIterate(gCtgMgmt.pCluster, NULL); + void *pIter = taosHashIterate(gCtgMgmt.pCluster, NULL); while (pIter) { - pCtg = *(SCatalog**)pIter; + pCtg = *(SCatalog **)pIter; if (pCtg) { ctgFreeHandle(pCtg); @@ -1582,51 +1525,51 @@ void ctgFreeAllInstance(void) { taosHashClear(gCtgMgmt.pCluster); } - int32_t ctgOpUpdateVgroup(SCtgCacheOperation *operation) { - int32_t code = 0; + int32_t code = 0; SCtgUpdateVgMsg *msg = operation->data; - SDBVgInfo* dbInfo = msg->dbInfo; - char* dbFName = msg->dbFName; - SCatalog* pCtg = msg->pCtg; - + SDBVgInfo *dbInfo = msg->dbInfo; + char *dbFName = msg->dbFName; + SCatalog *pCtg = msg->pCtg; + if (NULL == dbInfo->vgHash) { goto _return; } - + if (dbInfo->vgVersion < 0 || taosHashGetSize(dbInfo->vgHash) <= 0) { - ctgError("invalid db vgInfo, dbFName:%s, vgHash:%p, vgVersion:%d, vgHashSize:%d", - dbFName, dbInfo->vgHash, dbInfo->vgVersion, taosHashGetSize(dbInfo->vgHash)); + ctgError("invalid db vgInfo, dbFName:%s, vgHash:%p, vgVersion:%d, vgHashSize:%d", dbFName, dbInfo->vgHash, + dbInfo->vgVersion, taosHashGetSize(dbInfo->vgHash)); CTG_ERR_JRET(TSDB_CODE_APP_ERROR); } - bool newAdded = false; + bool newAdded = false; SDbVgVersion vgVersion = {.dbId = msg->dbId, .vgVersion = dbInfo->vgVersion, .numOfTable = dbInfo->numOfTable}; SCtgDBCache *dbCache = NULL; CTG_ERR_JRET(ctgGetAddDBCache(msg->pCtg, dbFName, msg->dbId, &dbCache)); if (NULL == dbCache) { - ctgInfo("conflict db update, ignore this update, dbFName:%s, dbId:0x%"PRIx64, dbFName, msg->dbId); + ctgInfo("conflict db update, ignore this update, dbFName:%s, dbId:0x%" PRIx64, dbFName, msg->dbId); CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR); } SCtgVgCache *vgCache = &dbCache->vgCache; CTG_ERR_JRET(ctgWLockVgInfo(msg->pCtg, dbCache)); - + if (vgCache->vgInfo) { SDBVgInfo *vgInfo = vgCache->vgInfo; - + if (dbInfo->vgVersion < vgInfo->vgVersion) { ctgDebug("db vgVer is old, dbFName:%s, vgVer:%d, curVer:%d", dbFName, dbInfo->vgVersion, vgInfo->vgVersion); ctgWUnlockVgInfo(dbCache); - + goto _return; } if (dbInfo->vgVersion == vgInfo->vgVersion && dbInfo->numOfTable == vgInfo->numOfTable) { - ctgDebug("no new db vgVer or numOfTable, dbFName:%s, vgVer:%d, numOfTable:%d", dbFName, dbInfo->vgVersion, dbInfo->numOfTable); + ctgDebug("no new db vgVer or numOfTable, dbFName:%s, vgVer:%d, numOfTable:%d", dbFName, dbInfo->vgVersion, + dbInfo->numOfTable); ctgWUnlockVgInfo(dbCache); - + goto _return; } @@ -1636,61 +1579,63 @@ int32_t ctgOpUpdateVgroup(SCtgCacheOperation *operation) { vgCache->vgInfo = dbInfo; msg->dbInfo = NULL; - ctgDebug("db vgInfo updated, dbFName:%s, vgVer:%d, dbId:0x%"PRIx64, dbFName, vgVersion.vgVersion, vgVersion.dbId); + ctgDebug("db vgInfo updated, dbFName:%s, vgVer:%d, dbId:0x%" PRIx64, dbFName, vgVersion.vgVersion, vgVersion.dbId); ctgWUnlockVgInfo(dbCache); dbCache = NULL; strncpy(vgVersion.dbFName, dbFName, sizeof(vgVersion.dbFName)); - CTG_ERR_RET(ctgMetaRentUpdate(&msg->pCtg->dbRent, &vgVersion, vgVersion.dbId, sizeof(SDbVgVersion), ctgDbVgVersionSortCompare, ctgDbVgVersionSearchCompare)); + CTG_ERR_RET(ctgMetaRentUpdate(&msg->pCtg->dbRent, &vgVersion, vgVersion.dbId, sizeof(SDbVgVersion), + ctgDbVgVersionSortCompare, ctgDbVgVersionSearchCompare)); _return: ctgFreeVgInfo(msg->dbInfo); taosMemoryFreeClear(msg); - + CTG_RET(code); } int32_t ctgOpDropDbCache(SCtgCacheOperation *operation) { - int32_t code = 0; + int32_t code = 0; SCtgDropDBMsg *msg = operation->data; - SCatalog* pCtg = msg->pCtg; + SCatalog *pCtg = msg->pCtg; SCtgDBCache *dbCache = NULL; ctgGetDBCache(msg->pCtg, msg->dbFName, &dbCache); if (NULL == dbCache) { goto _return; } - + if (dbCache->dbId != msg->dbId) { - ctgInfo("dbId already updated, dbFName:%s, dbId:0x%"PRIx64 ", targetId:0x%"PRIx64, msg->dbFName, dbCache->dbId, msg->dbId); + ctgInfo("dbId already updated, dbFName:%s, dbId:0x%" PRIx64 ", targetId:0x%" PRIx64, msg->dbFName, dbCache->dbId, + msg->dbId); goto _return; } - + CTG_ERR_JRET(ctgRemoveDBFromCache(pCtg, dbCache, msg->dbFName)); _return: taosMemoryFreeClear(msg); - + CTG_RET(code); } int32_t ctgOpDropDbVgroup(SCtgCacheOperation *operation) { - int32_t code = 0; + int32_t code = 0; SCtgDropDbVgroupMsg *msg = operation->data; - SCatalog* pCtg = msg->pCtg; + SCatalog *pCtg = msg->pCtg; SCtgDBCache *dbCache = NULL; ctgGetDBCache(msg->pCtg, msg->dbFName, &dbCache); if (NULL == dbCache) { goto _return; } - + CTG_ERR_RET(ctgWLockVgInfo(pCtg, dbCache)); - + ctgFreeVgInfo(dbCache->vgCache.vgInfo); dbCache->vgCache.vgInfo = NULL; @@ -1701,17 +1646,16 @@ int32_t ctgOpDropDbVgroup(SCtgCacheOperation *operation) { _return: taosMemoryFreeClear(msg); - + CTG_RET(code); } - int32_t ctgOpUpdateTbMeta(SCtgCacheOperation *operation) { - int32_t code = 0; + int32_t code = 0; SCtgUpdateTbMetaMsg *msg = operation->data; - SCatalog* pCtg = msg->pCtg; - STableMetaOutput* pMeta = msg->pMeta; - SCtgDBCache *dbCache = NULL; + SCatalog *pCtg = msg->pCtg; + STableMetaOutput *pMeta = msg->pMeta; + SCtgDBCache *dbCache = NULL; if ((!CTG_IS_META_CTABLE(pMeta->metaType)) && NULL == pMeta->tbMeta) { ctgError("no valid tbmeta got from meta rsp, dbFName:%s, tbName:%s", pMeta->dbFName, pMeta->tbName); @@ -1721,8 +1665,8 @@ int32_t ctgOpUpdateTbMeta(SCtgCacheOperation *operation) { if (CTG_IS_META_BOTH(pMeta->metaType) && TSDB_SUPER_TABLE != pMeta->tbMeta->tableType) { ctgError("table type error, expected:%d, actual:%d", TSDB_SUPER_TABLE, pMeta->tbMeta->tableType); CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR); - } - + } + CTG_ERR_JRET(ctgGetAddDBCache(pCtg, pMeta->dbFName, pMeta->dbId, &dbCache)); if (NULL == dbCache) { ctgInfo("conflict db update, ignore this update, dbFName:%s, dbId:0x%" PRIx64, pMeta->dbFName, pMeta->dbId); @@ -1731,17 +1675,19 @@ int32_t ctgOpUpdateTbMeta(SCtgCacheOperation *operation) { if (CTG_IS_META_TABLE(pMeta->metaType) || CTG_IS_META_BOTH(pMeta->metaType)) { int32_t metaSize = CTG_META_SIZE(pMeta->tbMeta); - CTG_ERR_JRET(ctgWriteTbMetaToCache(pCtg, dbCache, pMeta->dbFName, pMeta->dbId, pMeta->tbName, pMeta->tbMeta, metaSize)); + CTG_ERR_JRET( + ctgWriteTbMetaToCache(pCtg, dbCache, pMeta->dbFName, pMeta->dbId, pMeta->tbName, pMeta->tbMeta, metaSize)); pMeta->tbMeta = NULL; } if (CTG_IS_META_CTABLE(pMeta->metaType) || CTG_IS_META_BOTH(pMeta->metaType)) { - SCTableMeta* ctbMeta = taosMemoryMalloc(sizeof(SCTableMeta)); + SCTableMeta *ctbMeta = taosMemoryMalloc(sizeof(SCTableMeta)); if (NULL == ctbMeta) { CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); } memcpy(ctbMeta, &pMeta->ctbMeta, sizeof(SCTableMeta)); - CTG_ERR_JRET(ctgWriteTbMetaToCache(pCtg, dbCache, pMeta->dbFName, pMeta->dbId, pMeta->ctbName, (STableMeta *)ctbMeta, sizeof(SCTableMeta))); + CTG_ERR_JRET(ctgWriteTbMetaToCache(pCtg, dbCache, pMeta->dbFName, pMeta->dbId, pMeta->ctbName, + (STableMeta *)ctbMeta, sizeof(SCTableMeta))); } _return: @@ -1750,17 +1696,16 @@ _return: taosMemoryFreeClear(pMeta->tbMeta); taosMemoryFreeClear(pMeta); } - + taosMemoryFreeClear(msg); - + CTG_RET(code); } - int32_t ctgOpDropStbMeta(SCtgCacheOperation *operation) { - int32_t code = 0; + int32_t code = 0; SCtgDropStbMetaMsg *msg = operation->data; - SCatalog* pCtg = msg->pCtg; + SCatalog *pCtg = msg->pCtg; SCtgDBCache *dbCache = NULL; ctgGetDBCache(pCtg, msg->dbFName, &dbCache); @@ -1769,18 +1714,19 @@ int32_t ctgOpDropStbMeta(SCtgCacheOperation *operation) { } if (msg->dbId && (dbCache->dbId != msg->dbId)) { - ctgDebug("dbId already modified, dbFName:%s, current:0x%"PRIx64", dbId:0x%"PRIx64", stb:%s, suid:0x%"PRIx64, + ctgDebug("dbId already modified, dbFName:%s, current:0x%" PRIx64 ", dbId:0x%" PRIx64 ", stb:%s, suid:0x%" PRIx64, msg->dbFName, dbCache->dbId, msg->dbId, msg->stbName, msg->suid); return TSDB_CODE_SUCCESS; } - + if (taosHashRemove(dbCache->stbCache, &msg->suid, sizeof(msg->suid))) { - ctgDebug("stb not exist in stbCache, may be removed, dbFName:%s, stb:%s, suid:0x%"PRIx64, msg->dbFName, msg->stbName, msg->suid); + ctgDebug("stb not exist in stbCache, may be removed, dbFName:%s, stb:%s, suid:0x%" PRIx64, msg->dbFName, + msg->stbName, msg->suid); } else { CTG_CACHE_STAT_DEC(numOfStb, 1); } - SCtgTbCache* pTbCache = taosHashGet(dbCache->tbCache, msg->stbName, strlen(msg->stbName)); + SCtgTbCache *pTbCache = taosHashGet(dbCache->tbCache, msg->stbName, strlen(msg->stbName)); if (NULL == pTbCache) { ctgDebug("stb %s already not in cache", msg->stbName); goto _return; @@ -1790,29 +1736,29 @@ int32_t ctgOpDropStbMeta(SCtgCacheOperation *operation) { ctgFreeTbCacheImpl(pTbCache); CTG_UNLOCK(CTG_WRITE, &pTbCache->metaLock); - if (taosHashRemove(dbCache->tbCache, msg->stbName, strlen(msg->stbName))) { - ctgError("stb not exist in cache, dbFName:%s, stb:%s, suid:0x%"PRIx64, msg->dbFName, msg->stbName, msg->suid); + if (taosHashRemove(dbCache->tbCache, msg->stbName, strlen(msg->stbName))) { + ctgError("stb not exist in cache, dbFName:%s, stb:%s, suid:0x%" PRIx64, msg->dbFName, msg->stbName, msg->suid); } else { CTG_CACHE_STAT_DEC(numOfTbl, 1); } - - ctgInfo("stb removed from cache, dbFName:%s, stbName:%s, suid:0x%"PRIx64, msg->dbFName, msg->stbName, msg->suid); + + ctgInfo("stb removed from cache, dbFName:%s, stbName:%s, suid:0x%" PRIx64, msg->dbFName, msg->stbName, msg->suid); CTG_ERR_JRET(ctgMetaRentRemove(&msg->pCtg->stbRent, msg->suid, ctgStbVersionSortCompare, ctgStbVersionSearchCompare)); - - ctgDebug("stb removed from rent, dbFName:%s, stbName:%s, suid:0x%"PRIx64, msg->dbFName, msg->stbName, msg->suid); - + + ctgDebug("stb removed from rent, dbFName:%s, stbName:%s, suid:0x%" PRIx64, msg->dbFName, msg->stbName, msg->suid); + _return: taosMemoryFreeClear(msg); - + CTG_RET(code); } int32_t ctgOpDropTbMeta(SCtgCacheOperation *operation) { - int32_t code = 0; + int32_t code = 0; SCtgDropTblMetaMsg *msg = operation->data; - SCatalog* pCtg = msg->pCtg; + SCatalog *pCtg = msg->pCtg; SCtgDBCache *dbCache = NULL; ctgGetDBCache(pCtg, msg->dbFName, &dbCache); @@ -1821,11 +1767,12 @@ int32_t ctgOpDropTbMeta(SCtgCacheOperation *operation) { } if (dbCache->dbId != msg->dbId) { - ctgDebug("dbId 0x%" PRIx64 " not match with curId 0x%"PRIx64", dbFName:%s, tbName:%s", msg->dbId, dbCache->dbId, msg->dbFName, msg->tbName); + ctgDebug("dbId 0x%" PRIx64 " not match with curId 0x%" PRIx64 ", dbFName:%s, tbName:%s", msg->dbId, dbCache->dbId, + msg->dbFName, msg->tbName); goto _return; } - SCtgTbCache* pTbCache = taosHashGet(dbCache->tbCache, msg->tbName, strlen(msg->tbName)); + SCtgTbCache *pTbCache = taosHashGet(dbCache->tbCache, msg->tbName, strlen(msg->tbName)); if (NULL == pTbCache) { ctgDebug("tb %s already not in cache", msg->tbName); goto _return; @@ -1834,7 +1781,7 @@ int32_t ctgOpDropTbMeta(SCtgCacheOperation *operation) { CTG_LOCK(CTG_WRITE, &pTbCache->metaLock); ctgFreeTbCacheImpl(pTbCache); CTG_UNLOCK(CTG_WRITE, &pTbCache->metaLock); - + if (taosHashRemove(dbCache->tbCache, msg->tbName, strlen(msg->tbName))) { ctgError("tb %s not exist in cache, dbFName:%s", msg->tbName, msg->dbFName); CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR); @@ -1852,10 +1799,10 @@ _return: } int32_t ctgOpUpdateUser(SCtgCacheOperation *operation) { - int32_t code = 0; + int32_t code = 0; SCtgUpdateUserMsg *msg = operation->data; - SCatalog* pCtg = msg->pCtg; - + SCatalog *pCtg = msg->pCtg; + SCtgUserAuth *pUser = (SCtgUserAuth *)taosHashGet(pCtg->userCache, msg->userAuth.user, strlen(msg->userAuth.user)); if (NULL == pUser) { SCtgUserAuth userAuth = {0}; @@ -1899,17 +1846,17 @@ _return: taosHashCleanup(msg->userAuth.createdDbs); taosHashCleanup(msg->userAuth.readDbs); taosHashCleanup(msg->userAuth.writeDbs); - + taosMemoryFreeClear(msg); - + CTG_RET(code); } int32_t ctgOpUpdateEpset(SCtgCacheOperation *operation) { - int32_t code = 0; + int32_t code = 0; SCtgUpdateEpsetMsg *msg = operation->data; - SCatalog* pCtg = msg->pCtg; - + SCatalog *pCtg = msg->pCtg; + SCtgDBCache *dbCache = NULL; CTG_ERR_JRET(ctgGetDBCache(pCtg, msg->dbFName, &dbCache)); if (NULL == dbCache) { @@ -1919,23 +1866,23 @@ int32_t ctgOpUpdateEpset(SCtgCacheOperation *operation) { CTG_ERR_JRET(ctgWLockVgInfo(pCtg, dbCache)); - SDBVgInfo *vgInfo = dbCache->vgCache.vgInfo; + SDBVgInfo *vgInfo = dbCache->vgCache.vgInfo; if (NULL == vgInfo) { ctgDebug("vgroup in db %s not cached, ignore epset update", msg->dbFName); goto _return; } - - SVgroupInfo* pInfo = taosHashGet(vgInfo->vgHash, &msg->vgId, sizeof(msg->vgId)); + + SVgroupInfo *pInfo = taosHashGet(vgInfo->vgHash, &msg->vgId, sizeof(msg->vgId)); if (NULL == pInfo) { ctgDebug("no vgroup %d in db %s, ignore epset update", msg->vgId, msg->dbFName); goto _return; } - SEp* pOrigEp = &pInfo->epSet.eps[pInfo->epSet.inUse]; - SEp* pNewEp = &msg->epSet.eps[msg->epSet.inUse]; - ctgDebug("vgroup %d epset updated from %d/%d=>%s:%d to %d/%d=>%s:%d, dbFName:%s in ctg", - pInfo->vgId, pInfo->epSet.inUse, pInfo->epSet.numOfEps, pOrigEp->fqdn, pOrigEp->port, - msg->epSet.inUse, msg->epSet.numOfEps, pNewEp->fqdn, pNewEp->port, msg->dbFName); + SEp *pOrigEp = &pInfo->epSet.eps[pInfo->epSet.inUse]; + SEp *pNewEp = &msg->epSet.eps[msg->epSet.inUse]; + ctgDebug("vgroup %d epset updated from %d/%d=>%s:%d to %d/%d=>%s:%d, dbFName:%s in ctg", pInfo->vgId, + pInfo->epSet.inUse, pInfo->epSet.numOfEps, pOrigEp->fqdn, pOrigEp->port, msg->epSet.inUse, + msg->epSet.numOfEps, pNewEp->fqdn, pNewEp->port, msg->dbFName); pInfo->epSet = msg->epSet; @@ -1946,17 +1893,17 @@ _return: } taosMemoryFreeClear(msg); - + CTG_RET(code); } int32_t ctgOpUpdateTbIndex(SCtgCacheOperation *operation) { - int32_t code = 0; + int32_t code = 0; SCtgUpdateTbIndexMsg *msg = operation->data; - SCatalog* pCtg = msg->pCtg; - STableIndex* pIndex = msg->pIndex; - SCtgDBCache *dbCache = NULL; - + SCatalog *pCtg = msg->pCtg; + STableIndex *pIndex = msg->pIndex; + SCtgDBCache *dbCache = NULL; + CTG_ERR_JRET(ctgGetAddDBCache(pCtg, pIndex->dbFName, 0, &dbCache)); CTG_ERR_JRET(ctgWriteTbIndexToCache(pCtg, dbCache, pIndex->dbFName, pIndex->tbName, &pIndex)); @@ -1967,24 +1914,24 @@ _return: taosArrayDestroyEx(pIndex->pIndex, tFreeSTableIndexInfo); taosMemoryFreeClear(pIndex); } - + taosMemoryFreeClear(msg); - + CTG_RET(code); } int32_t ctgOpDropTbIndex(SCtgCacheOperation *operation) { - int32_t code = 0; + int32_t code = 0; SCtgDropTbIndexMsg *msg = operation->data; - SCatalog* pCtg = msg->pCtg; - SCtgDBCache *dbCache = NULL; - + SCatalog *pCtg = msg->pCtg; + SCtgDBCache *dbCache = NULL; + CTG_ERR_JRET(ctgGetDBCache(pCtg, msg->dbFName, &dbCache)); if (NULL == dbCache) { return TSDB_CODE_SUCCESS; } - STableIndex* pIndex = taosMemoryCalloc(1, sizeof(STableIndex)); + STableIndex *pIndex = taosMemoryCalloc(1, sizeof(STableIndex)); if (NULL == pIndex) { CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); } @@ -2000,17 +1947,16 @@ _return: taosArrayDestroyEx(pIndex->pIndex, tFreeSTableIndexInfo); taosMemoryFreeClear(pIndex); } - + taosMemoryFreeClear(msg); - + CTG_RET(code); } - int32_t ctgOpClearCache(SCtgCacheOperation *operation) { - int32_t code = 0; + int32_t code = 0; SCtgClearCacheMsg *msg = operation->data; - SCatalog* pCtg = msg->pCtg; + SCatalog *pCtg = msg->pCtg; CTG_LOCK(CTG_WRITE, &gCtgMgmt.lock); @@ -2020,7 +1966,7 @@ int32_t ctgOpClearCache(SCtgCacheOperation *operation) { } else { ctgClearHandle(pCtg); } - + goto _return; } @@ -2033,17 +1979,17 @@ int32_t ctgOpClearCache(SCtgCacheOperation *operation) { _return: CTG_UNLOCK(CTG_WRITE, &gCtgMgmt.lock); - + taosMemoryFreeClear(msg); - + CTG_RET(code); } void ctgCleanupCacheQueue(void) { - SCtgQNode *node = NULL; - SCtgQNode *nodeNext = NULL; + SCtgQNode *node = NULL; + SCtgQNode *nodeNext = NULL; SCtgCacheOperation *op = NULL; - bool stopQueue = false; + bool stopQueue = false; while (true) { node = gCtgMgmt.queue.head->next; @@ -2055,12 +2001,13 @@ void ctgCleanupCacheQueue(void) { ctgDebug("process [%s] operation", gCtgCacheOperation[op->opId].name); (*gCtgCacheOperation[op->opId].func)(op); stopQueue = true; - CTG_RT_STAT_INC(numOfOpDequeue, 1); + taosMemoryFree(op->data); + CTG_RT_STAT_INC(numOfOpDequeue, 1); } else { taosMemoryFree(op->data); - CTG_RT_STAT_INC(numOfOpAbort, 1); + CTG_RT_STAT_INC(numOfOpAbort, 1); } - + if (op->syncOp) { tsem_post(&op->rspSem); } else { @@ -2070,7 +2017,7 @@ void ctgCleanupCacheQueue(void) { nodeNext = node->next; taosMemoryFree(node); - + node = nodeNext; } @@ -2085,7 +2032,7 @@ void ctgCleanupCacheQueue(void) { gCtgMgmt.queue.tail = NULL; } -void* ctgUpdateThreadFunc(void* param) { +void *ctgUpdateThreadFunc(void *param) { setThreadName("catalog"); qInfo("catalog update thread started"); @@ -2094,8 +2041,8 @@ void* ctgUpdateThreadFunc(void* param) { if (tsem_wait(&gCtgMgmt.queue.reqSem)) { qError("ctg tsem_wait failed, error:%s", tstrerror(TAOS_SYSTEM_ERROR(errno))); } - - if (atomic_load_8((int8_t*)&gCtgMgmt.exit)) { + + if (atomic_load_8((int8_t *)&gCtgMgmt.exit)) { ctgCleanupCacheQueue(); break; } @@ -2105,7 +2052,7 @@ void* ctgUpdateThreadFunc(void* param) { SCatalog *pCtg = ((SCtgUpdateMsgHeader *)operation->data)->pCtg; ctgDebug("process [%s] operation", gCtgCacheOperation[operation->opId].name); - + (*gCtgCacheOperation[operation->opId].func)(operation); if (operation->syncOp) { @@ -2114,18 +2061,17 @@ void* ctgUpdateThreadFunc(void* param) { taosMemoryFreeClear(operation); } - CTG_RT_STAT_INC(numOfOpDequeue, 1); + CTG_RT_STAT_INC(numOfOpDequeue, 1); ctgdShowCacheInfo(); ctgdShowClusterCache(pCtg); } qInfo("catalog update thread stopped"); - + return NULL; } - int32_t ctgStartUpdateThread() { TdThreadAttr thAttr; taosThreadAttrInit(&thAttr); @@ -2135,13 +2081,12 @@ int32_t ctgStartUpdateThread() { terrno = TAOS_SYSTEM_ERROR(errno); CTG_ERR_RET(terrno); } - + taosThreadAttrDestroy(&thAttr); return TSDB_CODE_SUCCESS; } - -int32_t ctgGetTbMetaFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMetaCtx* ctx, STableMeta** pTableMeta) { +int32_t ctgGetTbMetaFromCache(SCatalog *pCtg, SRequestConnInfo *pConn, SCtgTbMetaCtx *ctx, STableMeta **pTableMeta) { if (IS_SYS_DBNAME(ctx->pName->dbname)) { CTG_FLAG_SET_SYS_DB(ctx->flag); } @@ -2221,14 +2166,15 @@ int32_t ctgGetTbMetaBFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMe } #endif -int32_t ctgGetTbMetasFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMetasCtx* ctx, int32_t dbIdx, int32_t *fetchIdx, int32_t baseResIdx, SArray* pList) { - int32_t tbNum = taosArrayGetSize(pList); - SName* pName = taosArrayGet(pList, 0); - char dbFName[TSDB_DB_FNAME_LEN] = {0}; - int32_t flag = CTG_FLAG_UNKNOWN_STB; - uint64_t lastSuid = 0; - STableMeta* lastTableMeta = NULL; - +int32_t ctgGetTbMetasFromCache(SCatalog *pCtg, SRequestConnInfo *pConn, SCtgTbMetasCtx *ctx, int32_t dbIdx, + int32_t *fetchIdx, int32_t baseResIdx, SArray *pList) { + int32_t tbNum = taosArrayGetSize(pList); + SName *pName = taosArrayGet(pList, 0); + char dbFName[TSDB_DB_FNAME_LEN] = {0}; + int32_t flag = CTG_FLAG_UNKNOWN_STB; + uint64_t lastSuid = 0; + STableMeta *lastTableMeta = NULL; + if (IS_SYS_DBNAME(pName->dbname)) { CTG_FLAG_SET_SYS_DB(flag); strcpy(dbFName, pName->dbname); @@ -2237,9 +2183,9 @@ int32_t ctgGetTbMetasFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMe } SCtgDBCache *dbCache = NULL; - SCtgTbCache* pCache = NULL; + SCtgTbCache *pCache = NULL; ctgAcquireDBCache(pCtg, dbFName, &dbCache); - + if (NULL == dbCache) { ctgDebug("db %s not in cache", dbFName); for (int32_t i = 0; i < tbNum; ++i) { @@ -2251,14 +2197,14 @@ int32_t ctgGetTbMetasFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMe } for (int32_t i = 0; i < tbNum; ++i) { - SName* pName = taosArrayGet(pList, i); + SName *pName = taosArrayGet(pList, i); pCache = taosHashAcquire(dbCache->tbCache, pName->tname, strlen(pName->tname)); if (NULL == pCache) { ctgDebug("tb %s not in cache, dbFName:%s", pName->tname, dbFName); ctgAddFetch(&ctx->pFetchs, dbIdx, i, fetchIdx, baseResIdx + i, flag); taosArraySetSize(ctx->pResList, taosArrayGetSize(ctx->pResList) + 1); - + continue; } @@ -2267,11 +2213,11 @@ int32_t ctgGetTbMetasFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMe ctgDebug("tb %s meta not in cache, dbFName:%s", pName->tname, dbFName); ctgAddFetch(&ctx->pFetchs, dbIdx, i, fetchIdx, baseResIdx + i, flag); taosArraySetSize(ctx->pResList, taosArrayGetSize(ctx->pResList) + 1); - + continue; } - STableMeta* tbMeta = pCache->pMeta; + STableMeta *tbMeta = pCache->pMeta; SCtgTbMetaCtx nctx = {0}; nctx.flag = flag; @@ -2280,8 +2226,8 @@ int32_t ctgGetTbMetasFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMe nctx.tbInfo.suid = tbMeta->suid; nctx.tbInfo.tbType = tbMeta->tableType; - SMetaRes res = {0}; - STableMeta* pTableMeta = NULL; + SMetaRes res = {0}; + STableMeta *pTableMeta = NULL; if (tbMeta->tableType != TSDB_CHILD_TABLE) { int32_t metaSize = CTG_META_SIZE(tbMeta); pTableMeta = taosMemoryCalloc(1, metaSize); @@ -2289,20 +2235,20 @@ int32_t ctgGetTbMetasFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMe ctgReleaseTbMetaToCache(pCtg, dbCache, pCache); CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); } - + memcpy(pTableMeta, tbMeta, metaSize); - + CTG_UNLOCK(CTG_READ, &pCache->metaLock); - taosHashRelease(dbCache->tbCache, pCache); - + taosHashRelease(dbCache->tbCache, pCache); + ctgDebug("Got tb %s meta from cache, type:%d, dbFName:%s", pName->tname, tbMeta->tableType, dbFName); - + res.pRes = pTableMeta; taosArrayPush(ctx->pResList, &res); continue; } - + // PROCESS FOR CHILD TABLE if (lastSuid && tbMeta->suid == lastSuid && lastTableMeta) { @@ -2310,32 +2256,32 @@ int32_t ctgGetTbMetasFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMe memcpy(pTableMeta, tbMeta, sizeof(SCTableMeta)); CTG_UNLOCK(CTG_READ, &pCache->metaLock); - taosHashRelease(dbCache->tbCache, pCache); - + taosHashRelease(dbCache->tbCache, pCache); + ctgDebug("Got tb %s meta from cache, type:%d, dbFName:%s", pName->tname, tbMeta->tableType, dbFName); - + res.pRes = pTableMeta; taosArrayPush(ctx->pResList, &res); - + continue; } - + int32_t metaSize = sizeof(SCTableMeta); pTableMeta = taosMemoryCalloc(1, metaSize); if (NULL == pTableMeta) { - ctgReleaseTbMetaToCache(pCtg, dbCache, pCache); + ctgReleaseTbMetaToCache(pCtg, dbCache, pCache); CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); } - + memcpy(pTableMeta, tbMeta, metaSize); - + CTG_UNLOCK(CTG_READ, &pCache->metaLock); - taosHashRelease(dbCache->tbCache, pCache); - - ctgDebug("Got ctb %s meta from cache, will continue to get its stb meta, type:%d, dbFName:%s", - pName->tname, nctx.tbInfo.tbType, dbFName); - - char* stName = taosHashAcquire(dbCache->stbCache, &pTableMeta->suid, sizeof(pTableMeta->suid)); + taosHashRelease(dbCache->tbCache, pCache); + + ctgDebug("Got ctb %s meta from cache, will continue to get its stb meta, type:%d, dbFName:%s", pName->tname, + nctx.tbInfo.tbType, dbFName); + + char *stName = taosHashAcquire(dbCache->stbCache, &pTableMeta->suid, sizeof(pTableMeta->suid)); if (NULL == stName) { ctgDebug("stb 0x%" PRIx64 " not in cache, dbFName:%s", pTableMeta->suid, dbFName); ctgAddFetch(&ctx->pFetchs, dbIdx, i, fetchIdx, baseResIdx + i, flag); @@ -2349,11 +2295,11 @@ int32_t ctgGetTbMetasFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMe if (NULL == pCache) { ctgDebug("stb 0x%" PRIx64 " name %s not in cache, dbFName:%s", pTableMeta->suid, stName, dbFName); taosHashRelease(dbCache->stbCache, stName); - + ctgAddFetch(&ctx->pFetchs, dbIdx, i, fetchIdx, baseResIdx + i, flag); taosArraySetSize(ctx->pResList, taosArrayGetSize(ctx->pResList) + 1); - taosMemoryFreeClear(pTableMeta); + taosMemoryFreeClear(pTableMeta); continue; } @@ -2363,8 +2309,8 @@ int32_t ctgGetTbMetasFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMe if (NULL == pCache->pMeta) { ctgDebug("stb 0x%" PRIx64 " meta not in cache, dbFName:%s", pTableMeta->suid, dbFName); CTG_UNLOCK(CTG_READ, &pCache->metaLock); - taosHashRelease(dbCache->tbCache, pCache); - + taosHashRelease(dbCache->tbCache, pCache); + ctgAddFetch(&ctx->pFetchs, dbIdx, i, fetchIdx, baseResIdx + i, flag); taosArraySetSize(ctx->pResList, taosArrayGetSize(ctx->pResList) + 1); @@ -2372,14 +2318,15 @@ int32_t ctgGetTbMetasFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMe continue; } - - STableMeta* stbMeta = pCache->pMeta; - if (stbMeta->suid != nctx.tbInfo.suid) { + + STableMeta *stbMeta = pCache->pMeta; + if (stbMeta->suid != nctx.tbInfo.suid) { CTG_UNLOCK(CTG_READ, &pCache->metaLock); - taosHashRelease(dbCache->tbCache, pCache); - - ctgError("stb suid 0x%" PRIx64 " in stbCache mis-match, expected suid 0x%"PRIx64 , stbMeta->suid, nctx.tbInfo.suid); - + taosHashRelease(dbCache->tbCache, pCache); + + ctgError("stb suid 0x%" PRIx64 " in stbCache mis-match, expected suid 0x%" PRIx64, stbMeta->suid, + nctx.tbInfo.suid); + ctgAddFetch(&ctx->pFetchs, dbIdx, i, fetchIdx, baseResIdx + i, flag); taosArraySetSize(ctx->pResList, taosArrayGetSize(ctx->pResList) + 1); @@ -2387,19 +2334,19 @@ int32_t ctgGetTbMetasFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMe continue; } - + metaSize = CTG_META_SIZE(stbMeta); pTableMeta = taosMemoryRealloc(pTableMeta, metaSize); - if (NULL == pTableMeta) { + if (NULL == pTableMeta) { ctgReleaseTbMetaToCache(pCtg, dbCache, pCache); CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); } - + memcpy(&pTableMeta->sversion, &stbMeta->sversion, metaSize - sizeof(SCTableMeta)); - + CTG_UNLOCK(CTG_READ, &pCache->metaLock); - taosHashRelease(dbCache->tbCache, pCache); - + taosHashRelease(dbCache->tbCache, pCache); + res.pRes = pTableMeta; taosArrayPush(ctx->pResList, &res); @@ -2408,14 +2355,13 @@ int32_t ctgGetTbMetasFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMe } ctgReleaseDBCache(pCtg, dbCache); - + return TSDB_CODE_SUCCESS; } - -int32_t ctgRemoveTbMetaFromCache(SCatalog* pCtg, SName* pTableName, bool syncReq) { +int32_t ctgRemoveTbMetaFromCache(SCatalog *pCtg, SName *pTableName, bool syncReq) { int32_t code = 0; - STableMeta* tblMeta = NULL; + STableMeta *tblMeta = NULL; SCtgTbMetaCtx tbCtx = {0}; tbCtx.flag = CTG_FLAG_UNKNOWN_STB; tbCtx.pName = pTableName; @@ -2449,7 +2395,7 @@ int32_t ctgGetTbHashVgroupFromCache(SCatalog *pCtg, const SName *pTableName, SVg CTG_ERR_RET(TSDB_CODE_CTG_INVALID_INPUT); } - SCtgDBCache* dbCache = NULL; + SCtgDBCache *dbCache = NULL; int32_t code = 0; char dbFName[TSDB_DB_FNAME_LEN] = {0}; tNameGetFullDbName(pTableName, dbFName); @@ -2476,5 +2422,3 @@ _return: CTG_RET(code); } - - From f32a17580cc7e6a39c4f765f43a6de9b86ed5bd4 Mon Sep 17 00:00:00 2001 From: Xiaoyu Wang Date: Tue, 13 Sep 2022 13:31:35 +0800 Subject: [PATCH 013/138] enh: add binary serialization method to node structure --- source/libs/nodes/src/nodesMsgFuncs.c | 28 +++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/source/libs/nodes/src/nodesMsgFuncs.c b/source/libs/nodes/src/nodesMsgFuncs.c index b0be001e56..af32913f47 100644 --- a/source/libs/nodes/src/nodesMsgFuncs.c +++ b/source/libs/nodes/src/nodesMsgFuncs.c @@ -367,6 +367,10 @@ enum { COLUMN_CODE_TABLE_TYPE, COLUMN_CODE_COLUMN_ID, COLUMN_CODE_COLUMN_TYPE, + COLUMN_CODE_DB_NAME, + COLUMN_CODE_TABLE_NAME, + COLUMN_CODE_TABLE_ALIAS, + COLUMN_CODE_COL_NAME, COLUMN_CODE_DATABLOCK_ID, COLUMN_CODE_SLOT_ID }; @@ -387,6 +391,18 @@ static int32_t columnNodeToMsg(const void* pObj, STlvEncoder* pEncoder) { if (TSDB_CODE_SUCCESS == code) { code = tlvEncodeEnum(pEncoder, COLUMN_CODE_COLUMN_TYPE, pNode->colType); } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeCStr(pEncoder, COLUMN_CODE_DB_NAME, pNode->dbName); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeCStr(pEncoder, COLUMN_CODE_TABLE_NAME, pNode->tableName); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeCStr(pEncoder, COLUMN_CODE_TABLE_ALIAS, pNode->tableAlias); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeCStr(pEncoder, COLUMN_CODE_COL_NAME, pNode->colName); + } if (TSDB_CODE_SUCCESS == code) { code = tlvEncodeI16(pEncoder, COLUMN_CODE_DATABLOCK_ID, pNode->dataBlockId); } @@ -419,6 +435,18 @@ static int32_t msgToColumnNode(STlvDecoder* pDecoder, void* pObj) { case COLUMN_CODE_COLUMN_TYPE: code = tlvDecodeEnum(pTlv, &pNode->colType, sizeof(pNode->colType)); break; + case COLUMN_CODE_DB_NAME: + code = tlvDecodeCStr(pTlv, pNode->dbName); + break; + case COLUMN_CODE_TABLE_NAME: + code = tlvDecodeCStr(pTlv, pNode->tableName); + break; + case COLUMN_CODE_TABLE_ALIAS: + code = tlvDecodeCStr(pTlv, pNode->tableAlias); + break; + case COLUMN_CODE_COL_NAME: + code = tlvDecodeCStr(pTlv, pNode->colName); + break; case COLUMN_CODE_DATABLOCK_ID: code = tlvDecodeI16(pTlv, &pNode->dataBlockId); break; From 25fdef454020ca802bb2832192c8471c7be05645 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Tue, 13 Sep 2022 13:35:14 +0800 Subject: [PATCH 014/138] fix: alter table memory leakage --- source/dnode/vnode/src/meta/metaTable.c | 1 + 1 file changed, 1 insertion(+) diff --git a/source/dnode/vnode/src/meta/metaTable.c b/source/dnode/vnode/src/meta/metaTable.c index 92cf90d328..3467c3f078 100644 --- a/source/dnode/vnode/src/meta/metaTable.c +++ b/source/dnode/vnode/src/meta/metaTable.c @@ -244,6 +244,7 @@ int metaDropSTable(SMeta *pMeta, int64_t verison, SVDropStbReq *pReq, SArray *tb // check if super table exists rc = tdbTbGet(pMeta->pNameIdx, pReq->name, strlen(pReq->name) + 1, &pData, &nData); if (rc < 0 || *(tb_uid_t *)pData != pReq->suid) { + tdbFree(pData); terrno = TSDB_CODE_TDB_STB_NOT_EXIST; return -1; } From f72668def8d3cebab9ad8bb247cda73dcf82336a Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Tue, 13 Sep 2022 14:09:17 +0800 Subject: [PATCH 015/138] fix: fix mem leak --- source/libs/catalog/src/ctgCache.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/source/libs/catalog/src/ctgCache.c b/source/libs/catalog/src/ctgCache.c index ee0577523d..aa7db9c43e 100644 --- a/source/libs/catalog/src/ctgCache.c +++ b/source/libs/catalog/src/ctgCache.c @@ -1586,8 +1586,8 @@ int32_t ctgOpUpdateVgroup(SCtgCacheOperation *operation) { dbCache = NULL; strncpy(vgVersion.dbFName, dbFName, sizeof(vgVersion.dbFName)); - CTG_ERR_RET(ctgMetaRentUpdate(&msg->pCtg->dbRent, &vgVersion, vgVersion.dbId, sizeof(SDbVgVersion), - ctgDbVgVersionSortCompare, ctgDbVgVersionSearchCompare)); + CTG_ERR_JRET(ctgMetaRentUpdate(&msg->pCtg->dbRent, &vgVersion, vgVersion.dbId, sizeof(SDbVgVersion), + ctgDbVgVersionSortCompare, ctgDbVgVersionSearchCompare)); _return: @@ -1634,7 +1634,7 @@ int32_t ctgOpDropDbVgroup(SCtgCacheOperation *operation) { goto _return; } - CTG_ERR_RET(ctgWLockVgInfo(pCtg, dbCache)); + CTG_ERR_JRET(ctgWLockVgInfo(pCtg, dbCache)); ctgFreeVgInfo(dbCache->vgCache.vgInfo); dbCache->vgCache.vgInfo = NULL; From 6cf578f2992f43a6218611800f9192a7c512c315 Mon Sep 17 00:00:00 2001 From: Xiaoyu Wang Date: Tue, 13 Sep 2022 14:19:50 +0800 Subject: [PATCH 016/138] feat: database option 'tsdb_pagesize' --- include/common/tmsg.h | 1 + include/common/ttokendef.h | 469 +- include/libs/nodes/cmdnodes.h | 1 + include/util/tdef.h | 3 + source/common/src/tmsg.c | 3 + source/libs/parser/inc/parAst.h | 3 +- source/libs/parser/inc/sql.y | 5 +- source/libs/parser/src/parAstCreater.c | 7 +- source/libs/parser/src/parTokenizer.c | 3 +- source/libs/parser/src/parTranslater.c | 5 + source/libs/parser/src/sql.c | 6142 +++++++++-------- .../parser/test/parAlterToBalanceTest.cpp | 6 +- source/libs/parser/test/parInitialCTest.cpp | 11 +- 13 files changed, 3352 insertions(+), 3307 deletions(-) diff --git a/include/common/tmsg.h b/include/common/tmsg.h index 9f919fa250..d3db2f318c 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -787,6 +787,7 @@ typedef struct { int32_t sstTrigger; int16_t hashPrefix; int16_t hashSuffix; + int32_t tsdbPageSize; } SCreateDbReq; int32_t tSerializeSCreateDbReq(void* buf, int32_t bufLen, SCreateDbReq* pReq); diff --git a/include/common/ttokendef.h b/include/common/ttokendef.h index c7cce6a183..3e170d5098 100644 --- a/include/common/ttokendef.h +++ b/include/common/ttokendef.h @@ -89,240 +89,241 @@ #define TK_KEEP 71 #define TK_PAGES 72 #define TK_PAGESIZE 73 -#define TK_PRECISION 74 -#define TK_REPLICA 75 -#define TK_STRICT 76 -#define TK_VGROUPS 77 -#define TK_SINGLE_STABLE 78 -#define TK_RETENTIONS 79 -#define TK_SCHEMALESS 80 -#define TK_WAL_LEVEL 81 -#define TK_WAL_FSYNC_PERIOD 82 -#define TK_WAL_RETENTION_PERIOD 83 -#define TK_WAL_RETENTION_SIZE 84 -#define TK_WAL_ROLL_PERIOD 85 -#define TK_WAL_SEGMENT_SIZE 86 -#define TK_SST_TRIGGER 87 -#define TK_TABLE_PREFIX 88 -#define TK_TABLE_SUFFIX 89 -#define TK_NK_COLON 90 -#define TK_TABLE 91 -#define TK_NK_LP 92 -#define TK_NK_RP 93 -#define TK_STABLE 94 -#define TK_ADD 95 -#define TK_COLUMN 96 -#define TK_MODIFY 97 -#define TK_RENAME 98 -#define TK_TAG 99 -#define TK_SET 100 -#define TK_NK_EQ 101 -#define TK_USING 102 -#define TK_TAGS 103 -#define TK_COMMENT 104 -#define TK_BOOL 105 -#define TK_TINYINT 106 -#define TK_SMALLINT 107 -#define TK_INT 108 -#define TK_INTEGER 109 -#define TK_BIGINT 110 -#define TK_FLOAT 111 -#define TK_DOUBLE 112 -#define TK_BINARY 113 -#define TK_TIMESTAMP 114 -#define TK_NCHAR 115 -#define TK_UNSIGNED 116 -#define TK_JSON 117 -#define TK_VARCHAR 118 -#define TK_MEDIUMBLOB 119 -#define TK_BLOB 120 -#define TK_VARBINARY 121 -#define TK_DECIMAL 122 -#define TK_MAX_DELAY 123 -#define TK_WATERMARK 124 -#define TK_ROLLUP 125 -#define TK_TTL 126 -#define TK_SMA 127 -#define TK_FIRST 128 -#define TK_LAST 129 -#define TK_SHOW 130 -#define TK_DATABASES 131 -#define TK_TABLES 132 -#define TK_STABLES 133 -#define TK_MNODES 134 -#define TK_MODULES 135 -#define TK_QNODES 136 -#define TK_FUNCTIONS 137 -#define TK_INDEXES 138 -#define TK_ACCOUNTS 139 -#define TK_APPS 140 -#define TK_CONNECTIONS 141 -#define TK_LICENCES 142 -#define TK_GRANTS 143 -#define TK_QUERIES 144 -#define TK_SCORES 145 -#define TK_TOPICS 146 -#define TK_VARIABLES 147 -#define TK_BNODES 148 -#define TK_SNODES 149 -#define TK_CLUSTER 150 -#define TK_TRANSACTIONS 151 -#define TK_DISTRIBUTED 152 -#define TK_CONSUMERS 153 -#define TK_SUBSCRIPTIONS 154 -#define TK_VNODES 155 -#define TK_LIKE 156 -#define TK_INDEX 157 -#define TK_FUNCTION 158 -#define TK_INTERVAL 159 -#define TK_TOPIC 160 -#define TK_AS 161 -#define TK_WITH 162 -#define TK_META 163 -#define TK_CONSUMER 164 -#define TK_GROUP 165 -#define TK_DESC 166 -#define TK_DESCRIBE 167 -#define TK_RESET 168 -#define TK_QUERY 169 -#define TK_CACHE 170 -#define TK_EXPLAIN 171 -#define TK_ANALYZE 172 -#define TK_VERBOSE 173 -#define TK_NK_BOOL 174 -#define TK_RATIO 175 -#define TK_NK_FLOAT 176 -#define TK_OUTPUTTYPE 177 -#define TK_AGGREGATE 178 -#define TK_BUFSIZE 179 -#define TK_STREAM 180 -#define TK_INTO 181 -#define TK_TRIGGER 182 -#define TK_AT_ONCE 183 -#define TK_WINDOW_CLOSE 184 -#define TK_IGNORE 185 -#define TK_EXPIRED 186 -#define TK_KILL 187 -#define TK_CONNECTION 188 -#define TK_TRANSACTION 189 -#define TK_BALANCE 190 -#define TK_VGROUP 191 -#define TK_MERGE 192 -#define TK_REDISTRIBUTE 193 -#define TK_SPLIT 194 -#define TK_DELETE 195 -#define TK_INSERT 196 -#define TK_NULL 197 -#define TK_NK_QUESTION 198 -#define TK_NK_ARROW 199 -#define TK_ROWTS 200 -#define TK_TBNAME 201 -#define TK_QSTART 202 -#define TK_QEND 203 -#define TK_QDURATION 204 -#define TK_WSTART 205 -#define TK_WEND 206 -#define TK_WDURATION 207 -#define TK_CAST 208 -#define TK_NOW 209 -#define TK_TODAY 210 -#define TK_TIMEZONE 211 -#define TK_CLIENT_VERSION 212 -#define TK_SERVER_VERSION 213 -#define TK_SERVER_STATUS 214 -#define TK_CURRENT_USER 215 -#define TK_COUNT 216 -#define TK_LAST_ROW 217 -#define TK_BETWEEN 218 -#define TK_IS 219 -#define TK_NK_LT 220 -#define TK_NK_GT 221 -#define TK_NK_LE 222 -#define TK_NK_GE 223 -#define TK_NK_NE 224 -#define TK_MATCH 225 -#define TK_NMATCH 226 -#define TK_CONTAINS 227 -#define TK_IN 228 -#define TK_JOIN 229 -#define TK_INNER 230 -#define TK_SELECT 231 -#define TK_DISTINCT 232 -#define TK_WHERE 233 -#define TK_PARTITION 234 -#define TK_BY 235 -#define TK_SESSION 236 -#define TK_STATE_WINDOW 237 -#define TK_SLIDING 238 -#define TK_FILL 239 -#define TK_VALUE 240 -#define TK_NONE 241 -#define TK_PREV 242 -#define TK_LINEAR 243 -#define TK_NEXT 244 -#define TK_HAVING 245 -#define TK_RANGE 246 -#define TK_EVERY 247 -#define TK_ORDER 248 -#define TK_SLIMIT 249 -#define TK_SOFFSET 250 -#define TK_LIMIT 251 -#define TK_OFFSET 252 -#define TK_ASC 253 -#define TK_NULLS 254 -#define TK_ABORT 255 -#define TK_AFTER 256 -#define TK_ATTACH 257 -#define TK_BEFORE 258 -#define TK_BEGIN 259 -#define TK_BITAND 260 -#define TK_BITNOT 261 -#define TK_BITOR 262 -#define TK_BLOCKS 263 -#define TK_CHANGE 264 -#define TK_COMMA 265 -#define TK_COMPACT 266 -#define TK_CONCAT 267 -#define TK_CONFLICT 268 -#define TK_COPY 269 -#define TK_DEFERRED 270 -#define TK_DELIMITERS 271 -#define TK_DETACH 272 -#define TK_DIVIDE 273 -#define TK_DOT 274 -#define TK_EACH 275 -#define TK_END 276 -#define TK_FAIL 277 -#define TK_FILE 278 -#define TK_FOR 279 -#define TK_GLOB 280 -#define TK_ID 281 -#define TK_IMMEDIATE 282 -#define TK_IMPORT 283 -#define TK_INITIALLY 284 -#define TK_INSTEAD 285 -#define TK_ISNULL 286 -#define TK_KEY 287 -#define TK_NK_BITNOT 288 -#define TK_NK_SEMI 289 -#define TK_NOTNULL 290 -#define TK_OF 291 -#define TK_PLUS 292 -#define TK_PRIVILEGE 293 -#define TK_RAISE 294 -#define TK_REPLACE 295 -#define TK_RESTRICT 296 -#define TK_ROW 297 -#define TK_SEMI 298 -#define TK_STAR 299 -#define TK_STATEMENT 300 -#define TK_STRING 301 -#define TK_TIMES 302 -#define TK_UPDATE 303 -#define TK_VALUES 304 -#define TK_VARIABLE 305 -#define TK_VIEW 306 -#define TK_WAL 307 +#define TK_TSDB_PAGESIZE 74 +#define TK_PRECISION 75 +#define TK_REPLICA 76 +#define TK_STRICT 77 +#define TK_VGROUPS 78 +#define TK_SINGLE_STABLE 79 +#define TK_RETENTIONS 80 +#define TK_SCHEMALESS 81 +#define TK_WAL_LEVEL 82 +#define TK_WAL_FSYNC_PERIOD 83 +#define TK_WAL_RETENTION_PERIOD 84 +#define TK_WAL_RETENTION_SIZE 85 +#define TK_WAL_ROLL_PERIOD 86 +#define TK_WAL_SEGMENT_SIZE 87 +#define TK_STT_TRIGGER 88 +#define TK_TABLE_PREFIX 89 +#define TK_TABLE_SUFFIX 90 +#define TK_NK_COLON 91 +#define TK_TABLE 92 +#define TK_NK_LP 93 +#define TK_NK_RP 94 +#define TK_STABLE 95 +#define TK_ADD 96 +#define TK_COLUMN 97 +#define TK_MODIFY 98 +#define TK_RENAME 99 +#define TK_TAG 100 +#define TK_SET 101 +#define TK_NK_EQ 102 +#define TK_USING 103 +#define TK_TAGS 104 +#define TK_COMMENT 105 +#define TK_BOOL 106 +#define TK_TINYINT 107 +#define TK_SMALLINT 108 +#define TK_INT 109 +#define TK_INTEGER 110 +#define TK_BIGINT 111 +#define TK_FLOAT 112 +#define TK_DOUBLE 113 +#define TK_BINARY 114 +#define TK_TIMESTAMP 115 +#define TK_NCHAR 116 +#define TK_UNSIGNED 117 +#define TK_JSON 118 +#define TK_VARCHAR 119 +#define TK_MEDIUMBLOB 120 +#define TK_BLOB 121 +#define TK_VARBINARY 122 +#define TK_DECIMAL 123 +#define TK_MAX_DELAY 124 +#define TK_WATERMARK 125 +#define TK_ROLLUP 126 +#define TK_TTL 127 +#define TK_SMA 128 +#define TK_FIRST 129 +#define TK_LAST 130 +#define TK_SHOW 131 +#define TK_DATABASES 132 +#define TK_TABLES 133 +#define TK_STABLES 134 +#define TK_MNODES 135 +#define TK_MODULES 136 +#define TK_QNODES 137 +#define TK_FUNCTIONS 138 +#define TK_INDEXES 139 +#define TK_ACCOUNTS 140 +#define TK_APPS 141 +#define TK_CONNECTIONS 142 +#define TK_LICENCES 143 +#define TK_GRANTS 144 +#define TK_QUERIES 145 +#define TK_SCORES 146 +#define TK_TOPICS 147 +#define TK_VARIABLES 148 +#define TK_BNODES 149 +#define TK_SNODES 150 +#define TK_CLUSTER 151 +#define TK_TRANSACTIONS 152 +#define TK_DISTRIBUTED 153 +#define TK_CONSUMERS 154 +#define TK_SUBSCRIPTIONS 155 +#define TK_VNODES 156 +#define TK_LIKE 157 +#define TK_INDEX 158 +#define TK_FUNCTION 159 +#define TK_INTERVAL 160 +#define TK_TOPIC 161 +#define TK_AS 162 +#define TK_WITH 163 +#define TK_META 164 +#define TK_CONSUMER 165 +#define TK_GROUP 166 +#define TK_DESC 167 +#define TK_DESCRIBE 168 +#define TK_RESET 169 +#define TK_QUERY 170 +#define TK_CACHE 171 +#define TK_EXPLAIN 172 +#define TK_ANALYZE 173 +#define TK_VERBOSE 174 +#define TK_NK_BOOL 175 +#define TK_RATIO 176 +#define TK_NK_FLOAT 177 +#define TK_OUTPUTTYPE 178 +#define TK_AGGREGATE 179 +#define TK_BUFSIZE 180 +#define TK_STREAM 181 +#define TK_INTO 182 +#define TK_TRIGGER 183 +#define TK_AT_ONCE 184 +#define TK_WINDOW_CLOSE 185 +#define TK_IGNORE 186 +#define TK_EXPIRED 187 +#define TK_KILL 188 +#define TK_CONNECTION 189 +#define TK_TRANSACTION 190 +#define TK_BALANCE 191 +#define TK_VGROUP 192 +#define TK_MERGE 193 +#define TK_REDISTRIBUTE 194 +#define TK_SPLIT 195 +#define TK_DELETE 196 +#define TK_INSERT 197 +#define TK_NULL 198 +#define TK_NK_QUESTION 199 +#define TK_NK_ARROW 200 +#define TK_ROWTS 201 +#define TK_TBNAME 202 +#define TK_QSTART 203 +#define TK_QEND 204 +#define TK_QDURATION 205 +#define TK_WSTART 206 +#define TK_WEND 207 +#define TK_WDURATION 208 +#define TK_CAST 209 +#define TK_NOW 210 +#define TK_TODAY 211 +#define TK_TIMEZONE 212 +#define TK_CLIENT_VERSION 213 +#define TK_SERVER_VERSION 214 +#define TK_SERVER_STATUS 215 +#define TK_CURRENT_USER 216 +#define TK_COUNT 217 +#define TK_LAST_ROW 218 +#define TK_BETWEEN 219 +#define TK_IS 220 +#define TK_NK_LT 221 +#define TK_NK_GT 222 +#define TK_NK_LE 223 +#define TK_NK_GE 224 +#define TK_NK_NE 225 +#define TK_MATCH 226 +#define TK_NMATCH 227 +#define TK_CONTAINS 228 +#define TK_IN 229 +#define TK_JOIN 230 +#define TK_INNER 231 +#define TK_SELECT 232 +#define TK_DISTINCT 233 +#define TK_WHERE 234 +#define TK_PARTITION 235 +#define TK_BY 236 +#define TK_SESSION 237 +#define TK_STATE_WINDOW 238 +#define TK_SLIDING 239 +#define TK_FILL 240 +#define TK_VALUE 241 +#define TK_NONE 242 +#define TK_PREV 243 +#define TK_LINEAR 244 +#define TK_NEXT 245 +#define TK_HAVING 246 +#define TK_RANGE 247 +#define TK_EVERY 248 +#define TK_ORDER 249 +#define TK_SLIMIT 250 +#define TK_SOFFSET 251 +#define TK_LIMIT 252 +#define TK_OFFSET 253 +#define TK_ASC 254 +#define TK_NULLS 255 +#define TK_ABORT 256 +#define TK_AFTER 257 +#define TK_ATTACH 258 +#define TK_BEFORE 259 +#define TK_BEGIN 260 +#define TK_BITAND 261 +#define TK_BITNOT 262 +#define TK_BITOR 263 +#define TK_BLOCKS 264 +#define TK_CHANGE 265 +#define TK_COMMA 266 +#define TK_COMPACT 267 +#define TK_CONCAT 268 +#define TK_CONFLICT 269 +#define TK_COPY 270 +#define TK_DEFERRED 271 +#define TK_DELIMITERS 272 +#define TK_DETACH 273 +#define TK_DIVIDE 274 +#define TK_DOT 275 +#define TK_EACH 276 +#define TK_END 277 +#define TK_FAIL 278 +#define TK_FILE 279 +#define TK_FOR 280 +#define TK_GLOB 281 +#define TK_ID 282 +#define TK_IMMEDIATE 283 +#define TK_IMPORT 284 +#define TK_INITIALLY 285 +#define TK_INSTEAD 286 +#define TK_ISNULL 287 +#define TK_KEY 288 +#define TK_NK_BITNOT 289 +#define TK_NK_SEMI 290 +#define TK_NOTNULL 291 +#define TK_OF 292 +#define TK_PLUS 293 +#define TK_PRIVILEGE 294 +#define TK_RAISE 295 +#define TK_REPLACE 296 +#define TK_RESTRICT 297 +#define TK_ROW 298 +#define TK_SEMI 299 +#define TK_STAR 300 +#define TK_STATEMENT 301 +#define TK_STRING 302 +#define TK_TIMES 303 +#define TK_UPDATE 304 +#define TK_VALUES 305 +#define TK_VARIABLE 306 +#define TK_VIEW 307 +#define TK_WAL 308 #define TK_NK_SPACE 300 #define TK_NK_COMMENT 301 diff --git a/include/libs/nodes/cmdnodes.h b/include/libs/nodes/cmdnodes.h index ea70a42147..22e92b2e80 100644 --- a/include/libs/nodes/cmdnodes.h +++ b/include/libs/nodes/cmdnodes.h @@ -64,6 +64,7 @@ typedef struct SDatabaseOptions { int64_t keep[3]; int32_t pages; int32_t pagesize; + int32_t tsdbPageSize; char precisionStr[3]; int8_t precision; int8_t replica; diff --git a/include/util/tdef.h b/include/util/tdef.h index 21f879cd93..840a2671fa 100644 --- a/include/util/tdef.h +++ b/include/util/tdef.h @@ -300,6 +300,9 @@ typedef enum ELogicConditionType { #define TSDB_DEFAULT_PAGES_PER_VNODE 256 #define TSDB_MIN_PAGESIZE_PER_VNODE 1 // unit KB #define TSDB_MAX_PAGESIZE_PER_VNODE 16384 +#define TSDB_DEFAULT_TSDB_PAGESIZE 4 +#define TSDB_MIN_TSDB_PAGESIZE 1 // unit KB +#define TSDB_MAX_TSDB_PAGESIZE 16384 #define TSDB_DEFAULT_PAGESIZE_PER_VNODE 4 #define TSDB_MIN_DAYS_PER_FILE 60 // unit minute #define TSDB_MAX_DAYS_PER_FILE (3650 * 1440) diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index ea25094d10..7d8461ca60 100644 --- a/source/common/src/tmsg.c +++ b/source/common/src/tmsg.c @@ -2038,6 +2038,7 @@ int32_t tSerializeSCreateDbReq(void *buf, int32_t bufLen, SCreateDbReq *pReq) { if (tEncodeI8(&encoder, pRetension->freqUnit) < 0) return -1; if (tEncodeI8(&encoder, pRetension->keepUnit) < 0) return -1; } + if (tEncodeI32(&encoder, pReq->tsdbPageSize) < 0) return -1; tEndEncode(&encoder); int32_t tlen = encoder.pos; @@ -2098,6 +2099,8 @@ int32_t tDeserializeSCreateDbReq(void *buf, int32_t bufLen, SCreateDbReq *pReq) } } + if (tDecodeI32(&decoder, &pReq->tsdbPageSize) < 0) return -1; + tEndDecode(&decoder); tDecoderClear(&decoder); diff --git a/source/libs/parser/inc/parAst.h b/source/libs/parser/inc/parAst.h index 0507fe0c66..898e4bf732 100644 --- a/source/libs/parser/inc/parAst.h +++ b/source/libs/parser/inc/parAst.h @@ -48,6 +48,7 @@ typedef enum EDatabaseOptionType { DB_OPTION_KEEP, DB_OPTION_PAGES, DB_OPTION_PAGESIZE, + DB_OPTION_TSDB_PAGESIZE, DB_OPTION_PRECISION, DB_OPTION_REPLICA, DB_OPTION_STRICT, @@ -60,7 +61,7 @@ typedef enum EDatabaseOptionType { DB_OPTION_WAL_RETENTION_SIZE, DB_OPTION_WAL_ROLL_PERIOD, DB_OPTION_WAL_SEGMENT_SIZE, - DB_OPTION_SST_TRIGGER, + DB_OPTION_STT_TRIGGER, DB_OPTION_TABLE_PREFIX, DB_OPTION_TABLE_SUFFIX } EDatabaseOptionType; diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y index fdd0ec548b..bef2ed98ec 100644 --- a/source/libs/parser/inc/sql.y +++ b/source/libs/parser/inc/sql.y @@ -184,6 +184,7 @@ db_options(A) ::= db_options(B) KEEP integer_list(C). db_options(A) ::= db_options(B) KEEP variable_list(C). { A = setDatabaseOption(pCxt, B, DB_OPTION_KEEP, C); } db_options(A) ::= db_options(B) PAGES NK_INTEGER(C). { A = setDatabaseOption(pCxt, B, DB_OPTION_PAGES, &C); } db_options(A) ::= db_options(B) PAGESIZE NK_INTEGER(C). { A = setDatabaseOption(pCxt, B, DB_OPTION_PAGESIZE, &C); } +db_options(A) ::= db_options(B) TSDB_PAGESIZE NK_INTEGER(C). { A = setDatabaseOption(pCxt, B, DB_OPTION_TSDB_PAGESIZE, &C); } db_options(A) ::= db_options(B) PRECISION NK_STRING(C). { A = setDatabaseOption(pCxt, B, DB_OPTION_PRECISION, &C); } db_options(A) ::= db_options(B) REPLICA NK_INTEGER(C). { A = setDatabaseOption(pCxt, B, DB_OPTION_REPLICA, &C); } db_options(A) ::= db_options(B) STRICT NK_STRING(C). { A = setDatabaseOption(pCxt, B, DB_OPTION_STRICT, &C); } @@ -207,7 +208,7 @@ db_options(A) ::= db_options(B) WAL_RETENTION_SIZE NK_MINUS(D) NK_INTEGER(C). } db_options(A) ::= db_options(B) WAL_ROLL_PERIOD NK_INTEGER(C). { A = setDatabaseOption(pCxt, B, DB_OPTION_WAL_ROLL_PERIOD, &C); } db_options(A) ::= db_options(B) WAL_SEGMENT_SIZE NK_INTEGER(C). { A = setDatabaseOption(pCxt, B, DB_OPTION_WAL_SEGMENT_SIZE, &C); } -db_options(A) ::= db_options(B) SST_TRIGGER NK_INTEGER(C). { A = setDatabaseOption(pCxt, B, DB_OPTION_SST_TRIGGER, &C); } +db_options(A) ::= db_options(B) STT_TRIGGER NK_INTEGER(C). { A = setDatabaseOption(pCxt, B, DB_OPTION_STT_TRIGGER, &C); } db_options(A) ::= db_options(B) TABLE_PREFIX NK_INTEGER(C). { A = setDatabaseOption(pCxt, B, DB_OPTION_TABLE_PREFIX, &C); } db_options(A) ::= db_options(B) TABLE_SUFFIX NK_INTEGER(C). { A = setDatabaseOption(pCxt, B, DB_OPTION_TABLE_SUFFIX, &C); } @@ -226,7 +227,7 @@ alter_db_option(A) ::= KEEP variable_list(B). //alter_db_option(A) ::= REPLICA NK_INTEGER(B). { A.type = DB_OPTION_REPLICA; A.val = B; } //alter_db_option(A) ::= STRICT NK_STRING(B). { A.type = DB_OPTION_STRICT; A.val = B; } alter_db_option(A) ::= WAL_LEVEL NK_INTEGER(B). { A.type = DB_OPTION_WAL; A.val = B; } -alter_db_option(A) ::= SST_TRIGGER NK_INTEGER(B). { A.type = DB_OPTION_SST_TRIGGER; A.val = B; } +alter_db_option(A) ::= STT_TRIGGER NK_INTEGER(B). { A.type = DB_OPTION_STT_TRIGGER; A.val = B; } %type integer_list { SNodeList* } %destructor integer_list { nodesDestroyList($$); } diff --git a/source/libs/parser/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c index 901abf17ee..655bb68206 100644 --- a/source/libs/parser/src/parAstCreater.c +++ b/source/libs/parser/src/parAstCreater.c @@ -826,6 +826,7 @@ SNode* createDefaultDatabaseOptions(SAstCreateContext* pCxt) { pOptions->keep[2] = TSDB_DEFAULT_KEEP; pOptions->pages = TSDB_DEFAULT_PAGES_PER_VNODE; pOptions->pagesize = TSDB_DEFAULT_PAGESIZE_PER_VNODE; + pOptions->tsdbPageSize = TSDB_DEFAULT_TSDB_PAGESIZE; pOptions->precision = TSDB_DEFAULT_PRECISION; pOptions->replica = TSDB_DEFAULT_DB_REPLICA; pOptions->strict = TSDB_DEFAULT_DB_STRICT; @@ -858,6 +859,7 @@ SNode* createAlterDatabaseOptions(SAstCreateContext* pCxt) { pOptions->keep[2] = -1; pOptions->pages = -1; pOptions->pagesize = -1; + pOptions->tsdbPageSize = -1; pOptions->precision = -1; pOptions->replica = -1; pOptions->strict = -1; @@ -918,6 +920,9 @@ SNode* setDatabaseOption(SAstCreateContext* pCxt, SNode* pOptions, EDatabaseOpti case DB_OPTION_PAGESIZE: pDbOptions->pagesize = taosStr2Int32(((SToken*)pVal)->z, NULL, 10); break; + case DB_OPTION_TSDB_PAGESIZE: + pDbOptions->tsdbPageSize = taosStr2Int32(((SToken*)pVal)->z, NULL, 10); + break; case DB_OPTION_PRECISION: COPY_STRING_FORM_STR_TOKEN(pDbOptions->precisionStr, (SToken*)pVal); break; @@ -955,7 +960,7 @@ SNode* setDatabaseOption(SAstCreateContext* pCxt, SNode* pOptions, EDatabaseOpti case DB_OPTION_WAL_SEGMENT_SIZE: pDbOptions->walSegmentSize = taosStr2Int32(((SToken*)pVal)->z, NULL, 10); break; - case DB_OPTION_SST_TRIGGER: + case DB_OPTION_STT_TRIGGER: pDbOptions->sstTrigger = taosStr2Int32(((SToken*)pVal)->z, NULL, 10); break; case DB_OPTION_TABLE_PREFIX: diff --git a/source/libs/parser/src/parTokenizer.c b/source/libs/parser/src/parTokenizer.c index e0f54530dd..68eb3e6fb1 100644 --- a/source/libs/parser/src/parTokenizer.c +++ b/source/libs/parser/src/parTokenizer.c @@ -187,7 +187,7 @@ static SKeyword keywordTable[] = { {"SNODES", TK_SNODES}, {"SOFFSET", TK_SOFFSET}, {"SPLIT", TK_SPLIT}, - {"SST_TRIGGER", TK_SST_TRIGGER}, + {"STT_TRIGGER", TK_STT_TRIGGER}, {"STABLE", TK_STABLE}, {"STABLES", TK_STABLES}, {"STATE", TK_STATE}, @@ -216,6 +216,7 @@ static SKeyword keywordTable[] = { {"TRANSACTIONS", TK_TRANSACTIONS}, {"TRIGGER", TK_TRIGGER}, {"TRIM", TK_TRIM}, + {"TSDB_PAGESIZE", TK_TSDB_PAGESIZE}, {"TSERIES", TK_TSERIES}, {"TTL", TK_TTL}, {"UNION", TK_UNION}, diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index 91787f5a72..2af4032fd8 100644 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -3485,6 +3485,7 @@ static int32_t buildCreateDbReq(STranslateContext* pCxt, SCreateDatabaseStmt* pS pReq->sstTrigger = pStmt->pOptions->sstTrigger; pReq->hashPrefix = pStmt->pOptions->tablePrefix; pReq->hashSuffix = pStmt->pOptions->tableSuffix; + pReq->tsdbPageSize = pStmt->pOptions->tsdbPageSize; pReq->ignoreExist = pStmt->ignoreExists; return buildCreateDbRetentions(pStmt->pOptions->pRetentions, pReq); } @@ -3729,6 +3730,10 @@ static int32_t checkDatabaseOptions(STranslateContext* pCxt, const char* pDbName code = checkDbRangeOption(pCxt, "pagesize", pOptions->pagesize, TSDB_MIN_PAGESIZE_PER_VNODE, TSDB_MAX_PAGESIZE_PER_VNODE); } + if (TSDB_CODE_SUCCESS == code) { + code = checkDbRangeOption(pCxt, "tsdbPagesize", pOptions->tsdbPageSize, TSDB_MIN_TSDB_PAGESIZE, + TSDB_MAX_TSDB_PAGESIZE); + } if (TSDB_CODE_SUCCESS == code) { code = checkDbPrecisionOption(pCxt, pOptions); } diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c index 0442d262f1..a2a52aa0e0 100644 --- a/source/libs/parser/src/sql.c +++ b/source/libs/parser/src/sql.c @@ -104,26 +104,26 @@ #endif /************* Begin control #defines *****************************************/ #define YYCODETYPE unsigned short int -#define YYNOCODE 429 +#define YYNOCODE 430 #define YYACTIONTYPE unsigned short int #define ParseTOKENTYPE SToken typedef union { int yyinit; ParseTOKENTYPE yy0; - int32_t yy46; - SNode* yy80; - int64_t yy129; - SDataType yy136; - EOperatorType yy194; - SToken yy239; - SAlterOption yy299; - EOrder yy422; - EFillMode yy426; - int8_t yy509; - SNodeList* yy574; - EJoinType yy750; - ENullOrder yy763; - bool yy845; + int64_t yy49; + SDataType yy84; + EFillMode yy134; + SToken yy149; + EOrder yy158; + int32_t yy160; + SNode* yy312; + EOperatorType yy320; + int8_t yy363; + SAlterOption yy405; + ENullOrder yy417; + bool yy497; + SNodeList* yy824; + EJoinType yy832; } YYMINORTYPE; #ifndef YYSTACKDEPTH #define YYSTACKDEPTH 100 @@ -139,17 +139,17 @@ typedef union { #define ParseCTX_FETCH #define ParseCTX_STORE #define YYFALLBACK 1 -#define YYNSTATE 674 -#define YYNRULE 495 -#define YYNTOKEN 308 -#define YY_MAX_SHIFT 673 -#define YY_MIN_SHIFTREDUCE 983 -#define YY_MAX_SHIFTREDUCE 1477 -#define YY_ERROR_ACTION 1478 -#define YY_ACCEPT_ACTION 1479 -#define YY_NO_ACTION 1480 -#define YY_MIN_REDUCE 1481 -#define YY_MAX_REDUCE 1975 +#define YYNSTATE 675 +#define YYNRULE 496 +#define YYNTOKEN 309 +#define YY_MAX_SHIFT 674 +#define YY_MIN_SHIFTREDUCE 985 +#define YY_MAX_SHIFTREDUCE 1480 +#define YY_ERROR_ACTION 1481 +#define YY_ACCEPT_ACTION 1482 +#define YY_NO_ACTION 1483 +#define YY_MIN_REDUCE 1484 +#define YY_MAX_REDUCE 1979 /************* End control #defines *******************************************/ #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) @@ -216,680 +216,690 @@ typedef union { ** yy_default[] Default action for each state. ** *********** Begin parsing tables **********************************************/ -#define YY_ACTTAB_COUNT (2464) +#define YY_ACTTAB_COUNT (2512) static const YYACTIONTYPE yy_action[] = { - /* 0 */ 436, 379, 437, 1516, 1809, 91, 516, 444, 1616, 437, - /* 10 */ 1516, 1614, 39, 37, 553, 64, 30, 260, 124, 1793, - /* 20 */ 340, 1953, 1278, 33, 32, 1016, 1617, 40, 38, 36, - /* 30 */ 35, 34, 1827, 1354, 1952, 1276, 385, 148, 1950, 1493, - /* 40 */ 582, 1953, 127, 1789, 1795, 1779, 1953, 581, 40, 38, - /* 50 */ 36, 35, 34, 556, 164, 575, 1349, 517, 1950, 164, - /* 60 */ 558, 14, 558, 1950, 326, 1020, 1021, 1725, 1284, 1543, - /* 70 */ 1841, 1304, 74, 303, 94, 1810, 584, 1812, 1813, 580, - /* 80 */ 125, 575, 1504, 173, 1887, 122, 217, 345, 306, 1883, - /* 90 */ 1670, 1672, 1, 556, 1620, 250, 1895, 552, 63, 551, - /* 100 */ 1953, 107, 1953, 63, 106, 105, 104, 103, 102, 101, - /* 110 */ 100, 99, 98, 166, 670, 166, 453, 1950, 71, 1950, - /* 120 */ 1421, 70, 63, 1779, 78, 42, 1303, 1303, 1356, 1357, - /* 130 */ 11, 10, 647, 646, 645, 644, 350, 1503, 643, 642, - /* 140 */ 128, 637, 636, 635, 634, 633, 632, 631, 139, 627, - /* 150 */ 626, 625, 349, 348, 622, 621, 620, 619, 618, 530, - /* 160 */ 500, 33, 32, 196, 1481, 40, 38, 36, 35, 34, - /* 170 */ 55, 223, 224, 498, 1279, 496, 1277, 152, 1779, 1175, - /* 180 */ 1176, 1474, 470, 466, 462, 458, 195, 1625, 116, 115, - /* 190 */ 114, 113, 112, 111, 110, 109, 108, 1282, 1283, 63, - /* 200 */ 1331, 1332, 1334, 1335, 1336, 1337, 1338, 1339, 577, 573, - /* 210 */ 1347, 1348, 1350, 1351, 1352, 1353, 1355, 1358, 39, 37, - /* 220 */ 1417, 75, 1390, 302, 193, 1301, 340, 84, 1278, 1809, - /* 230 */ 305, 167, 415, 520, 1953, 427, 353, 167, 530, 1354, - /* 240 */ 542, 1276, 167, 1677, 1798, 553, 1448, 165, 1618, 169, - /* 250 */ 328, 1950, 400, 1677, 428, 1793, 402, 1827, 1953, 1675, - /* 260 */ 344, 167, 1349, 1304, 167, 582, 1625, 14, 1473, 1675, - /* 270 */ 1779, 1951, 581, 127, 1284, 1950, 1953, 33, 32, 1789, - /* 280 */ 1795, 40, 38, 36, 35, 34, 1797, 192, 186, 164, - /* 290 */ 191, 575, 49, 1950, 449, 1841, 393, 1793, 2, 95, - /* 300 */ 1810, 584, 1812, 1813, 580, 1303, 575, 1333, 389, 1887, - /* 310 */ 184, 125, 22, 331, 1883, 1966, 556, 548, 543, 158, - /* 320 */ 670, 1789, 1795, 329, 1921, 555, 160, 1895, 1896, 1724, - /* 330 */ 1900, 300, 1664, 575, 1356, 1357, 426, 1479, 167, 421, - /* 340 */ 420, 419, 418, 417, 414, 413, 412, 411, 410, 406, - /* 350 */ 405, 404, 403, 397, 396, 395, 394, 1522, 391, 390, - /* 360 */ 314, 1902, 1133, 606, 605, 604, 1137, 603, 1139, 1140, - /* 370 */ 602, 1142, 599, 530, 1148, 596, 1150, 1151, 593, 590, - /* 380 */ 1279, 327, 1277, 317, 383, 1899, 33, 32, 43, 146, - /* 390 */ 40, 38, 36, 35, 34, 150, 355, 547, 1627, 1584, - /* 400 */ 1033, 1625, 1032, 1282, 1283, 665, 1331, 1332, 1334, 1335, - /* 410 */ 1336, 1337, 1338, 1339, 577, 573, 1347, 1348, 1350, 1351, - /* 420 */ 1352, 1353, 1355, 1358, 39, 37, 1809, 491, 1671, 1672, - /* 430 */ 1034, 167, 340, 1723, 1278, 300, 1953, 1302, 36, 35, - /* 440 */ 34, 318, 501, 316, 315, 1354, 476, 1276, 1677, 164, - /* 450 */ 478, 1305, 222, 1950, 1827, 312, 209, 1602, 486, 485, - /* 460 */ 1364, 1603, 582, 617, 1675, 123, 1303, 1779, 1349, 581, - /* 470 */ 494, 1428, 477, 14, 488, 481, 484, 26, 343, 208, - /* 480 */ 1284, 480, 558, 33, 32, 346, 146, 40, 38, 36, - /* 490 */ 35, 34, 1841, 146, 7, 1627, 94, 1810, 584, 1812, - /* 500 */ 1813, 580, 1627, 575, 2, 609, 1887, 1378, 553, 530, - /* 510 */ 306, 1883, 1258, 1259, 58, 435, 1953, 57, 439, 1502, - /* 520 */ 117, 453, 1953, 147, 1827, 63, 670, 474, 278, 165, - /* 530 */ 1809, 1501, 546, 1950, 374, 164, 127, 1625, 28, 1950, - /* 540 */ 1356, 1357, 276, 60, 33, 32, 59, 1284, 40, 38, - /* 550 */ 36, 35, 34, 376, 372, 337, 336, 1500, 1827, 530, - /* 560 */ 1779, 615, 180, 432, 430, 1292, 582, 1728, 545, 27, - /* 570 */ 117, 1779, 1779, 581, 125, 517, 1354, 479, 1285, 1383, - /* 580 */ 137, 136, 612, 611, 610, 1726, 1279, 1625, 1277, 161, - /* 590 */ 1895, 1896, 252, 1900, 629, 1499, 1841, 63, 1779, 1349, - /* 600 */ 149, 1810, 584, 1812, 1813, 580, 378, 575, 377, 1282, - /* 610 */ 1283, 1284, 1331, 1332, 1334, 1335, 1336, 1337, 1338, 1339, - /* 620 */ 577, 573, 1347, 1348, 1350, 1351, 1352, 1353, 1355, 1358, - /* 630 */ 39, 37, 1902, 1278, 1498, 93, 1779, 1497, 340, 630, - /* 640 */ 1278, 1597, 441, 1601, 559, 1967, 1276, 1333, 1301, 1610, - /* 650 */ 1033, 1354, 1032, 1276, 33, 32, 1898, 570, 40, 38, - /* 660 */ 36, 35, 34, 1546, 167, 472, 443, 352, 1612, 439, - /* 670 */ 1496, 68, 67, 382, 1349, 1779, 171, 1608, 1779, 1284, - /* 680 */ 1034, 210, 1495, 33, 32, 1410, 1284, 40, 38, 36, - /* 690 */ 35, 34, 301, 530, 1809, 370, 74, 368, 364, 360, - /* 700 */ 357, 354, 1492, 617, 384, 1020, 1021, 1953, 33, 32, - /* 710 */ 8, 1779, 40, 38, 36, 35, 34, 1293, 1621, 1288, - /* 720 */ 164, 1625, 1827, 1779, 1950, 670, 213, 486, 485, 1491, - /* 730 */ 557, 1490, 670, 502, 123, 1779, 167, 581, 76, 305, - /* 740 */ 1296, 1298, 520, 1779, 481, 484, 1356, 1357, 1489, 1095, - /* 750 */ 480, 1902, 573, 1347, 1348, 1350, 1351, 1352, 1353, 1438, - /* 760 */ 1841, 307, 1907, 1410, 95, 1810, 584, 1812, 1813, 580, - /* 770 */ 1779, 575, 1779, 1953, 1887, 1897, 615, 1718, 331, 1883, - /* 780 */ 159, 1414, 1097, 483, 482, 1279, 164, 1277, 172, 1779, - /* 790 */ 1950, 478, 1279, 1316, 1277, 137, 136, 612, 611, 610, - /* 800 */ 1914, 1376, 539, 1436, 1437, 1439, 1440, 145, 1282, 1283, - /* 810 */ 1488, 1809, 1487, 477, 1486, 1282, 1283, 1306, 1331, 1332, - /* 820 */ 1334, 1335, 1336, 1337, 1338, 1339, 577, 573, 1347, 1348, - /* 830 */ 1350, 1351, 1352, 1353, 1355, 1358, 39, 37, 1359, 1827, - /* 840 */ 1482, 146, 422, 509, 340, 1060, 1278, 582, 1485, 167, - /* 850 */ 1628, 1779, 1779, 1779, 581, 1779, 1377, 1354, 1484, 1276, - /* 860 */ 1677, 107, 1718, 61, 106, 105, 104, 103, 102, 101, - /* 870 */ 100, 99, 98, 175, 641, 639, 1676, 1841, 1061, 1303, - /* 880 */ 1349, 96, 1810, 584, 1812, 1813, 580, 613, 575, 1779, - /* 890 */ 1668, 1887, 1284, 44, 4, 1886, 1883, 177, 176, 1779, - /* 900 */ 614, 33, 32, 1668, 1797, 40, 38, 36, 35, 34, - /* 910 */ 272, 135, 576, 1655, 1809, 1793, 9, 1766, 29, 338, - /* 920 */ 1371, 1372, 1373, 1374, 1375, 1379, 1380, 1381, 1382, 33, - /* 930 */ 32, 1809, 530, 40, 38, 36, 35, 34, 670, 1789, - /* 940 */ 1795, 335, 1827, 392, 562, 530, 608, 324, 1533, 386, - /* 950 */ 582, 575, 1356, 1357, 307, 1779, 407, 581, 232, 1827, - /* 960 */ 1625, 54, 387, 201, 362, 203, 199, 582, 202, 1494, - /* 970 */ 487, 530, 1779, 1625, 581, 53, 513, 11, 10, 530, - /* 980 */ 1841, 216, 408, 565, 294, 1810, 584, 1812, 1813, 580, - /* 990 */ 451, 575, 553, 205, 1376, 1528, 204, 1841, 1279, 1625, - /* 1000 */ 1277, 96, 1810, 584, 1812, 1813, 580, 1625, 575, 1413, - /* 1010 */ 207, 1887, 41, 206, 1316, 569, 1883, 489, 255, 77, - /* 1020 */ 127, 1282, 1283, 1526, 1331, 1332, 1334, 1335, 1336, 1337, - /* 1030 */ 1338, 1339, 577, 573, 1347, 1348, 1350, 1351, 1352, 1353, - /* 1040 */ 1355, 1358, 39, 37, 530, 492, 221, 1585, 530, 1377, - /* 1050 */ 340, 131, 1278, 134, 673, 452, 530, 1287, 125, 1622, - /* 1060 */ 1333, 471, 1229, 1354, 1809, 1276, 1286, 503, 267, 1476, - /* 1070 */ 1477, 540, 1625, 162, 1895, 1896, 1625, 1900, 571, 1800, - /* 1080 */ 623, 135, 156, 51, 1625, 90, 1349, 663, 659, 655, - /* 1090 */ 651, 265, 1827, 1600, 244, 87, 225, 531, 1284, 530, - /* 1100 */ 582, 523, 1079, 229, 1809, 1779, 236, 581, 560, 1828, - /* 1110 */ 510, 29, 338, 1371, 1372, 1373, 1374, 1375, 1379, 1380, - /* 1120 */ 1381, 1382, 9, 41, 624, 1802, 92, 1625, 351, 230, - /* 1130 */ 1841, 1126, 1827, 1435, 294, 1810, 584, 1812, 1813, 580, - /* 1140 */ 557, 575, 1665, 51, 670, 1779, 1077, 581, 1517, 41, - /* 1150 */ 588, 563, 530, 1917, 530, 530, 239, 530, 1356, 1357, - /* 1160 */ 554, 134, 527, 514, 249, 227, 526, 254, 528, 257, - /* 1170 */ 1841, 135, 259, 271, 95, 1810, 584, 1812, 1813, 580, - /* 1180 */ 1625, 575, 1625, 1625, 1887, 1625, 3, 5, 331, 1883, - /* 1190 */ 159, 356, 566, 1384, 361, 219, 313, 615, 1290, 1340, - /* 1200 */ 1154, 530, 163, 119, 1279, 134, 1277, 1289, 1245, 174, - /* 1210 */ 1913, 1158, 529, 1252, 1368, 212, 137, 136, 612, 611, - /* 1220 */ 610, 1165, 268, 388, 1301, 409, 1720, 1282, 1283, 1625, - /* 1230 */ 1331, 1332, 1334, 1335, 1336, 1337, 1338, 1339, 577, 573, - /* 1240 */ 1347, 1348, 1350, 1351, 1352, 1353, 1355, 1358, 39, 37, - /* 1250 */ 1809, 530, 530, 1163, 416, 138, 340, 424, 1278, 423, - /* 1260 */ 425, 429, 261, 347, 431, 433, 1307, 1309, 434, 1354, - /* 1270 */ 442, 1276, 445, 183, 446, 185, 1308, 447, 1827, 1625, - /* 1280 */ 1625, 1310, 188, 448, 450, 190, 582, 72, 73, 454, - /* 1290 */ 194, 1779, 1349, 581, 473, 475, 118, 1615, 304, 198, - /* 1300 */ 1611, 1759, 200, 269, 1284, 140, 504, 141, 211, 505, - /* 1310 */ 1809, 1613, 1609, 142, 143, 214, 1841, 511, 218, 515, - /* 1320 */ 95, 1810, 584, 1812, 1813, 580, 553, 575, 2, 538, - /* 1330 */ 1887, 524, 508, 81, 331, 1883, 1966, 323, 1827, 83, - /* 1340 */ 518, 132, 1758, 1730, 521, 1944, 582, 1306, 133, 525, - /* 1350 */ 670, 1779, 1626, 581, 127, 270, 325, 1928, 534, 541, - /* 1360 */ 1918, 536, 6, 234, 1356, 1357, 537, 330, 544, 1909, - /* 1370 */ 550, 535, 533, 238, 558, 532, 1841, 1305, 1410, 126, - /* 1380 */ 95, 1810, 584, 1812, 1813, 580, 567, 575, 564, 48, - /* 1390 */ 1887, 332, 125, 246, 331, 1883, 1966, 1927, 243, 248, - /* 1400 */ 1903, 85, 586, 1669, 1598, 1906, 247, 250, 1895, 552, - /* 1410 */ 1279, 551, 1277, 1868, 1953, 153, 273, 264, 666, 667, - /* 1420 */ 52, 669, 299, 286, 275, 245, 1809, 164, 296, 1773, - /* 1430 */ 277, 1950, 295, 1282, 1283, 65, 1331, 1332, 1334, 1335, - /* 1440 */ 1336, 1337, 1338, 1339, 577, 573, 1347, 1348, 1350, 1351, - /* 1450 */ 1352, 1353, 1355, 1358, 1827, 1969, 1772, 1949, 1771, 253, - /* 1460 */ 1770, 256, 582, 66, 561, 568, 258, 1779, 1767, 581, - /* 1470 */ 359, 358, 1270, 1271, 170, 363, 1765, 365, 366, 367, - /* 1480 */ 1764, 369, 558, 1763, 371, 1762, 373, 1809, 1761, 375, - /* 1490 */ 1248, 1741, 1841, 1247, 1740, 380, 285, 1810, 584, 1812, - /* 1500 */ 1813, 580, 381, 575, 1739, 1738, 1713, 1217, 1712, 1711, - /* 1510 */ 1710, 129, 1709, 1708, 69, 1827, 1707, 1706, 1705, 1704, - /* 1520 */ 1703, 398, 1953, 582, 399, 1702, 401, 1701, 1779, 1700, - /* 1530 */ 581, 1699, 1698, 1697, 1696, 166, 1695, 1694, 1693, 1950, - /* 1540 */ 1692, 1691, 1690, 558, 1809, 1689, 1688, 1687, 1686, 130, - /* 1550 */ 1685, 1684, 1683, 1841, 178, 1547, 179, 285, 1810, 584, - /* 1560 */ 1812, 1813, 580, 1682, 575, 1219, 1681, 1680, 1679, 1678, - /* 1570 */ 1809, 1548, 1827, 1545, 1513, 1023, 438, 181, 120, 1022, - /* 1580 */ 579, 1512, 1754, 1953, 1748, 1779, 1737, 581, 189, 1736, - /* 1590 */ 1722, 1604, 157, 1544, 1542, 121, 164, 182, 1827, 440, - /* 1600 */ 1950, 187, 1540, 1538, 1536, 455, 582, 456, 1525, 1524, - /* 1610 */ 1841, 1779, 459, 581, 293, 1810, 584, 1812, 1813, 580, - /* 1620 */ 578, 575, 572, 1859, 457, 460, 1053, 461, 1809, 1509, - /* 1630 */ 463, 465, 467, 1606, 464, 469, 1841, 1168, 1605, 97, - /* 1640 */ 96, 1810, 584, 1812, 1813, 580, 1809, 575, 468, 1169, - /* 1650 */ 1887, 1094, 1093, 638, 640, 1884, 1827, 1090, 197, 50, - /* 1660 */ 1089, 1088, 1534, 319, 582, 1529, 320, 490, 1527, 1779, - /* 1670 */ 321, 581, 493, 1508, 1827, 1507, 1506, 495, 497, 499, - /* 1680 */ 1753, 1254, 582, 56, 1747, 506, 215, 1779, 144, 581, - /* 1690 */ 1735, 1733, 1734, 1732, 1841, 1731, 1809, 15, 289, 1810, - /* 1700 */ 584, 1812, 1813, 580, 1262, 575, 220, 519, 1729, 1721, - /* 1710 */ 80, 45, 1841, 226, 87, 41, 149, 1810, 584, 1812, - /* 1720 */ 1813, 580, 1809, 575, 1827, 231, 79, 82, 23, 47, - /* 1730 */ 16, 241, 579, 507, 17, 522, 549, 1779, 512, 581, - /* 1740 */ 322, 1462, 1450, 233, 242, 235, 1809, 1432, 237, 1800, - /* 1750 */ 1827, 1434, 151, 240, 25, 339, 228, 1427, 582, 24, - /* 1760 */ 251, 1968, 1841, 1779, 46, 581, 293, 1810, 584, 1812, - /* 1770 */ 1813, 580, 1799, 575, 1827, 1860, 1407, 86, 154, 341, - /* 1780 */ 1406, 18, 582, 1461, 333, 1466, 1465, 1779, 1841, 581, - /* 1790 */ 1467, 334, 294, 1810, 584, 1812, 1813, 580, 1456, 575, - /* 1800 */ 10, 1294, 19, 1369, 1809, 1844, 155, 168, 1344, 574, - /* 1810 */ 1324, 1342, 1841, 1341, 31, 13, 294, 1810, 584, 1812, - /* 1820 */ 1813, 580, 12, 575, 1155, 20, 583, 21, 585, 587, - /* 1830 */ 342, 589, 1827, 1152, 591, 592, 594, 1149, 595, 597, - /* 1840 */ 582, 600, 1132, 1147, 598, 1779, 1143, 581, 1141, 601, - /* 1850 */ 1146, 1164, 1145, 1144, 88, 1809, 89, 62, 607, 1160, - /* 1860 */ 262, 1085, 1051, 616, 1084, 1809, 1083, 1082, 1081, 1080, - /* 1870 */ 1841, 1078, 628, 1076, 279, 1810, 584, 1812, 1813, 580, - /* 1880 */ 1075, 575, 1074, 1827, 1072, 263, 1101, 1071, 1070, 1069, - /* 1890 */ 1068, 582, 1067, 1827, 1066, 1098, 1779, 1096, 581, 1063, - /* 1900 */ 1062, 582, 1059, 1057, 1058, 1056, 1779, 1541, 581, 648, - /* 1910 */ 649, 650, 1539, 652, 654, 1537, 658, 656, 1809, 1535, - /* 1920 */ 653, 1841, 660, 657, 662, 280, 1810, 584, 1812, 1813, - /* 1930 */ 580, 1841, 575, 661, 1809, 281, 1810, 584, 1812, 1813, - /* 1940 */ 580, 1523, 575, 664, 1013, 1505, 1827, 266, 668, 1480, - /* 1950 */ 1280, 274, 671, 672, 582, 1480, 1480, 1480, 1809, 1779, - /* 1960 */ 1480, 581, 1827, 1480, 1480, 1480, 1480, 1480, 1480, 1480, - /* 1970 */ 582, 1480, 1480, 1480, 1480, 1779, 1480, 581, 1480, 1480, - /* 1980 */ 1480, 1480, 1480, 1480, 1841, 1480, 1827, 1480, 288, 1810, - /* 1990 */ 584, 1812, 1813, 580, 582, 575, 1480, 1480, 1480, 1779, - /* 2000 */ 1841, 581, 1480, 1480, 290, 1810, 584, 1812, 1813, 580, - /* 2010 */ 1809, 575, 1480, 1480, 1480, 1480, 1480, 1480, 1480, 1480, - /* 2020 */ 1480, 1480, 1480, 1480, 1841, 1480, 1480, 1480, 282, 1810, - /* 2030 */ 584, 1812, 1813, 580, 1809, 575, 1480, 1480, 1827, 1480, - /* 2040 */ 1480, 1480, 1480, 1480, 1480, 1480, 582, 1480, 1480, 1480, - /* 2050 */ 1480, 1779, 1480, 581, 1480, 1480, 1480, 1480, 1809, 1480, - /* 2060 */ 1480, 1480, 1827, 1480, 1480, 1480, 1480, 1480, 1480, 1480, - /* 2070 */ 582, 1480, 1480, 1480, 1809, 1779, 1841, 581, 1480, 1480, - /* 2080 */ 291, 1810, 584, 1812, 1813, 580, 1827, 575, 1480, 1480, - /* 2090 */ 1480, 1480, 1480, 1480, 582, 1480, 1480, 1480, 1480, 1779, - /* 2100 */ 1841, 581, 1827, 1480, 283, 1810, 584, 1812, 1813, 580, - /* 2110 */ 582, 575, 1480, 1480, 1480, 1779, 1480, 581, 1480, 1480, - /* 2120 */ 1480, 1480, 1480, 1480, 1841, 1480, 1480, 1480, 292, 1810, - /* 2130 */ 584, 1812, 1813, 580, 1480, 575, 1480, 1480, 1480, 1480, - /* 2140 */ 1841, 1480, 1480, 1480, 284, 1810, 584, 1812, 1813, 580, - /* 2150 */ 1480, 575, 1809, 1480, 1480, 1480, 1480, 1480, 1480, 1480, - /* 2160 */ 1480, 1480, 1480, 1480, 1480, 1480, 1480, 1480, 1480, 1480, - /* 2170 */ 1480, 1480, 1480, 1480, 1480, 1480, 1480, 1480, 1480, 1480, - /* 2180 */ 1827, 1480, 1480, 1480, 1480, 1480, 1480, 1480, 582, 1480, - /* 2190 */ 1480, 1480, 1480, 1779, 1480, 581, 1480, 1480, 1480, 1480, - /* 2200 */ 1480, 1480, 1480, 1809, 1480, 1480, 1480, 1480, 1480, 1480, - /* 2210 */ 1480, 1480, 1480, 1809, 1480, 1480, 1480, 1480, 1841, 1480, - /* 2220 */ 1480, 1480, 297, 1810, 584, 1812, 1813, 580, 1480, 575, - /* 2230 */ 1480, 1827, 1480, 1480, 1480, 1480, 1480, 1480, 1480, 582, - /* 2240 */ 1480, 1827, 1480, 1480, 1779, 1480, 581, 1480, 1480, 582, - /* 2250 */ 1480, 1480, 1480, 1480, 1779, 1480, 581, 1480, 1480, 1480, - /* 2260 */ 1480, 1480, 1480, 1480, 1480, 1480, 1809, 1480, 1480, 1841, - /* 2270 */ 1480, 1480, 1480, 298, 1810, 584, 1812, 1813, 580, 1841, - /* 2280 */ 575, 1480, 1809, 1821, 1810, 584, 1812, 1813, 580, 1480, - /* 2290 */ 575, 1480, 1480, 1480, 1827, 1480, 1480, 1480, 1480, 1480, - /* 2300 */ 1480, 1480, 582, 1480, 1480, 1480, 1809, 1779, 1480, 581, - /* 2310 */ 1827, 1480, 1480, 1480, 1480, 1480, 1480, 1480, 582, 1480, - /* 2320 */ 1480, 1480, 1809, 1779, 1480, 581, 1480, 1480, 1480, 1480, - /* 2330 */ 1480, 1480, 1841, 1480, 1827, 1480, 1820, 1810, 584, 1812, - /* 2340 */ 1813, 580, 582, 575, 1480, 1480, 1809, 1779, 1841, 581, - /* 2350 */ 1827, 1480, 1819, 1810, 584, 1812, 1813, 580, 582, 575, - /* 2360 */ 1480, 1480, 1480, 1779, 1480, 581, 1480, 1480, 1480, 1480, - /* 2370 */ 1809, 1480, 1841, 1480, 1827, 1480, 310, 1810, 584, 1812, - /* 2380 */ 1813, 580, 582, 575, 1480, 1480, 1809, 1779, 1841, 581, - /* 2390 */ 1480, 1480, 309, 1810, 584, 1812, 1813, 580, 1827, 575, - /* 2400 */ 1480, 1480, 1480, 1480, 1480, 1480, 582, 1480, 1480, 1480, - /* 2410 */ 1480, 1779, 1841, 581, 1827, 1480, 311, 1810, 584, 1812, - /* 2420 */ 1813, 580, 582, 575, 1480, 1480, 1480, 1779, 1480, 581, - /* 2430 */ 1480, 1480, 1480, 1480, 1480, 1480, 1841, 1480, 1480, 1480, - /* 2440 */ 308, 1810, 584, 1812, 1813, 580, 1480, 575, 1480, 1480, - /* 2450 */ 1480, 1480, 1841, 1480, 1480, 1480, 287, 1810, 584, 1812, - /* 2460 */ 1813, 580, 1480, 575, + /* 0 */ 436, 1813, 437, 1519, 444, 345, 437, 1519, 1674, 1676, + /* 10 */ 33, 32, 39, 37, 40, 38, 36, 35, 34, 1620, + /* 20 */ 340, 530, 1281, 1801, 40, 38, 36, 35, 34, 1831, + /* 30 */ 1797, 1681, 117, 1357, 1797, 1279, 1770, 582, 312, 474, + /* 40 */ 30, 260, 1783, 1525, 581, 385, 148, 1679, 1496, 1629, + /* 50 */ 1035, 1813, 1034, 1801, 1793, 1799, 1352, 558, 1793, 1799, + /* 60 */ 329, 14, 1675, 1676, 1797, 472, 575, 1845, 1287, 1546, + /* 70 */ 575, 94, 1814, 584, 1816, 1817, 580, 1485, 575, 1831, + /* 80 */ 1036, 1891, 303, 362, 1802, 306, 1887, 582, 1793, 1799, + /* 90 */ 335, 666, 1783, 1, 581, 1797, 1451, 1957, 107, 1957, + /* 100 */ 575, 106, 105, 104, 103, 102, 101, 100, 99, 98, + /* 110 */ 166, 1681, 165, 1307, 1954, 671, 1954, 1845, 328, 1793, + /* 120 */ 1799, 149, 1814, 584, 1816, 1817, 580, 1679, 575, 1359, + /* 130 */ 1360, 575, 648, 647, 646, 645, 350, 1607, 644, 643, + /* 140 */ 128, 638, 637, 636, 635, 634, 633, 632, 631, 139, + /* 150 */ 627, 626, 625, 349, 348, 622, 621, 620, 619, 618, + /* 160 */ 36, 35, 34, 33, 32, 559, 1971, 40, 38, 36, + /* 170 */ 35, 34, 556, 556, 1306, 1282, 556, 1280, 1136, 606, + /* 180 */ 605, 604, 1140, 603, 1142, 1143, 602, 1145, 599, 63, + /* 190 */ 1151, 596, 1153, 1154, 593, 590, 453, 453, 1285, 1286, + /* 200 */ 553, 1334, 1335, 1337, 1338, 1339, 1340, 1341, 1342, 577, + /* 210 */ 573, 1350, 1351, 1353, 1354, 1355, 1356, 1358, 1361, 39, + /* 220 */ 37, 1420, 1178, 1179, 1307, 1831, 500, 340, 127, 1281, + /* 230 */ 33, 32, 167, 546, 40, 38, 36, 35, 34, 498, + /* 240 */ 1357, 496, 1279, 486, 485, 43, 42, 63, 558, 107, + /* 250 */ 123, 379, 106, 105, 104, 103, 102, 101, 100, 99, + /* 260 */ 98, 481, 484, 1352, 491, 22, 125, 480, 14, 545, + /* 270 */ 378, 84, 377, 1018, 1813, 1287, 39, 37, 530, 501, + /* 280 */ 1417, 250, 1899, 552, 340, 551, 1281, 478, 1957, 117, + /* 290 */ 1813, 1957, 1622, 209, 7, 327, 479, 1357, 1507, 1279, + /* 300 */ 2, 166, 1831, 146, 164, 1954, 1629, 494, 1954, 477, + /* 310 */ 582, 488, 1631, 1022, 1023, 1783, 208, 581, 1831, 150, + /* 320 */ 1352, 1957, 671, 1588, 435, 14, 579, 439, 167, 1441, + /* 330 */ 558, 1783, 1287, 581, 1956, 422, 1359, 1360, 1954, 1783, + /* 340 */ 1845, 135, 173, 517, 94, 1814, 584, 1816, 1817, 580, + /* 350 */ 326, 575, 58, 1729, 1891, 57, 1845, 2, 306, 1887, + /* 360 */ 293, 1814, 584, 1816, 1817, 580, 578, 575, 572, 1863, + /* 370 */ 1957, 1484, 539, 1439, 1440, 1442, 1443, 222, 71, 671, + /* 380 */ 146, 70, 1282, 164, 1280, 167, 167, 1954, 1506, 1632, + /* 390 */ 177, 176, 54, 1359, 1360, 116, 115, 114, 113, 112, + /* 400 */ 111, 110, 109, 108, 63, 1285, 1286, 1098, 1334, 1335, + /* 410 */ 1337, 1338, 1339, 1340, 1341, 1342, 577, 573, 1350, 1351, + /* 420 */ 1353, 1354, 1355, 1356, 1358, 1361, 33, 32, 1681, 1783, + /* 430 */ 40, 38, 36, 35, 34, 344, 26, 1261, 1262, 1282, + /* 440 */ 1100, 1280, 33, 32, 1679, 28, 40, 38, 36, 35, + /* 450 */ 34, 33, 32, 217, 562, 40, 38, 36, 35, 34, + /* 460 */ 1813, 317, 1285, 1286, 542, 1334, 1335, 1337, 1338, 1339, + /* 470 */ 1340, 1341, 1342, 577, 573, 1350, 1351, 1353, 1354, 1355, + /* 480 */ 1356, 1358, 1361, 39, 37, 302, 1413, 1304, 1831, 530, + /* 490 */ 63, 340, 78, 1281, 415, 210, 557, 427, 223, 224, + /* 500 */ 55, 1783, 1957, 581, 1357, 1308, 1279, 441, 516, 1416, + /* 510 */ 353, 1957, 1431, 1304, 400, 165, 428, 1629, 402, 1954, + /* 520 */ 318, 49, 316, 315, 1955, 476, 1845, 1352, 1954, 478, + /* 530 */ 95, 1814, 584, 1816, 1817, 580, 1722, 575, 1306, 1287, + /* 540 */ 1891, 548, 543, 167, 331, 1887, 159, 172, 1957, 1281, + /* 550 */ 1957, 477, 76, 305, 674, 64, 520, 305, 163, 393, + /* 560 */ 520, 164, 1279, 164, 8, 1954, 1917, 1954, 267, 553, + /* 570 */ 547, 389, 158, 33, 32, 343, 346, 40, 38, 36, + /* 580 */ 35, 34, 156, 146, 146, 1668, 671, 664, 660, 656, + /* 590 */ 652, 265, 1631, 1631, 1482, 1287, 1035, 127, 1034, 426, + /* 600 */ 1359, 1360, 421, 420, 419, 418, 417, 414, 413, 412, + /* 610 */ 411, 410, 406, 405, 404, 403, 397, 396, 395, 394, + /* 620 */ 1505, 391, 390, 314, 617, 1424, 1036, 92, 1367, 167, + /* 630 */ 230, 1306, 33, 32, 1306, 125, 40, 38, 36, 35, + /* 640 */ 34, 1305, 671, 1381, 63, 615, 1282, 252, 1280, 555, + /* 650 */ 160, 1899, 1900, 355, 1904, 352, 11, 10, 483, 482, + /* 660 */ 167, 1783, 563, 527, 137, 136, 612, 611, 610, 1285, + /* 670 */ 1286, 1732, 1334, 1335, 1337, 1338, 1339, 1340, 1341, 1342, + /* 680 */ 577, 573, 1350, 1351, 1353, 1354, 1355, 1356, 1358, 1361, + /* 690 */ 39, 37, 1362, 1957, 1287, 1957, 219, 502, 340, 374, + /* 700 */ 1281, 74, 1282, 167, 1280, 27, 164, 74, 164, 91, + /* 710 */ 1954, 1357, 1954, 1279, 1255, 1386, 212, 1504, 376, 372, + /* 720 */ 122, 1605, 124, 1625, 1813, 1285, 1286, 1722, 1503, 1624, + /* 730 */ 1621, 1502, 1477, 530, 1352, 33, 32, 1957, 175, 40, + /* 740 */ 38, 36, 35, 34, 169, 530, 1287, 39, 37, 1393, + /* 750 */ 164, 530, 1831, 1549, 1954, 340, 383, 1281, 1783, 1501, + /* 760 */ 582, 1629, 384, 443, 553, 1783, 439, 581, 1357, 1783, + /* 770 */ 1279, 9, 1783, 1629, 530, 642, 640, 517, 530, 1629, + /* 780 */ 558, 617, 61, 167, 1306, 392, 145, 1730, 1500, 407, + /* 790 */ 1845, 1352, 127, 671, 285, 1814, 584, 1816, 1817, 580, + /* 800 */ 1783, 575, 1629, 1287, 337, 336, 1629, 1359, 1360, 609, + /* 810 */ 1499, 530, 530, 1336, 1295, 530, 1336, 486, 485, 1476, + /* 820 */ 1957, 1319, 408, 451, 123, 1357, 452, 1288, 9, 1783, + /* 830 */ 125, 530, 1498, 166, 1495, 481, 484, 1954, 629, 1629, + /* 840 */ 1629, 480, 1626, 1629, 1309, 161, 1899, 1900, 1352, 1904, + /* 850 */ 671, 1783, 1728, 1282, 300, 1280, 630, 1618, 1601, 1629, + /* 860 */ 1287, 90, 33, 32, 1359, 1360, 40, 38, 36, 35, + /* 870 */ 34, 87, 1727, 1783, 300, 1783, 1285, 1286, 1494, 1334, + /* 880 */ 1335, 1337, 1338, 1339, 1340, 1341, 1342, 577, 573, 1350, + /* 890 */ 1351, 1353, 1354, 1355, 1356, 1358, 1361, 530, 530, 553, + /* 900 */ 530, 201, 530, 530, 199, 1906, 509, 570, 347, 503, + /* 910 */ 1282, 510, 1280, 514, 227, 307, 1614, 1493, 613, 1783, + /* 920 */ 1492, 1672, 1491, 1022, 1023, 1629, 1629, 127, 1629, 1903, + /* 930 */ 1629, 1629, 1490, 1285, 1286, 1489, 1334, 1335, 1337, 1338, + /* 940 */ 1339, 1340, 1341, 1342, 577, 573, 1350, 1351, 1353, 1354, + /* 950 */ 1355, 1356, 1358, 1361, 39, 37, 1379, 530, 1783, 530, + /* 960 */ 1616, 1783, 340, 1783, 1281, 125, 1336, 1296, 526, 1291, + /* 970 */ 528, 1911, 1413, 1783, 196, 1357, 1783, 1279, 1488, 1487, + /* 980 */ 162, 1899, 1900, 1606, 1904, 1629, 232, 1629, 152, 1813, + /* 990 */ 1299, 1301, 1906, 470, 466, 462, 458, 195, 1352, 1681, + /* 1000 */ 44, 4, 573, 1350, 1351, 1353, 1354, 1355, 1356, 1604, + /* 1010 */ 1287, 1380, 530, 530, 386, 1680, 1902, 1831, 614, 1783, + /* 1020 */ 1783, 1672, 324, 529, 261, 582, 1906, 387, 560, 147, + /* 1030 */ 1783, 565, 581, 75, 278, 2, 193, 571, 33, 32, + /* 1040 */ 1629, 1629, 40, 38, 36, 35, 34, 41, 276, 60, + /* 1050 */ 1901, 272, 59, 203, 1659, 1845, 202, 671, 216, 294, + /* 1060 */ 1814, 584, 1816, 1817, 580, 221, 575, 131, 180, 432, + /* 1070 */ 430, 1359, 1360, 29, 338, 1374, 1375, 1376, 1377, 1378, + /* 1080 */ 1382, 1383, 1384, 1385, 205, 1290, 207, 204, 615, 206, + /* 1090 */ 1536, 307, 53, 513, 11, 10, 1289, 77, 1232, 192, + /* 1100 */ 186, 1531, 191, 1529, 63, 1589, 449, 137, 136, 612, + /* 1110 */ 611, 610, 487, 134, 615, 135, 225, 1282, 523, 1280, + /* 1120 */ 51, 236, 184, 489, 1319, 492, 1479, 1480, 1804, 1612, + /* 1130 */ 51, 41, 1379, 137, 136, 612, 611, 610, 41, 588, + /* 1140 */ 1285, 1286, 93, 1334, 1335, 1337, 1338, 1339, 1340, 1341, + /* 1150 */ 1342, 577, 573, 1350, 1351, 1353, 1354, 1355, 1356, 1358, + /* 1160 */ 1361, 134, 135, 119, 229, 134, 1129, 1062, 213, 623, + /* 1170 */ 624, 1438, 239, 576, 1371, 1806, 608, 1497, 68, 67, + /* 1180 */ 382, 1387, 1343, 171, 255, 540, 471, 1380, 244, 271, + /* 1190 */ 1157, 1082, 1080, 1832, 1813, 351, 1520, 1669, 1921, 301, + /* 1200 */ 1063, 554, 370, 254, 368, 364, 360, 357, 354, 249, + /* 1210 */ 3, 257, 1161, 1168, 1166, 259, 138, 356, 5, 361, + /* 1220 */ 1248, 313, 1831, 174, 1304, 268, 388, 1293, 409, 1724, + /* 1230 */ 557, 416, 424, 423, 425, 1783, 429, 581, 1292, 431, + /* 1240 */ 433, 566, 1310, 167, 1312, 434, 442, 1813, 183, 29, + /* 1250 */ 338, 1374, 1375, 1376, 1377, 1378, 1382, 1383, 1384, 1385, + /* 1260 */ 1845, 445, 446, 185, 95, 1814, 584, 1816, 1817, 580, + /* 1270 */ 1311, 575, 447, 1313, 1891, 1831, 188, 450, 331, 1887, + /* 1280 */ 159, 448, 473, 582, 190, 72, 73, 1813, 1783, 454, + /* 1290 */ 581, 194, 269, 475, 1619, 198, 304, 1615, 118, 200, + /* 1300 */ 1918, 1763, 211, 140, 141, 1617, 1613, 504, 214, 505, + /* 1310 */ 142, 1813, 143, 1845, 511, 1831, 515, 95, 1814, 584, + /* 1320 */ 1816, 1817, 580, 582, 575, 218, 508, 1891, 1783, 524, + /* 1330 */ 581, 331, 1887, 1970, 518, 81, 538, 132, 1762, 1831, + /* 1340 */ 323, 83, 1925, 1734, 521, 1309, 270, 582, 325, 1630, + /* 1350 */ 541, 1813, 1783, 1845, 581, 6, 133, 279, 1814, 584, + /* 1360 */ 1816, 1817, 580, 1932, 575, 534, 525, 536, 537, 234, + /* 1370 */ 238, 330, 550, 544, 535, 533, 532, 1845, 1413, 1831, + /* 1380 */ 126, 95, 1814, 584, 1816, 1817, 580, 582, 575, 1922, + /* 1390 */ 245, 1891, 1783, 1931, 581, 331, 1887, 1970, 567, 1308, + /* 1400 */ 564, 248, 48, 332, 1813, 85, 1948, 1907, 586, 1673, + /* 1410 */ 1602, 273, 667, 52, 668, 1913, 243, 1845, 670, 299, + /* 1420 */ 264, 95, 1814, 584, 1816, 1817, 580, 277, 575, 246, + /* 1430 */ 153, 1891, 1831, 1872, 247, 331, 1887, 1970, 275, 286, + /* 1440 */ 582, 296, 295, 1777, 253, 1783, 1910, 581, 1776, 1775, + /* 1450 */ 1953, 65, 1774, 561, 1813, 568, 256, 1973, 258, 66, + /* 1460 */ 558, 1771, 358, 359, 1273, 1274, 170, 363, 1769, 365, + /* 1470 */ 1845, 1813, 366, 367, 285, 1814, 584, 1816, 1817, 580, + /* 1480 */ 1768, 575, 1831, 369, 1767, 371, 1766, 373, 1765, 375, + /* 1490 */ 582, 1251, 1250, 1745, 1744, 1783, 381, 581, 380, 1831, + /* 1500 */ 1957, 1743, 1742, 1220, 1717, 1716, 1715, 582, 129, 1714, + /* 1510 */ 1713, 1712, 1783, 164, 581, 69, 1711, 1954, 1710, 1709, + /* 1520 */ 1845, 1813, 398, 1706, 96, 1814, 584, 1816, 1817, 580, + /* 1530 */ 1708, 575, 1707, 399, 1891, 401, 1705, 1845, 1890, 1887, + /* 1540 */ 1704, 96, 1814, 584, 1816, 1817, 580, 1703, 575, 1831, + /* 1550 */ 1702, 1891, 1701, 1700, 1699, 569, 1887, 582, 1698, 1697, + /* 1560 */ 1696, 1695, 1783, 1694, 581, 1693, 1692, 130, 1691, 1813, + /* 1570 */ 1690, 1689, 1688, 1687, 1686, 1685, 1684, 1222, 1683, 1813, + /* 1580 */ 178, 1550, 179, 1548, 1516, 181, 182, 1845, 1682, 1551, + /* 1590 */ 120, 96, 1814, 584, 1816, 1817, 580, 1831, 575, 157, + /* 1600 */ 1025, 1891, 531, 438, 1024, 582, 1888, 1831, 440, 1515, + /* 1610 */ 1783, 1758, 581, 1752, 1741, 582, 121, 189, 187, 1740, + /* 1620 */ 1783, 1726, 581, 1608, 1547, 1545, 1055, 1543, 455, 456, + /* 1630 */ 1813, 459, 460, 457, 461, 1845, 1541, 463, 464, 294, + /* 1640 */ 1814, 584, 1816, 1817, 580, 1845, 575, 465, 1539, 289, + /* 1650 */ 1814, 584, 1816, 1817, 580, 467, 575, 468, 1831, 1171, + /* 1660 */ 1609, 469, 1528, 1527, 1512, 1610, 582, 1172, 1097, 50, + /* 1670 */ 1096, 1783, 639, 581, 641, 1093, 1092, 1091, 1537, 319, + /* 1680 */ 1532, 1530, 493, 320, 1511, 495, 1510, 549, 490, 321, + /* 1690 */ 1813, 497, 1509, 499, 97, 1757, 1845, 197, 1751, 56, + /* 1700 */ 149, 1814, 584, 1816, 1817, 580, 144, 575, 1813, 506, + /* 1710 */ 1257, 507, 1739, 1737, 1738, 1736, 1735, 1265, 1831, 15, + /* 1720 */ 519, 1733, 220, 226, 1725, 231, 579, 79, 215, 80, + /* 1730 */ 45, 1783, 41, 581, 47, 82, 1831, 23, 233, 16, + /* 1740 */ 1453, 339, 241, 235, 582, 1972, 87, 522, 1435, 1783, + /* 1750 */ 242, 581, 1437, 1804, 25, 1465, 1845, 228, 1813, 237, + /* 1760 */ 293, 1814, 584, 1816, 1817, 580, 322, 575, 251, 1864, + /* 1770 */ 512, 1430, 46, 1803, 1845, 17, 151, 154, 294, 1814, + /* 1780 */ 584, 1816, 1817, 580, 1813, 575, 1831, 240, 18, 24, + /* 1790 */ 86, 341, 1464, 333, 582, 1410, 1409, 1470, 1469, 1783, + /* 1800 */ 1459, 581, 1468, 334, 10, 1297, 155, 19, 1813, 1327, + /* 1810 */ 1372, 1848, 1831, 587, 585, 168, 583, 1347, 574, 31, + /* 1820 */ 582, 342, 1345, 12, 1845, 1783, 1344, 581, 294, 1814, + /* 1830 */ 584, 1816, 1817, 580, 1813, 575, 1831, 13, 1158, 20, + /* 1840 */ 21, 589, 591, 1155, 582, 592, 594, 1152, 595, 1783, + /* 1850 */ 1845, 581, 597, 600, 280, 1814, 584, 1816, 1817, 580, + /* 1860 */ 1146, 575, 1831, 598, 1135, 1144, 601, 1150, 1149, 88, + /* 1870 */ 582, 1148, 1167, 1147, 1845, 1783, 262, 581, 281, 1814, + /* 1880 */ 584, 1816, 1817, 580, 607, 575, 89, 62, 1163, 1053, + /* 1890 */ 616, 1088, 1813, 1087, 1086, 1085, 1084, 1083, 1081, 1079, + /* 1900 */ 1845, 628, 1078, 1077, 288, 1814, 584, 1816, 1817, 580, + /* 1910 */ 1813, 575, 553, 1104, 263, 1075, 1074, 1073, 1072, 1071, + /* 1920 */ 1831, 1070, 1069, 1068, 1099, 1101, 1065, 1064, 582, 1061, + /* 1930 */ 1059, 1060, 1544, 1783, 1058, 581, 649, 650, 1831, 651, + /* 1940 */ 127, 1542, 653, 655, 1540, 654, 582, 657, 659, 658, + /* 1950 */ 1538, 1783, 661, 581, 663, 1526, 1508, 662, 1845, 665, + /* 1960 */ 558, 1015, 290, 1814, 584, 1816, 1817, 580, 266, 575, + /* 1970 */ 669, 1813, 1483, 1283, 274, 672, 1845, 673, 125, 1483, + /* 1980 */ 282, 1814, 584, 1816, 1817, 580, 1483, 575, 1483, 1483, + /* 1990 */ 1483, 1483, 1483, 250, 1899, 552, 1483, 551, 1483, 1831, + /* 2000 */ 1957, 1483, 1483, 1483, 1483, 1483, 1483, 582, 1483, 1483, + /* 2010 */ 1483, 1483, 1783, 164, 581, 1483, 1483, 1954, 1483, 1483, + /* 2020 */ 1483, 1813, 1483, 1483, 1483, 1483, 1483, 1483, 1483, 1483, + /* 2030 */ 1483, 1813, 1483, 1483, 1483, 1483, 1483, 1845, 1483, 1483, + /* 2040 */ 1483, 291, 1814, 584, 1816, 1817, 580, 1483, 575, 1831, + /* 2050 */ 1483, 1483, 1483, 1483, 1483, 1483, 1483, 582, 1483, 1831, + /* 2060 */ 1483, 1483, 1783, 1483, 581, 1483, 1483, 582, 1483, 1483, + /* 2070 */ 1483, 1813, 1783, 1483, 581, 1483, 1483, 1483, 1483, 1483, + /* 2080 */ 1483, 1483, 1483, 1483, 1483, 1483, 1483, 1845, 1483, 1483, + /* 2090 */ 1483, 283, 1814, 584, 1816, 1817, 580, 1845, 575, 1831, + /* 2100 */ 1483, 292, 1814, 584, 1816, 1817, 580, 582, 575, 1483, + /* 2110 */ 1483, 1483, 1783, 1483, 581, 1483, 1483, 1483, 1483, 1483, + /* 2120 */ 1483, 1813, 1483, 1483, 1483, 1483, 1483, 1483, 1483, 1483, + /* 2130 */ 1483, 1483, 1483, 1813, 1483, 1483, 1483, 1845, 1483, 1483, + /* 2140 */ 1483, 284, 1814, 584, 1816, 1817, 580, 1813, 575, 1831, + /* 2150 */ 1483, 1483, 1483, 1483, 1483, 1483, 1483, 582, 1483, 1483, + /* 2160 */ 1483, 1831, 1783, 1483, 581, 1483, 1483, 1483, 1483, 582, + /* 2170 */ 1483, 1483, 1483, 1483, 1783, 1831, 581, 1483, 1483, 1483, + /* 2180 */ 1483, 1483, 1483, 582, 1483, 1483, 1483, 1845, 1783, 1483, + /* 2190 */ 581, 297, 1814, 584, 1816, 1817, 580, 1483, 575, 1845, + /* 2200 */ 1483, 1483, 1483, 298, 1814, 584, 1816, 1817, 580, 1483, + /* 2210 */ 575, 1483, 1483, 1845, 1483, 1483, 1483, 1825, 1814, 584, + /* 2220 */ 1816, 1817, 580, 1813, 575, 1483, 1483, 1483, 1483, 1483, + /* 2230 */ 1483, 1483, 1483, 1813, 1483, 1483, 1483, 1483, 1483, 1483, + /* 2240 */ 1483, 1483, 1483, 1483, 1483, 1483, 1483, 1483, 1483, 1483, + /* 2250 */ 1483, 1831, 1483, 1483, 1483, 1483, 1483, 1483, 1483, 582, + /* 2260 */ 1483, 1831, 1483, 1483, 1783, 1483, 581, 1483, 1483, 582, + /* 2270 */ 1483, 1483, 1483, 1483, 1783, 1483, 581, 1483, 1483, 1483, + /* 2280 */ 1483, 1483, 1483, 1483, 1813, 1483, 1483, 1483, 1483, 1845, + /* 2290 */ 1483, 1483, 1483, 1824, 1814, 584, 1816, 1817, 580, 1845, + /* 2300 */ 575, 1483, 1483, 1823, 1814, 584, 1816, 1817, 580, 1483, + /* 2310 */ 575, 1483, 1831, 1483, 1483, 1483, 1483, 1483, 1483, 1483, + /* 2320 */ 582, 1483, 1483, 1483, 1483, 1783, 1483, 581, 1483, 1483, + /* 2330 */ 1483, 1483, 1483, 1483, 1813, 1483, 1483, 1483, 1483, 1483, + /* 2340 */ 1483, 1483, 1483, 1483, 1813, 1483, 1483, 1483, 1483, 1483, + /* 2350 */ 1845, 1483, 1483, 1483, 310, 1814, 584, 1816, 1817, 580, + /* 2360 */ 1483, 575, 1831, 1483, 1483, 1483, 1483, 1483, 1483, 1483, + /* 2370 */ 582, 1483, 1831, 1483, 1483, 1783, 1483, 581, 1483, 1483, + /* 2380 */ 582, 1483, 1483, 1483, 1813, 1783, 1483, 581, 1483, 1483, + /* 2390 */ 1483, 1483, 1483, 1483, 1483, 1483, 1483, 1483, 1483, 1483, + /* 2400 */ 1845, 1483, 1483, 1483, 309, 1814, 584, 1816, 1817, 580, + /* 2410 */ 1845, 575, 1831, 1483, 311, 1814, 584, 1816, 1817, 580, + /* 2420 */ 582, 575, 1483, 1483, 1483, 1783, 1483, 581, 1483, 1483, + /* 2430 */ 1483, 1483, 1483, 1483, 1813, 1483, 1483, 1483, 1483, 1483, + /* 2440 */ 1483, 1483, 1483, 1483, 1483, 1483, 1483, 1483, 1483, 1483, + /* 2450 */ 1845, 1483, 1483, 1483, 308, 1814, 584, 1816, 1817, 580, + /* 2460 */ 1483, 575, 1831, 1483, 1483, 1483, 1483, 1483, 1483, 1483, + /* 2470 */ 582, 1483, 1483, 1483, 1483, 1783, 1483, 581, 1483, 1483, + /* 2480 */ 1483, 1483, 1483, 1483, 1483, 1483, 1483, 1483, 1483, 1483, + /* 2490 */ 1483, 1483, 1483, 1483, 1483, 1483, 1483, 1483, 1483, 1483, + /* 2500 */ 1845, 1483, 1483, 1483, 287, 1814, 584, 1816, 1817, 580, + /* 2510 */ 1483, 575, }; static const YYCODETYPE yy_lookahead[] = { - /* 0 */ 315, 367, 317, 318, 311, 321, 367, 315, 341, 317, - /* 10 */ 318, 340, 12, 13, 319, 4, 392, 393, 334, 352, - /* 20 */ 20, 407, 22, 8, 9, 4, 342, 12, 13, 14, - /* 30 */ 15, 16, 339, 33, 420, 35, 319, 310, 424, 312, - /* 40 */ 347, 407, 347, 376, 377, 352, 407, 354, 12, 13, - /* 50 */ 14, 15, 16, 20, 420, 388, 56, 354, 424, 420, - /* 60 */ 367, 61, 367, 424, 361, 44, 45, 364, 68, 0, - /* 70 */ 377, 20, 323, 356, 381, 382, 383, 384, 385, 386, - /* 80 */ 385, 388, 311, 56, 391, 336, 56, 350, 395, 396, - /* 90 */ 353, 354, 92, 20, 345, 400, 401, 402, 92, 404, - /* 100 */ 407, 21, 407, 92, 24, 25, 26, 27, 28, 29, - /* 110 */ 30, 31, 32, 420, 114, 420, 60, 424, 91, 424, - /* 120 */ 14, 94, 92, 352, 94, 92, 20, 20, 128, 129, - /* 130 */ 1, 2, 63, 64, 65, 66, 67, 311, 69, 70, + /* 0 */ 316, 312, 318, 319, 316, 351, 318, 319, 354, 355, + /* 10 */ 8, 9, 12, 13, 12, 13, 14, 15, 16, 342, + /* 20 */ 20, 320, 22, 342, 12, 13, 14, 15, 16, 340, + /* 30 */ 353, 340, 331, 33, 353, 35, 0, 348, 347, 338, + /* 40 */ 393, 394, 353, 0, 355, 320, 311, 356, 313, 348, + /* 50 */ 20, 312, 22, 342, 377, 378, 56, 368, 377, 378, + /* 60 */ 379, 61, 354, 355, 353, 35, 389, 378, 68, 0, + /* 70 */ 389, 382, 383, 384, 385, 386, 387, 0, 389, 340, + /* 80 */ 50, 392, 357, 47, 342, 396, 397, 348, 377, 378, + /* 90 */ 379, 48, 353, 93, 355, 353, 94, 408, 21, 408, + /* 100 */ 389, 24, 25, 26, 27, 28, 29, 30, 31, 32, + /* 110 */ 421, 340, 421, 20, 425, 115, 425, 378, 347, 377, + /* 120 */ 378, 382, 383, 384, 385, 386, 387, 356, 389, 129, + /* 130 */ 130, 389, 63, 64, 65, 66, 67, 0, 69, 70, /* 140 */ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, - /* 150 */ 81, 82, 83, 84, 85, 86, 87, 88, 89, 319, - /* 160 */ 21, 8, 9, 33, 0, 12, 13, 14, 15, 16, - /* 170 */ 330, 123, 124, 34, 174, 36, 176, 47, 352, 128, - /* 180 */ 129, 166, 52, 53, 54, 55, 56, 347, 24, 25, - /* 190 */ 26, 27, 28, 29, 30, 31, 32, 197, 198, 92, - /* 200 */ 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - /* 210 */ 210, 211, 212, 213, 214, 215, 216, 217, 12, 13, - /* 220 */ 14, 91, 93, 18, 94, 20, 20, 321, 22, 311, - /* 230 */ 182, 231, 27, 185, 407, 30, 367, 231, 319, 33, - /* 240 */ 159, 35, 231, 339, 341, 319, 93, 420, 342, 330, - /* 250 */ 346, 424, 47, 339, 49, 352, 51, 339, 407, 355, - /* 260 */ 346, 231, 56, 20, 231, 347, 347, 61, 253, 355, - /* 270 */ 352, 420, 354, 347, 68, 424, 407, 8, 9, 376, - /* 280 */ 377, 12, 13, 14, 15, 16, 341, 157, 158, 420, - /* 290 */ 160, 388, 92, 424, 164, 377, 91, 352, 92, 381, - /* 300 */ 382, 383, 384, 385, 386, 20, 388, 201, 103, 391, - /* 310 */ 180, 385, 43, 395, 396, 397, 20, 236, 237, 338, - /* 320 */ 114, 376, 377, 378, 406, 399, 400, 401, 402, 363, - /* 330 */ 404, 365, 351, 388, 128, 129, 131, 308, 231, 134, - /* 340 */ 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - /* 350 */ 145, 146, 147, 148, 149, 150, 151, 0, 153, 154, - /* 360 */ 155, 379, 105, 106, 107, 108, 109, 110, 111, 112, - /* 370 */ 113, 114, 115, 319, 117, 118, 119, 120, 121, 122, - /* 380 */ 174, 331, 176, 37, 330, 403, 8, 9, 92, 339, - /* 390 */ 12, 13, 14, 15, 16, 324, 367, 20, 348, 328, - /* 400 */ 20, 347, 22, 197, 198, 48, 200, 201, 202, 203, - /* 410 */ 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - /* 420 */ 214, 215, 216, 217, 12, 13, 311, 4, 353, 354, - /* 430 */ 50, 231, 20, 363, 22, 365, 407, 20, 14, 15, - /* 440 */ 16, 95, 19, 97, 98, 33, 100, 35, 339, 420, - /* 450 */ 104, 20, 123, 424, 339, 346, 33, 0, 64, 65, - /* 460 */ 14, 0, 347, 60, 355, 71, 20, 352, 56, 354, - /* 470 */ 47, 93, 126, 61, 51, 81, 82, 2, 331, 56, - /* 480 */ 68, 87, 367, 8, 9, 331, 339, 12, 13, 14, - /* 490 */ 15, 16, 377, 339, 39, 348, 381, 382, 383, 384, - /* 500 */ 385, 386, 348, 388, 92, 103, 391, 156, 319, 319, - /* 510 */ 395, 396, 183, 184, 91, 316, 407, 94, 319, 311, - /* 520 */ 330, 60, 407, 18, 339, 92, 114, 337, 23, 420, - /* 530 */ 311, 311, 347, 424, 169, 420, 347, 347, 2, 424, - /* 540 */ 128, 129, 37, 38, 8, 9, 41, 68, 12, 13, - /* 550 */ 14, 15, 16, 188, 189, 12, 13, 311, 339, 319, - /* 560 */ 352, 104, 57, 58, 59, 22, 347, 0, 383, 218, - /* 570 */ 330, 352, 352, 354, 385, 354, 33, 337, 35, 228, - /* 580 */ 123, 124, 125, 126, 127, 364, 174, 347, 176, 400, - /* 590 */ 401, 402, 161, 404, 68, 311, 377, 92, 352, 56, - /* 600 */ 381, 382, 383, 384, 385, 386, 173, 388, 175, 197, - /* 610 */ 198, 68, 200, 201, 202, 203, 204, 205, 206, 207, - /* 620 */ 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - /* 630 */ 12, 13, 379, 22, 311, 130, 352, 311, 20, 327, - /* 640 */ 22, 329, 14, 0, 425, 426, 35, 201, 20, 340, - /* 650 */ 20, 33, 22, 35, 8, 9, 403, 114, 12, 13, - /* 660 */ 14, 15, 16, 0, 231, 35, 316, 367, 340, 319, - /* 670 */ 311, 166, 167, 168, 56, 352, 171, 340, 352, 68, - /* 680 */ 50, 124, 311, 8, 9, 230, 68, 12, 13, 14, - /* 690 */ 15, 16, 187, 319, 311, 190, 323, 192, 193, 194, - /* 700 */ 195, 196, 311, 60, 330, 44, 45, 407, 8, 9, - /* 710 */ 92, 352, 12, 13, 14, 15, 16, 174, 345, 176, - /* 720 */ 420, 347, 339, 352, 424, 114, 340, 64, 65, 311, - /* 730 */ 347, 311, 114, 367, 71, 352, 231, 354, 181, 182, - /* 740 */ 197, 198, 185, 352, 81, 82, 128, 129, 311, 35, - /* 750 */ 87, 379, 209, 210, 211, 212, 213, 214, 215, 197, - /* 760 */ 377, 61, 229, 230, 381, 382, 383, 384, 385, 386, - /* 770 */ 352, 388, 352, 407, 391, 403, 104, 347, 395, 396, - /* 780 */ 397, 4, 68, 325, 326, 174, 420, 176, 358, 352, - /* 790 */ 424, 104, 174, 93, 176, 123, 124, 125, 126, 127, - /* 800 */ 417, 101, 240, 241, 242, 243, 244, 161, 197, 198, - /* 810 */ 311, 311, 311, 126, 311, 197, 198, 20, 200, 201, - /* 820 */ 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, - /* 830 */ 212, 213, 214, 215, 216, 217, 12, 13, 14, 339, - /* 840 */ 0, 339, 77, 371, 20, 35, 22, 347, 311, 231, - /* 850 */ 348, 352, 352, 352, 354, 352, 156, 33, 311, 35, - /* 860 */ 339, 21, 347, 3, 24, 25, 26, 27, 28, 29, - /* 870 */ 30, 31, 32, 358, 325, 326, 355, 377, 68, 20, - /* 880 */ 56, 381, 382, 383, 384, 385, 386, 349, 388, 352, - /* 890 */ 352, 391, 68, 42, 43, 395, 396, 132, 133, 352, - /* 900 */ 349, 8, 9, 352, 341, 12, 13, 14, 15, 16, - /* 910 */ 332, 43, 340, 335, 311, 352, 92, 0, 218, 219, - /* 920 */ 220, 221, 222, 223, 224, 225, 226, 227, 228, 8, - /* 930 */ 9, 311, 319, 12, 13, 14, 15, 16, 114, 376, - /* 940 */ 377, 378, 339, 330, 43, 319, 340, 344, 0, 22, - /* 950 */ 347, 388, 128, 129, 61, 352, 330, 354, 161, 339, - /* 960 */ 347, 93, 35, 96, 47, 96, 99, 347, 99, 312, - /* 970 */ 22, 319, 352, 347, 354, 161, 162, 1, 2, 319, - /* 980 */ 377, 56, 330, 43, 381, 382, 383, 384, 385, 386, - /* 990 */ 330, 388, 319, 96, 101, 0, 99, 377, 174, 347, - /* 1000 */ 176, 381, 382, 383, 384, 385, 386, 347, 388, 232, - /* 1010 */ 96, 391, 43, 99, 93, 395, 396, 22, 427, 94, - /* 1020 */ 347, 197, 198, 0, 200, 201, 202, 203, 204, 205, - /* 1030 */ 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - /* 1040 */ 216, 217, 12, 13, 319, 22, 43, 328, 319, 156, - /* 1050 */ 20, 43, 22, 43, 19, 330, 319, 35, 385, 330, - /* 1060 */ 201, 320, 93, 33, 311, 35, 35, 330, 33, 128, - /* 1070 */ 129, 418, 347, 400, 401, 402, 347, 404, 61, 46, - /* 1080 */ 13, 43, 47, 43, 347, 92, 56, 52, 53, 54, - /* 1090 */ 55, 56, 339, 0, 414, 102, 93, 344, 68, 319, - /* 1100 */ 347, 93, 35, 93, 311, 352, 43, 354, 248, 339, - /* 1110 */ 330, 218, 219, 220, 221, 222, 223, 224, 225, 226, - /* 1120 */ 227, 228, 92, 43, 13, 92, 91, 347, 320, 94, - /* 1130 */ 377, 93, 339, 93, 381, 382, 383, 384, 385, 386, - /* 1140 */ 347, 388, 351, 43, 114, 352, 35, 354, 318, 43, - /* 1150 */ 43, 250, 319, 380, 319, 319, 93, 319, 128, 129, - /* 1160 */ 405, 43, 127, 330, 398, 330, 330, 421, 330, 421, - /* 1170 */ 377, 43, 421, 93, 381, 382, 383, 384, 385, 386, - /* 1180 */ 347, 388, 347, 347, 391, 347, 408, 233, 395, 396, - /* 1190 */ 397, 375, 252, 93, 47, 160, 374, 104, 176, 93, - /* 1200 */ 93, 319, 409, 43, 174, 43, 176, 176, 172, 42, - /* 1210 */ 417, 93, 330, 178, 197, 180, 123, 124, 125, 126, - /* 1220 */ 127, 93, 369, 359, 20, 319, 319, 197, 198, 347, - /* 1230 */ 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - /* 1240 */ 210, 211, 212, 213, 214, 215, 216, 217, 12, 13, - /* 1250 */ 311, 319, 319, 93, 359, 93, 20, 156, 22, 357, - /* 1260 */ 357, 319, 330, 330, 319, 319, 20, 20, 313, 33, - /* 1270 */ 313, 35, 373, 323, 354, 323, 20, 366, 339, 347, - /* 1280 */ 347, 20, 323, 368, 366, 323, 347, 323, 323, 319, - /* 1290 */ 323, 352, 56, 354, 313, 339, 319, 339, 313, 339, - /* 1300 */ 339, 352, 339, 373, 68, 339, 179, 339, 321, 372, - /* 1310 */ 311, 339, 339, 339, 339, 321, 377, 319, 321, 319, - /* 1320 */ 381, 382, 383, 384, 385, 386, 319, 388, 92, 238, - /* 1330 */ 391, 158, 354, 321, 395, 396, 397, 366, 339, 321, - /* 1340 */ 352, 362, 352, 352, 352, 406, 347, 20, 362, 360, - /* 1350 */ 114, 352, 347, 354, 347, 335, 352, 413, 352, 239, - /* 1360 */ 380, 352, 245, 362, 128, 129, 352, 352, 352, 416, - /* 1370 */ 165, 247, 246, 362, 367, 234, 377, 20, 230, 347, - /* 1380 */ 381, 382, 383, 384, 385, 386, 251, 388, 249, 92, - /* 1390 */ 391, 254, 385, 411, 395, 396, 397, 413, 415, 375, - /* 1400 */ 379, 92, 343, 352, 329, 406, 410, 400, 401, 402, - /* 1410 */ 174, 404, 176, 394, 407, 413, 319, 321, 36, 314, - /* 1420 */ 370, 313, 365, 333, 322, 412, 311, 420, 333, 0, - /* 1430 */ 309, 424, 333, 197, 198, 181, 200, 201, 202, 203, - /* 1440 */ 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - /* 1450 */ 214, 215, 216, 217, 339, 428, 0, 423, 0, 422, - /* 1460 */ 0, 422, 347, 42, 423, 423, 422, 352, 0, 354, - /* 1470 */ 191, 35, 35, 35, 35, 191, 0, 35, 35, 191, - /* 1480 */ 0, 191, 367, 0, 35, 0, 22, 311, 0, 35, - /* 1490 */ 176, 0, 377, 174, 0, 170, 381, 382, 383, 384, - /* 1500 */ 385, 386, 169, 388, 0, 0, 0, 46, 0, 0, - /* 1510 */ 0, 42, 0, 0, 152, 339, 0, 0, 0, 0, - /* 1520 */ 0, 147, 407, 347, 35, 0, 147, 0, 352, 0, - /* 1530 */ 354, 0, 0, 0, 0, 420, 0, 0, 0, 424, - /* 1540 */ 0, 0, 0, 367, 311, 0, 0, 0, 0, 42, - /* 1550 */ 0, 0, 0, 377, 56, 0, 56, 381, 382, 383, - /* 1560 */ 384, 385, 386, 0, 388, 22, 0, 0, 0, 0, - /* 1570 */ 311, 0, 339, 0, 0, 14, 46, 42, 39, 14, - /* 1580 */ 347, 0, 0, 407, 0, 352, 0, 354, 165, 0, - /* 1590 */ 0, 0, 43, 0, 0, 39, 420, 40, 339, 46, - /* 1600 */ 424, 39, 0, 0, 0, 35, 347, 47, 0, 0, - /* 1610 */ 377, 352, 35, 354, 381, 382, 383, 384, 385, 386, - /* 1620 */ 387, 388, 389, 390, 39, 47, 62, 39, 311, 0, - /* 1630 */ 35, 39, 35, 0, 47, 39, 377, 22, 0, 20, - /* 1640 */ 381, 382, 383, 384, 385, 386, 311, 388, 47, 35, - /* 1650 */ 391, 35, 35, 43, 43, 396, 339, 35, 99, 101, - /* 1660 */ 35, 22, 0, 22, 347, 0, 22, 49, 0, 352, - /* 1670 */ 22, 354, 35, 0, 339, 0, 0, 35, 35, 22, - /* 1680 */ 0, 35, 347, 161, 0, 22, 158, 352, 177, 354, - /* 1690 */ 0, 0, 0, 0, 377, 0, 311, 92, 381, 382, - /* 1700 */ 383, 384, 385, 386, 35, 388, 93, 186, 0, 0, - /* 1710 */ 39, 229, 377, 92, 102, 43, 381, 382, 383, 384, - /* 1720 */ 385, 386, 311, 388, 339, 46, 92, 92, 92, 43, - /* 1730 */ 235, 43, 347, 161, 235, 159, 419, 352, 163, 354, - /* 1740 */ 161, 35, 93, 92, 46, 93, 311, 93, 92, 46, - /* 1750 */ 339, 93, 92, 92, 43, 344, 157, 93, 347, 92, - /* 1760 */ 46, 426, 377, 352, 43, 354, 381, 382, 383, 384, - /* 1770 */ 385, 386, 46, 388, 339, 390, 93, 92, 46, 344, - /* 1780 */ 93, 43, 347, 35, 35, 35, 35, 352, 377, 354, - /* 1790 */ 93, 35, 381, 382, 383, 384, 385, 386, 93, 388, - /* 1800 */ 2, 22, 43, 197, 311, 92, 46, 46, 93, 92, - /* 1810 */ 22, 93, 377, 93, 92, 235, 381, 382, 383, 384, - /* 1820 */ 385, 386, 92, 388, 93, 92, 199, 92, 103, 35, - /* 1830 */ 35, 92, 339, 93, 35, 92, 35, 93, 92, 35, - /* 1840 */ 347, 35, 22, 116, 92, 352, 93, 354, 93, 92, - /* 1850 */ 116, 35, 116, 116, 92, 311, 92, 92, 104, 22, - /* 1860 */ 43, 35, 62, 61, 35, 311, 35, 35, 35, 35, - /* 1870 */ 377, 35, 90, 35, 381, 382, 383, 384, 385, 386, - /* 1880 */ 35, 388, 35, 339, 35, 43, 68, 35, 22, 35, - /* 1890 */ 22, 347, 35, 339, 35, 68, 352, 35, 354, 35, - /* 1900 */ 35, 347, 35, 22, 35, 35, 352, 0, 354, 35, - /* 1910 */ 47, 39, 0, 35, 39, 0, 39, 35, 311, 0, - /* 1920 */ 47, 377, 35, 47, 39, 381, 382, 383, 384, 385, - /* 1930 */ 386, 377, 388, 47, 311, 381, 382, 383, 384, 385, - /* 1940 */ 386, 0, 388, 35, 35, 0, 339, 22, 21, 429, - /* 1950 */ 22, 22, 21, 20, 347, 429, 429, 429, 311, 352, - /* 1960 */ 429, 354, 339, 429, 429, 429, 429, 429, 429, 429, - /* 1970 */ 347, 429, 429, 429, 429, 352, 429, 354, 429, 429, - /* 1980 */ 429, 429, 429, 429, 377, 429, 339, 429, 381, 382, - /* 1990 */ 383, 384, 385, 386, 347, 388, 429, 429, 429, 352, - /* 2000 */ 377, 354, 429, 429, 381, 382, 383, 384, 385, 386, - /* 2010 */ 311, 388, 429, 429, 429, 429, 429, 429, 429, 429, - /* 2020 */ 429, 429, 429, 429, 377, 429, 429, 429, 381, 382, - /* 2030 */ 383, 384, 385, 386, 311, 388, 429, 429, 339, 429, - /* 2040 */ 429, 429, 429, 429, 429, 429, 347, 429, 429, 429, - /* 2050 */ 429, 352, 429, 354, 429, 429, 429, 429, 311, 429, - /* 2060 */ 429, 429, 339, 429, 429, 429, 429, 429, 429, 429, - /* 2070 */ 347, 429, 429, 429, 311, 352, 377, 354, 429, 429, - /* 2080 */ 381, 382, 383, 384, 385, 386, 339, 388, 429, 429, - /* 2090 */ 429, 429, 429, 429, 347, 429, 429, 429, 429, 352, - /* 2100 */ 377, 354, 339, 429, 381, 382, 383, 384, 385, 386, - /* 2110 */ 347, 388, 429, 429, 429, 352, 429, 354, 429, 429, - /* 2120 */ 429, 429, 429, 429, 377, 429, 429, 429, 381, 382, - /* 2130 */ 383, 384, 385, 386, 429, 388, 429, 429, 429, 429, - /* 2140 */ 377, 429, 429, 429, 381, 382, 383, 384, 385, 386, - /* 2150 */ 429, 388, 311, 429, 429, 429, 429, 429, 429, 429, - /* 2160 */ 429, 429, 429, 429, 429, 429, 429, 429, 429, 429, - /* 2170 */ 429, 429, 429, 429, 429, 429, 429, 429, 429, 429, - /* 2180 */ 339, 429, 429, 429, 429, 429, 429, 429, 347, 429, - /* 2190 */ 429, 429, 429, 352, 429, 354, 429, 429, 429, 429, - /* 2200 */ 429, 429, 429, 311, 429, 429, 429, 429, 429, 429, - /* 2210 */ 429, 429, 429, 311, 429, 429, 429, 429, 377, 429, - /* 2220 */ 429, 429, 381, 382, 383, 384, 385, 386, 429, 388, - /* 2230 */ 429, 339, 429, 429, 429, 429, 429, 429, 429, 347, - /* 2240 */ 429, 339, 429, 429, 352, 429, 354, 429, 429, 347, - /* 2250 */ 429, 429, 429, 429, 352, 429, 354, 429, 429, 429, - /* 2260 */ 429, 429, 429, 429, 429, 429, 311, 429, 429, 377, - /* 2270 */ 429, 429, 429, 381, 382, 383, 384, 385, 386, 377, - /* 2280 */ 388, 429, 311, 381, 382, 383, 384, 385, 386, 429, - /* 2290 */ 388, 429, 429, 429, 339, 429, 429, 429, 429, 429, - /* 2300 */ 429, 429, 347, 429, 429, 429, 311, 352, 429, 354, - /* 2310 */ 339, 429, 429, 429, 429, 429, 429, 429, 347, 429, - /* 2320 */ 429, 429, 311, 352, 429, 354, 429, 429, 429, 429, - /* 2330 */ 429, 429, 377, 429, 339, 429, 381, 382, 383, 384, - /* 2340 */ 385, 386, 347, 388, 429, 429, 311, 352, 377, 354, - /* 2350 */ 339, 429, 381, 382, 383, 384, 385, 386, 347, 388, - /* 2360 */ 429, 429, 429, 352, 429, 354, 429, 429, 429, 429, - /* 2370 */ 311, 429, 377, 429, 339, 429, 381, 382, 383, 384, - /* 2380 */ 385, 386, 347, 388, 429, 429, 311, 352, 377, 354, - /* 2390 */ 429, 429, 381, 382, 383, 384, 385, 386, 339, 388, - /* 2400 */ 429, 429, 429, 429, 429, 429, 347, 429, 429, 429, - /* 2410 */ 429, 352, 377, 354, 339, 429, 381, 382, 383, 384, - /* 2420 */ 385, 386, 347, 388, 429, 429, 429, 352, 429, 354, - /* 2430 */ 429, 429, 429, 429, 429, 429, 377, 429, 429, 429, - /* 2440 */ 381, 382, 383, 384, 385, 386, 429, 388, 429, 429, - /* 2450 */ 429, 429, 377, 429, 429, 429, 381, 382, 383, 384, - /* 2460 */ 385, 386, 429, 388, + /* 150 */ 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + /* 160 */ 14, 15, 16, 8, 9, 426, 427, 12, 13, 14, + /* 170 */ 15, 16, 20, 20, 20, 175, 20, 177, 106, 107, + /* 180 */ 108, 109, 110, 111, 112, 113, 114, 115, 116, 93, + /* 190 */ 118, 119, 120, 121, 122, 123, 60, 60, 198, 199, + /* 200 */ 320, 201, 202, 203, 204, 205, 206, 207, 208, 209, + /* 210 */ 210, 211, 212, 213, 214, 215, 216, 217, 218, 12, + /* 220 */ 13, 14, 129, 130, 20, 340, 21, 20, 348, 22, + /* 230 */ 8, 9, 232, 348, 12, 13, 14, 15, 16, 34, + /* 240 */ 33, 36, 35, 64, 65, 93, 93, 93, 368, 21, + /* 250 */ 71, 368, 24, 25, 26, 27, 28, 29, 30, 31, + /* 260 */ 32, 82, 83, 56, 4, 43, 386, 88, 61, 384, + /* 270 */ 174, 322, 176, 4, 312, 68, 12, 13, 320, 19, + /* 280 */ 4, 401, 402, 403, 20, 405, 22, 105, 408, 331, + /* 290 */ 312, 408, 343, 33, 39, 332, 338, 33, 312, 35, + /* 300 */ 93, 421, 340, 340, 421, 425, 348, 47, 425, 127, + /* 310 */ 348, 51, 349, 44, 45, 353, 56, 355, 340, 325, + /* 320 */ 56, 408, 115, 329, 317, 61, 348, 320, 232, 198, + /* 330 */ 368, 353, 68, 355, 421, 78, 129, 130, 425, 353, + /* 340 */ 378, 43, 56, 355, 382, 383, 384, 385, 386, 387, + /* 350 */ 362, 389, 92, 365, 392, 95, 378, 93, 396, 397, + /* 360 */ 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, + /* 370 */ 408, 0, 241, 242, 243, 244, 245, 124, 92, 115, + /* 380 */ 340, 95, 175, 421, 177, 232, 232, 425, 312, 349, + /* 390 */ 133, 134, 94, 129, 130, 24, 25, 26, 27, 28, + /* 400 */ 29, 30, 31, 32, 93, 198, 199, 35, 201, 202, + /* 410 */ 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, + /* 420 */ 213, 214, 215, 216, 217, 218, 8, 9, 340, 353, + /* 430 */ 12, 13, 14, 15, 16, 347, 2, 184, 185, 175, + /* 440 */ 68, 177, 8, 9, 356, 2, 12, 13, 14, 15, + /* 450 */ 16, 8, 9, 56, 43, 12, 13, 14, 15, 16, + /* 460 */ 312, 37, 198, 199, 160, 201, 202, 203, 204, 205, + /* 470 */ 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + /* 480 */ 216, 217, 218, 12, 13, 18, 231, 20, 340, 320, + /* 490 */ 93, 20, 95, 22, 27, 125, 348, 30, 124, 125, + /* 500 */ 331, 353, 408, 355, 33, 20, 35, 14, 368, 233, + /* 510 */ 368, 408, 94, 20, 47, 421, 49, 348, 51, 425, + /* 520 */ 96, 93, 98, 99, 421, 101, 378, 56, 425, 105, + /* 530 */ 382, 383, 384, 385, 386, 387, 348, 389, 20, 68, + /* 540 */ 392, 237, 238, 232, 396, 397, 398, 359, 408, 22, + /* 550 */ 408, 127, 182, 183, 19, 4, 186, 183, 410, 92, + /* 560 */ 186, 421, 35, 421, 93, 425, 418, 425, 33, 320, + /* 570 */ 20, 104, 339, 8, 9, 332, 332, 12, 13, 14, + /* 580 */ 15, 16, 47, 340, 340, 352, 115, 52, 53, 54, + /* 590 */ 55, 56, 349, 349, 309, 68, 20, 348, 22, 132, + /* 600 */ 129, 130, 135, 136, 137, 138, 139, 140, 141, 142, + /* 610 */ 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, + /* 620 */ 312, 154, 155, 156, 60, 14, 50, 92, 14, 232, + /* 630 */ 95, 20, 8, 9, 20, 386, 12, 13, 14, 15, + /* 640 */ 16, 20, 115, 157, 93, 105, 175, 162, 177, 400, + /* 650 */ 401, 402, 403, 368, 405, 368, 1, 2, 326, 327, + /* 660 */ 232, 353, 251, 128, 124, 125, 126, 127, 128, 198, + /* 670 */ 199, 0, 201, 202, 203, 204, 205, 206, 207, 208, + /* 680 */ 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + /* 690 */ 12, 13, 14, 408, 68, 408, 161, 368, 20, 170, + /* 700 */ 22, 324, 175, 232, 177, 219, 421, 324, 421, 322, + /* 710 */ 425, 33, 425, 35, 179, 229, 181, 312, 189, 190, + /* 720 */ 337, 0, 335, 346, 312, 198, 199, 348, 312, 346, + /* 730 */ 343, 312, 167, 320, 56, 8, 9, 408, 359, 12, + /* 740 */ 13, 14, 15, 16, 331, 320, 68, 12, 13, 94, + /* 750 */ 421, 320, 340, 0, 425, 20, 331, 22, 353, 312, + /* 760 */ 348, 348, 331, 317, 320, 353, 320, 355, 33, 353, + /* 770 */ 35, 93, 353, 348, 320, 326, 327, 355, 320, 348, + /* 780 */ 368, 60, 3, 232, 20, 331, 162, 365, 312, 331, + /* 790 */ 378, 56, 348, 115, 382, 383, 384, 385, 386, 387, + /* 800 */ 353, 389, 348, 68, 12, 13, 348, 129, 130, 104, + /* 810 */ 312, 320, 320, 202, 22, 320, 202, 64, 65, 254, + /* 820 */ 408, 94, 331, 331, 71, 33, 331, 35, 93, 353, + /* 830 */ 386, 320, 312, 421, 312, 82, 83, 425, 68, 348, + /* 840 */ 348, 88, 331, 348, 20, 401, 402, 403, 56, 405, + /* 850 */ 115, 353, 364, 175, 366, 177, 328, 341, 330, 348, + /* 860 */ 68, 93, 8, 9, 129, 130, 12, 13, 14, 15, + /* 870 */ 16, 103, 364, 353, 366, 353, 198, 199, 312, 201, + /* 880 */ 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + /* 890 */ 212, 213, 214, 215, 216, 217, 218, 320, 320, 320, + /* 900 */ 320, 97, 320, 320, 100, 380, 372, 115, 331, 331, + /* 910 */ 175, 331, 177, 331, 331, 61, 341, 312, 350, 353, + /* 920 */ 312, 353, 312, 44, 45, 348, 348, 348, 348, 404, + /* 930 */ 348, 348, 312, 198, 199, 312, 201, 202, 203, 204, + /* 940 */ 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + /* 950 */ 215, 216, 217, 218, 12, 13, 102, 320, 353, 320, + /* 960 */ 341, 353, 20, 353, 22, 386, 202, 175, 331, 177, + /* 970 */ 331, 230, 231, 353, 33, 33, 353, 35, 312, 312, + /* 980 */ 401, 402, 403, 0, 405, 348, 162, 348, 47, 312, + /* 990 */ 198, 199, 380, 52, 53, 54, 55, 56, 56, 340, + /* 1000 */ 42, 43, 210, 211, 212, 213, 214, 215, 216, 0, + /* 1010 */ 68, 157, 320, 320, 22, 356, 404, 340, 350, 353, + /* 1020 */ 353, 353, 345, 331, 331, 348, 380, 35, 249, 18, + /* 1030 */ 353, 43, 355, 92, 23, 93, 95, 61, 8, 9, + /* 1040 */ 348, 348, 12, 13, 14, 15, 16, 43, 37, 38, + /* 1050 */ 404, 333, 41, 97, 336, 378, 100, 115, 56, 382, + /* 1060 */ 383, 384, 385, 386, 387, 43, 389, 43, 57, 58, + /* 1070 */ 59, 129, 130, 219, 220, 221, 222, 223, 224, 225, + /* 1080 */ 226, 227, 228, 229, 97, 35, 97, 100, 105, 100, + /* 1090 */ 0, 61, 162, 163, 1, 2, 35, 95, 94, 158, + /* 1100 */ 159, 0, 161, 0, 93, 329, 165, 124, 125, 126, + /* 1110 */ 127, 128, 22, 43, 105, 43, 94, 175, 94, 177, + /* 1120 */ 43, 43, 181, 22, 94, 22, 129, 130, 46, 341, + /* 1130 */ 43, 43, 102, 124, 125, 126, 127, 128, 43, 43, + /* 1140 */ 198, 199, 131, 201, 202, 203, 204, 205, 206, 207, + /* 1150 */ 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + /* 1160 */ 218, 43, 43, 43, 94, 43, 94, 35, 341, 13, + /* 1170 */ 13, 94, 94, 341, 198, 93, 341, 313, 167, 168, + /* 1180 */ 169, 94, 94, 172, 428, 419, 321, 157, 415, 94, + /* 1190 */ 94, 35, 35, 340, 312, 321, 319, 352, 381, 188, + /* 1200 */ 68, 406, 191, 422, 193, 194, 195, 196, 197, 399, + /* 1210 */ 409, 422, 94, 94, 94, 422, 94, 376, 234, 47, + /* 1220 */ 173, 375, 340, 42, 20, 370, 360, 177, 320, 320, + /* 1230 */ 348, 360, 157, 358, 358, 353, 320, 355, 177, 320, + /* 1240 */ 320, 253, 20, 232, 20, 314, 314, 312, 324, 219, + /* 1250 */ 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + /* 1260 */ 378, 374, 355, 324, 382, 383, 384, 385, 386, 387, + /* 1270 */ 20, 389, 367, 20, 392, 340, 324, 367, 396, 397, + /* 1280 */ 398, 369, 314, 348, 324, 324, 324, 312, 353, 320, + /* 1290 */ 355, 324, 374, 340, 340, 340, 314, 340, 320, 340, + /* 1300 */ 418, 353, 322, 340, 340, 340, 340, 180, 322, 373, + /* 1310 */ 340, 312, 340, 378, 320, 340, 320, 382, 383, 384, + /* 1320 */ 385, 386, 387, 348, 389, 322, 355, 392, 353, 159, + /* 1330 */ 355, 396, 397, 398, 353, 322, 239, 363, 353, 340, + /* 1340 */ 367, 322, 407, 353, 353, 20, 336, 348, 353, 348, + /* 1350 */ 240, 312, 353, 378, 355, 246, 363, 382, 383, 384, + /* 1360 */ 385, 386, 387, 414, 389, 353, 361, 353, 353, 363, + /* 1370 */ 363, 353, 166, 353, 248, 247, 235, 378, 231, 340, + /* 1380 */ 348, 382, 383, 384, 385, 386, 387, 348, 389, 381, + /* 1390 */ 413, 392, 353, 414, 355, 396, 397, 398, 252, 20, + /* 1400 */ 250, 376, 93, 255, 312, 93, 407, 380, 344, 353, + /* 1410 */ 330, 320, 36, 371, 315, 417, 416, 378, 314, 366, + /* 1420 */ 322, 382, 383, 384, 385, 386, 387, 310, 389, 412, + /* 1430 */ 414, 392, 340, 395, 411, 396, 397, 398, 323, 334, + /* 1440 */ 348, 334, 334, 0, 423, 353, 407, 355, 0, 0, + /* 1450 */ 424, 182, 0, 424, 312, 424, 423, 429, 423, 42, + /* 1460 */ 368, 0, 35, 192, 35, 35, 35, 192, 0, 35, + /* 1470 */ 378, 312, 35, 192, 382, 383, 384, 385, 386, 387, + /* 1480 */ 0, 389, 340, 192, 0, 35, 0, 22, 0, 35, + /* 1490 */ 348, 177, 175, 0, 0, 353, 170, 355, 171, 340, + /* 1500 */ 408, 0, 0, 46, 0, 0, 0, 348, 42, 0, + /* 1510 */ 0, 0, 353, 421, 355, 153, 0, 425, 0, 0, + /* 1520 */ 378, 312, 148, 0, 382, 383, 384, 385, 386, 387, + /* 1530 */ 0, 389, 0, 35, 392, 148, 0, 378, 396, 397, + /* 1540 */ 0, 382, 383, 384, 385, 386, 387, 0, 389, 340, + /* 1550 */ 0, 392, 0, 0, 0, 396, 397, 348, 0, 0, + /* 1560 */ 0, 0, 353, 0, 355, 0, 0, 42, 0, 312, + /* 1570 */ 0, 0, 0, 0, 0, 0, 0, 22, 0, 312, + /* 1580 */ 56, 0, 56, 0, 0, 42, 40, 378, 0, 0, + /* 1590 */ 39, 382, 383, 384, 385, 386, 387, 340, 389, 43, + /* 1600 */ 14, 392, 345, 46, 14, 348, 397, 340, 46, 0, + /* 1610 */ 353, 0, 355, 0, 0, 348, 39, 166, 39, 0, + /* 1620 */ 353, 0, 355, 0, 0, 0, 62, 0, 35, 47, + /* 1630 */ 312, 35, 47, 39, 39, 378, 0, 35, 47, 382, + /* 1640 */ 383, 384, 385, 386, 387, 378, 389, 39, 0, 382, + /* 1650 */ 383, 384, 385, 386, 387, 35, 389, 47, 340, 22, + /* 1660 */ 0, 39, 0, 0, 0, 0, 348, 35, 35, 102, + /* 1670 */ 35, 353, 43, 355, 43, 35, 35, 22, 0, 22, + /* 1680 */ 0, 0, 35, 22, 0, 35, 0, 420, 49, 22, + /* 1690 */ 312, 35, 0, 22, 20, 0, 378, 100, 0, 162, + /* 1700 */ 382, 383, 384, 385, 386, 387, 178, 389, 312, 22, + /* 1710 */ 35, 162, 0, 0, 0, 0, 0, 35, 340, 93, + /* 1720 */ 187, 0, 94, 93, 0, 46, 348, 93, 159, 39, + /* 1730 */ 230, 353, 43, 355, 43, 93, 340, 93, 93, 236, + /* 1740 */ 94, 345, 43, 94, 348, 427, 103, 160, 94, 353, + /* 1750 */ 46, 355, 94, 46, 43, 35, 378, 158, 312, 93, + /* 1760 */ 382, 383, 384, 385, 386, 387, 162, 389, 46, 391, + /* 1770 */ 164, 94, 43, 46, 378, 236, 93, 46, 382, 383, + /* 1780 */ 384, 385, 386, 387, 312, 389, 340, 93, 43, 93, + /* 1790 */ 93, 345, 35, 35, 348, 94, 94, 94, 35, 353, + /* 1800 */ 94, 355, 35, 35, 2, 22, 46, 43, 312, 22, + /* 1810 */ 198, 93, 340, 35, 104, 46, 200, 94, 93, 93, + /* 1820 */ 348, 35, 94, 93, 378, 353, 94, 355, 382, 383, + /* 1830 */ 384, 385, 386, 387, 312, 389, 340, 236, 94, 93, + /* 1840 */ 93, 93, 35, 94, 348, 93, 35, 94, 93, 353, + /* 1850 */ 378, 355, 35, 35, 382, 383, 384, 385, 386, 387, + /* 1860 */ 94, 389, 340, 93, 22, 94, 93, 117, 117, 93, + /* 1870 */ 348, 117, 35, 117, 378, 353, 43, 355, 382, 383, + /* 1880 */ 384, 385, 386, 387, 105, 389, 93, 93, 22, 62, + /* 1890 */ 61, 35, 312, 35, 35, 35, 35, 35, 35, 35, + /* 1900 */ 378, 91, 35, 35, 382, 383, 384, 385, 386, 387, + /* 1910 */ 312, 389, 320, 68, 43, 35, 35, 22, 35, 22, + /* 1920 */ 340, 35, 35, 35, 35, 68, 35, 35, 348, 35, + /* 1930 */ 22, 35, 0, 353, 35, 355, 35, 47, 340, 39, + /* 1940 */ 348, 0, 35, 39, 0, 47, 348, 35, 39, 47, + /* 1950 */ 0, 353, 35, 355, 39, 0, 0, 47, 378, 35, + /* 1960 */ 368, 35, 382, 383, 384, 385, 386, 387, 22, 389, + /* 1970 */ 21, 312, 430, 22, 22, 21, 378, 20, 386, 430, + /* 1980 */ 382, 383, 384, 385, 386, 387, 430, 389, 430, 430, + /* 1990 */ 430, 430, 430, 401, 402, 403, 430, 405, 430, 340, + /* 2000 */ 408, 430, 430, 430, 430, 430, 430, 348, 430, 430, + /* 2010 */ 430, 430, 353, 421, 355, 430, 430, 425, 430, 430, + /* 2020 */ 430, 312, 430, 430, 430, 430, 430, 430, 430, 430, + /* 2030 */ 430, 312, 430, 430, 430, 430, 430, 378, 430, 430, + /* 2040 */ 430, 382, 383, 384, 385, 386, 387, 430, 389, 340, + /* 2050 */ 430, 430, 430, 430, 430, 430, 430, 348, 430, 340, + /* 2060 */ 430, 430, 353, 430, 355, 430, 430, 348, 430, 430, + /* 2070 */ 430, 312, 353, 430, 355, 430, 430, 430, 430, 430, + /* 2080 */ 430, 430, 430, 430, 430, 430, 430, 378, 430, 430, + /* 2090 */ 430, 382, 383, 384, 385, 386, 387, 378, 389, 340, + /* 2100 */ 430, 382, 383, 384, 385, 386, 387, 348, 389, 430, + /* 2110 */ 430, 430, 353, 430, 355, 430, 430, 430, 430, 430, + /* 2120 */ 430, 312, 430, 430, 430, 430, 430, 430, 430, 430, + /* 2130 */ 430, 430, 430, 312, 430, 430, 430, 378, 430, 430, + /* 2140 */ 430, 382, 383, 384, 385, 386, 387, 312, 389, 340, + /* 2150 */ 430, 430, 430, 430, 430, 430, 430, 348, 430, 430, + /* 2160 */ 430, 340, 353, 430, 355, 430, 430, 430, 430, 348, + /* 2170 */ 430, 430, 430, 430, 353, 340, 355, 430, 430, 430, + /* 2180 */ 430, 430, 430, 348, 430, 430, 430, 378, 353, 430, + /* 2190 */ 355, 382, 383, 384, 385, 386, 387, 430, 389, 378, + /* 2200 */ 430, 430, 430, 382, 383, 384, 385, 386, 387, 430, + /* 2210 */ 389, 430, 430, 378, 430, 430, 430, 382, 383, 384, + /* 2220 */ 385, 386, 387, 312, 389, 430, 430, 430, 430, 430, + /* 2230 */ 430, 430, 430, 312, 430, 430, 430, 430, 430, 430, + /* 2240 */ 430, 430, 430, 430, 430, 430, 430, 430, 430, 430, + /* 2250 */ 430, 340, 430, 430, 430, 430, 430, 430, 430, 348, + /* 2260 */ 430, 340, 430, 430, 353, 430, 355, 430, 430, 348, + /* 2270 */ 430, 430, 430, 430, 353, 430, 355, 430, 430, 430, + /* 2280 */ 430, 430, 430, 430, 312, 430, 430, 430, 430, 378, + /* 2290 */ 430, 430, 430, 382, 383, 384, 385, 386, 387, 378, + /* 2300 */ 389, 430, 430, 382, 383, 384, 385, 386, 387, 430, + /* 2310 */ 389, 430, 340, 430, 430, 430, 430, 430, 430, 430, + /* 2320 */ 348, 430, 430, 430, 430, 353, 430, 355, 430, 430, + /* 2330 */ 430, 430, 430, 430, 312, 430, 430, 430, 430, 430, + /* 2340 */ 430, 430, 430, 430, 312, 430, 430, 430, 430, 430, + /* 2350 */ 378, 430, 430, 430, 382, 383, 384, 385, 386, 387, + /* 2360 */ 430, 389, 340, 430, 430, 430, 430, 430, 430, 430, + /* 2370 */ 348, 430, 340, 430, 430, 353, 430, 355, 430, 430, + /* 2380 */ 348, 430, 430, 430, 312, 353, 430, 355, 430, 430, + /* 2390 */ 430, 430, 430, 430, 430, 430, 430, 430, 430, 430, + /* 2400 */ 378, 430, 430, 430, 382, 383, 384, 385, 386, 387, + /* 2410 */ 378, 389, 340, 430, 382, 383, 384, 385, 386, 387, + /* 2420 */ 348, 389, 430, 430, 430, 353, 430, 355, 430, 430, + /* 2430 */ 430, 430, 430, 430, 312, 430, 430, 430, 430, 430, + /* 2440 */ 430, 430, 430, 430, 430, 430, 430, 430, 430, 430, + /* 2450 */ 378, 430, 430, 430, 382, 383, 384, 385, 386, 387, + /* 2460 */ 430, 389, 340, 430, 430, 430, 430, 430, 430, 430, + /* 2470 */ 348, 430, 430, 430, 430, 353, 430, 355, 430, 430, + /* 2480 */ 430, 430, 430, 430, 430, 430, 430, 430, 430, 430, + /* 2490 */ 430, 430, 430, 430, 430, 430, 430, 430, 430, 430, + /* 2500 */ 378, 430, 430, 430, 382, 383, 384, 385, 386, 387, + /* 2510 */ 430, 389, }; -#define YY_SHIFT_COUNT (673) +#define YY_SHIFT_COUNT (674) #define YY_SHIFT_MIN (0) -#define YY_SHIFT_MAX (1945) +#define YY_SHIFT_MAX (1957) static const unsigned short int yy_shift_ofst[] = { - /* 0 */ 505, 0, 0, 206, 206, 412, 412, 412, 618, 618, - /* 10 */ 412, 412, 824, 1030, 1236, 1030, 1030, 1030, 1030, 1030, - /* 20 */ 1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030, - /* 30 */ 1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030, - /* 40 */ 1030, 1030, 33, 33, 296, 296, 296, 543, 543, 107, - /* 50 */ 543, 543, 433, 30, 6, 200, 6, 73, 73, 21, - /* 60 */ 21, 11, 51, 6, 6, 73, 73, 73, 73, 73, - /* 70 */ 73, 73, 73, 73, 73, 56, 73, 73, 73, 243, - /* 80 */ 73, 73, 285, 73, 73, 285, 377, 73, 285, 285, - /* 90 */ 285, 73, 403, 205, 700, 893, 893, 80, 611, 611, - /* 100 */ 611, 611, 611, 611, 611, 611, 611, 611, 611, 611, - /* 110 */ 611, 611, 611, 611, 611, 611, 611, 346, 394, 51, - /* 120 */ 628, 628, 461, 714, 643, 431, 431, 431, 714, 417, - /* 130 */ 417, 243, 567, 567, 285, 285, 479, 479, 402, 526, - /* 140 */ 257, 257, 257, 257, 257, 257, 257, 1035, 840, 15, - /* 150 */ 663, 562, 630, 81, 106, 446, 380, 661, 687, 797, - /* 160 */ 533, 455, 533, 851, 860, 860, 860, 777, 859, 954, - /* 170 */ 1147, 1036, 1167, 1204, 1204, 1167, 1101, 1101, 1204, 1204, - /* 180 */ 1204, 1246, 1246, 1247, 56, 243, 56, 1256, 1261, 56, - /* 190 */ 1256, 56, 56, 56, 1204, 56, 1246, 285, 285, 285, - /* 200 */ 285, 285, 285, 285, 285, 285, 285, 285, 1204, 1246, - /* 210 */ 479, 1247, 403, 1127, 243, 403, 1204, 1204, 1256, 403, - /* 220 */ 1091, 479, 479, 479, 479, 1091, 479, 1173, 403, 402, - /* 230 */ 403, 417, 1327, 479, 1120, 1091, 479, 479, 1120, 1091, - /* 240 */ 479, 479, 285, 1117, 1205, 1120, 1124, 1126, 1141, 954, - /* 250 */ 1148, 417, 1357, 1135, 1139, 1137, 1135, 1139, 1135, 1139, - /* 260 */ 1297, 1309, 479, 526, 1204, 403, 1382, 1246, 2464, 2464, - /* 270 */ 2464, 2464, 2464, 2464, 2464, 69, 130, 164, 423, 153, - /* 280 */ 269, 378, 475, 536, 646, 921, 457, 675, 675, 675, - /* 290 */ 675, 675, 675, 675, 675, 1093, 672, 36, 36, 557, - /* 300 */ 48, 365, 27, 765, 139, 329, 129, 351, 424, 424, - /* 310 */ 424, 424, 868, 917, 927, 867, 869, 897, 914, 948, - /* 320 */ 995, 1023, 925, 814, 969, 1003, 1008, 1010, 1038, 1040, - /* 330 */ 1063, 976, 941, 901, 940, 1100, 1022, 1031, 1017, 1106, - /* 340 */ 1033, 1080, 1107, 1118, 1128, 1160, 1162, 993, 1067, 1111, - /* 350 */ 810, 357, 1429, 1456, 1254, 1458, 1460, 1421, 1468, 1436, - /* 360 */ 1279, 1437, 1438, 1439, 1284, 1476, 1442, 1443, 1288, 1480, - /* 370 */ 1290, 1483, 1449, 1485, 1464, 1488, 1454, 1314, 1319, 1491, - /* 380 */ 1494, 1325, 1333, 1504, 1505, 1461, 1506, 1508, 1509, 1469, - /* 390 */ 1510, 1512, 1513, 1362, 1516, 1517, 1518, 1519, 1520, 1374, - /* 400 */ 1489, 1525, 1379, 1527, 1529, 1531, 1532, 1533, 1534, 1536, - /* 410 */ 1537, 1538, 1540, 1541, 1542, 1545, 1546, 1507, 1547, 1548, - /* 420 */ 1550, 1551, 1552, 1563, 1543, 1566, 1567, 1568, 1569, 1571, - /* 430 */ 1498, 1555, 1500, 1573, 1574, 1535, 1539, 1549, 1561, 1530, - /* 440 */ 1565, 1553, 1581, 1557, 1556, 1582, 1584, 1586, 1562, 1423, - /* 450 */ 1589, 1590, 1591, 1564, 1593, 1594, 1570, 1560, 1585, 1602, - /* 460 */ 1577, 1578, 1588, 1603, 1595, 1587, 1592, 1604, 1597, 1601, - /* 470 */ 1596, 1608, 1609, 1629, 1633, 1558, 1559, 1614, 1615, 1638, - /* 480 */ 1616, 1617, 1610, 1611, 1622, 1625, 1639, 1662, 1641, 1665, - /* 490 */ 1644, 1618, 1668, 1648, 1637, 1673, 1642, 1675, 1643, 1676, - /* 500 */ 1657, 1619, 1680, 1522, 1646, 1684, 1511, 1663, 1572, 1528, - /* 510 */ 1690, 1691, 1579, 1575, 1692, 1693, 1695, 1605, 1613, 1669, - /* 520 */ 1521, 1708, 1621, 1576, 1634, 1709, 1671, 1599, 1635, 1612, - /* 530 */ 1679, 1672, 1495, 1636, 1649, 1651, 1652, 1654, 1656, 1686, - /* 540 */ 1658, 1660, 1661, 1667, 1664, 1688, 1698, 1703, 1685, 1711, - /* 550 */ 1499, 1683, 1687, 1714, 1482, 1721, 1726, 1732, 1697, 1738, - /* 560 */ 1580, 1705, 1706, 1748, 1749, 1750, 1751, 1756, 1705, 1798, - /* 570 */ 1779, 1606, 1759, 1713, 1715, 1717, 1718, 1722, 1720, 1760, - /* 580 */ 1730, 1733, 1761, 1788, 1627, 1735, 1725, 1731, 1794, 1795, - /* 590 */ 1739, 1740, 1799, 1743, 1744, 1801, 1746, 1753, 1804, 1752, - /* 600 */ 1755, 1806, 1757, 1727, 1734, 1736, 1737, 1820, 1754, 1762, - /* 610 */ 1764, 1816, 1765, 1817, 1817, 1837, 1800, 1802, 1826, 1829, - /* 620 */ 1831, 1832, 1833, 1834, 1836, 1838, 1845, 1847, 1818, 1782, - /* 630 */ 1842, 1849, 1852, 1866, 1854, 1868, 1857, 1859, 1827, 1610, - /* 640 */ 1862, 1611, 1864, 1865, 1867, 1869, 1881, 1870, 1907, 1874, - /* 650 */ 1863, 1872, 1912, 1878, 1873, 1875, 1915, 1882, 1876, 1877, - /* 660 */ 1919, 1887, 1886, 1885, 1941, 1908, 1909, 1945, 1925, 1927, - /* 670 */ 1928, 1929, 1931, 1933, + /* 0 */ 1011, 0, 0, 207, 207, 264, 264, 264, 471, 471, + /* 10 */ 264, 264, 678, 735, 942, 735, 735, 735, 735, 735, + /* 20 */ 735, 735, 735, 735, 735, 735, 735, 735, 735, 735, + /* 30 */ 735, 735, 735, 735, 735, 735, 735, 735, 735, 735, + /* 40 */ 735, 735, 153, 153, 152, 152, 152, 792, 792, 154, + /* 50 */ 792, 792, 96, 397, 311, 428, 311, 156, 156, 269, + /* 60 */ 269, 551, 93, 311, 311, 156, 156, 156, 156, 156, + /* 70 */ 156, 156, 156, 156, 156, 136, 156, 156, 156, 204, + /* 80 */ 156, 156, 518, 156, 156, 518, 550, 156, 518, 518, + /* 90 */ 518, 156, 564, 467, 1030, 854, 854, 228, 527, 527, + /* 100 */ 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, + /* 110 */ 527, 527, 527, 527, 527, 527, 527, 424, 179, 93, + /* 120 */ 493, 493, 137, 372, 721, 485, 485, 485, 372, 621, + /* 130 */ 621, 204, 671, 671, 518, 518, 626, 626, 705, 770, + /* 140 */ 72, 72, 72, 72, 72, 72, 72, 535, 77, 565, + /* 150 */ 753, 131, 30, 304, 611, 614, 576, 879, 182, 824, + /* 160 */ 741, 255, 741, 958, 779, 779, 779, 276, 764, 984, + /* 170 */ 1172, 1047, 1181, 1204, 1204, 1181, 1075, 1075, 1204, 1204, + /* 180 */ 1204, 1222, 1222, 1224, 136, 204, 136, 1250, 1253, 136, + /* 190 */ 1250, 136, 136, 136, 1204, 136, 1222, 518, 518, 518, + /* 200 */ 518, 518, 518, 518, 518, 518, 518, 518, 1204, 1222, + /* 210 */ 626, 1224, 564, 1127, 204, 564, 1204, 1204, 1250, 564, + /* 220 */ 1097, 626, 626, 626, 626, 1097, 626, 1170, 564, 705, + /* 230 */ 564, 621, 1325, 626, 1110, 1097, 626, 626, 1110, 1097, + /* 240 */ 626, 626, 518, 1109, 1206, 1110, 1126, 1128, 1141, 984, + /* 250 */ 1147, 621, 1379, 1146, 1150, 1148, 1146, 1150, 1146, 1150, + /* 260 */ 1309, 1312, 626, 770, 1204, 564, 1376, 1222, 2512, 2512, + /* 270 */ 2512, 2512, 2512, 2512, 2512, 69, 941, 371, 260, 2, + /* 280 */ 222, 418, 434, 443, 624, 727, 983, 155, 155, 155, + /* 290 */ 155, 155, 155, 155, 155, 1009, 540, 12, 12, 370, + /* 300 */ 374, 529, 286, 257, 205, 253, 655, 486, 146, 146, + /* 310 */ 146, 146, 298, 36, 992, 804, 956, 987, 989, 1090, + /* 320 */ 1101, 1103, 1002, 930, 1004, 1022, 1024, 1070, 1072, 1077, + /* 330 */ 1078, 1093, 997, 411, 988, 1087, 1050, 1061, 976, 1088, + /* 340 */ 1082, 1095, 1096, 1118, 1119, 1120, 1122, 768, 1156, 1157, + /* 350 */ 1132, 43, 1443, 1448, 1269, 1449, 1452, 1417, 1461, 1427, + /* 360 */ 1271, 1429, 1430, 1431, 1275, 1468, 1434, 1437, 1281, 1480, + /* 370 */ 1291, 1484, 1450, 1486, 1465, 1488, 1454, 1314, 1317, 1493, + /* 380 */ 1494, 1327, 1326, 1501, 1502, 1457, 1504, 1505, 1506, 1466, + /* 390 */ 1509, 1510, 1511, 1362, 1516, 1518, 1519, 1530, 1532, 1374, + /* 400 */ 1498, 1523, 1387, 1536, 1540, 1547, 1550, 1552, 1553, 1554, + /* 410 */ 1558, 1559, 1560, 1561, 1563, 1565, 1566, 1525, 1568, 1570, + /* 420 */ 1571, 1572, 1573, 1574, 1555, 1575, 1576, 1578, 1588, 1589, + /* 430 */ 1524, 1581, 1526, 1583, 1584, 1543, 1551, 1556, 1586, 1557, + /* 440 */ 1590, 1562, 1609, 1546, 1577, 1611, 1613, 1614, 1579, 1451, + /* 450 */ 1619, 1621, 1623, 1564, 1624, 1625, 1593, 1582, 1594, 1627, + /* 460 */ 1596, 1585, 1595, 1636, 1602, 1591, 1608, 1648, 1620, 1610, + /* 470 */ 1622, 1662, 1663, 1664, 1665, 1567, 1597, 1632, 1637, 1660, + /* 480 */ 1633, 1635, 1629, 1631, 1640, 1641, 1655, 1678, 1657, 1680, + /* 490 */ 1661, 1639, 1681, 1667, 1647, 1684, 1650, 1686, 1656, 1692, + /* 500 */ 1671, 1674, 1695, 1537, 1675, 1698, 1528, 1687, 1549, 1569, + /* 510 */ 1712, 1713, 1604, 1606, 1714, 1715, 1716, 1626, 1628, 1682, + /* 520 */ 1533, 1721, 1630, 1587, 1634, 1724, 1690, 1599, 1642, 1643, + /* 530 */ 1679, 1689, 1503, 1644, 1646, 1645, 1649, 1654, 1666, 1691, + /* 540 */ 1658, 1683, 1694, 1696, 1677, 1699, 1704, 1707, 1697, 1711, + /* 550 */ 1539, 1701, 1702, 1722, 1500, 1729, 1727, 1731, 1703, 1745, + /* 560 */ 1601, 1706, 1720, 1757, 1758, 1763, 1767, 1768, 1706, 1802, + /* 570 */ 1783, 1612, 1764, 1718, 1723, 1725, 1728, 1726, 1732, 1760, + /* 580 */ 1730, 1746, 1769, 1787, 1616, 1747, 1710, 1744, 1778, 1786, + /* 590 */ 1748, 1749, 1807, 1752, 1753, 1811, 1755, 1766, 1817, 1770, + /* 600 */ 1771, 1818, 1773, 1750, 1751, 1754, 1756, 1842, 1779, 1776, + /* 610 */ 1793, 1837, 1794, 1833, 1833, 1866, 1827, 1829, 1856, 1858, + /* 620 */ 1859, 1860, 1861, 1862, 1863, 1864, 1867, 1868, 1845, 1810, + /* 630 */ 1871, 1880, 1881, 1895, 1883, 1897, 1886, 1887, 1888, 1857, + /* 640 */ 1629, 1889, 1631, 1891, 1892, 1894, 1896, 1908, 1899, 1932, + /* 650 */ 1901, 1890, 1900, 1941, 1907, 1898, 1904, 1944, 1912, 1902, + /* 660 */ 1909, 1950, 1917, 1910, 1915, 1955, 1924, 1926, 1956, 1946, + /* 670 */ 1949, 1951, 1952, 1954, 1957, }; #define YY_REDUCE_COUNT (274) -#define YY_REDUCE_MIN (-386) -#define YY_REDUCE_MAX (2075) +#define YY_REDUCE_MIN (-353) +#define YY_REDUCE_MAX (2122) static const short yy_reduce_ofst[] = { - /* 0 */ 29, -307, 115, 793, 383, -82, 939, 999, 1115, 1176, - /* 10 */ 500, 620, 1233, 219, 1259, 603, 753, 1317, 1335, 1385, - /* 20 */ 1411, 1435, 1493, 1544, 1554, 1607, 1623, 1647, 1699, 1723, - /* 30 */ 1747, 1763, 1841, 1892, 1902, 1955, 1971, 1995, 2011, 2035, - /* 40 */ 2059, 2075, -305, 1007, -74, 189, 673, -55, 563, 109, - /* 50 */ -333, -97, -366, -361, -131, 300, 366, 190, 240, -315, - /* 60 */ -308, -386, -263, -173, -149, -160, -81, 54, 374, 613, - /* 70 */ 626, 652, 660, 725, 729, -251, 737, 780, 833, -297, - /* 80 */ 835, 836, 50, 838, 882, -96, 185, 932, 147, -86, - /* 90 */ 154, 933, -316, -283, -376, -376, -376, -273, -229, -174, - /* 100 */ 208, 220, 246, 284, 323, 326, 359, 371, 391, 418, - /* 110 */ 420, 437, 499, 501, 503, 537, 547, -19, 71, 75, - /* 120 */ 199, 350, 373, 458, -94, -18, 253, 372, 549, 430, - /* 130 */ 515, 221, -34, 70, 502, 521, 538, 551, 578, 312, - /* 140 */ -329, 309, 328, 337, 386, 572, 606, 472, 657, 591, - /* 150 */ 719, 653, 741, 680, 770, 770, 808, 830, 791, 773, - /* 160 */ 755, 755, 755, 766, 746, 748, 751, 778, 770, 816, - /* 170 */ 822, 853, 864, 906, 907, 895, 902, 903, 942, 945, - /* 180 */ 946, 955, 957, 899, 950, 920, 952, 911, 915, 959, - /* 190 */ 918, 962, 964, 965, 970, 967, 981, 956, 958, 960, - /* 200 */ 961, 963, 966, 968, 972, 973, 974, 975, 977, 985, - /* 210 */ 949, 930, 987, 937, 978, 994, 998, 1000, 971, 997, - /* 220 */ 979, 988, 990, 991, 992, 986, 1004, 989, 1012, 1020, - /* 230 */ 1018, 1005, 980, 1006, 944, 1001, 1009, 1014, 984, 1011, - /* 240 */ 1015, 1016, 770, 953, 983, 1002, 1013, 982, 996, 1024, - /* 250 */ 755, 1032, 1021, 1034, 1037, 1027, 1041, 1039, 1042, 1044, - /* 260 */ 1019, 1059, 1051, 1075, 1097, 1096, 1105, 1108, 1050, 1057, - /* 270 */ 1090, 1095, 1099, 1102, 1121, + /* 0 */ 285, -311, -38, 148, 882, 935, 999, 1039, 412, 1092, + /* 10 */ 1142, 1159, -22, -261, 1209, 677, 1257, 1267, 1318, 1378, + /* 20 */ 1396, 1446, 975, 1472, 1496, 1522, 1580, 1598, 1659, 1709, + /* 30 */ 1719, 1759, 1809, 1821, 1835, 1911, 1921, 1972, 2022, 2032, + /* 40 */ 2072, 2122, -120, 1592, 249, 444, 579, -319, -289, -309, + /* 50 */ -323, -258, -117, 140, 142, 287, 329, -299, -42, -316, + /* 60 */ -312, -87, -346, 94, 103, 169, 413, 425, 431, 454, + /* 70 */ 458, 491, 492, 495, 511, 383, 578, 580, 582, -12, + /* 80 */ 583, 637, -37, 639, 692, -229, -115, 693, 243, 88, + /* 90 */ 244, 577, 387, -275, -353, -353, -353, -265, -14, 76, + /* 100 */ 308, 405, 416, 419, 447, 476, 498, 520, 522, 566, + /* 110 */ 605, 608, 610, 620, 623, 666, 667, 233, -6, -292, + /* 120 */ 7, 446, 377, 332, -51, 525, 612, 646, 449, 188, + /* 130 */ 379, 422, 488, 508, 40, 659, 568, 668, 718, 528, + /* 140 */ 516, 575, 619, 788, 827, 832, 835, 534, 864, 756, + /* 150 */ 776, 766, 865, 773, 853, 853, 874, 877, 845, 817, + /* 160 */ 795, 795, 795, 810, 781, 789, 793, 801, 853, 841, + /* 170 */ 846, 855, 866, 908, 909, 871, 875, 876, 916, 919, + /* 180 */ 920, 931, 932, 887, 924, 907, 939, 905, 912, 952, + /* 190 */ 910, 960, 961, 962, 969, 967, 968, 953, 954, 955, + /* 200 */ 957, 959, 963, 964, 965, 966, 970, 972, 978, 982, + /* 210 */ 948, 918, 980, 936, 971, 986, 994, 996, 973, 1003, + /* 220 */ 974, 981, 985, 990, 991, 993, 995, 1005, 1013, 1010, + /* 230 */ 1019, 1001, 1008, 1012, 949, 1006, 1014, 1015, 979, 1007, + /* 240 */ 1018, 1020, 853, 998, 1000, 1016, 977, 1017, 1023, 1025, + /* 250 */ 795, 1032, 1027, 1026, 1021, 1028, 1029, 1033, 1031, 1035, + /* 260 */ 1038, 1064, 1056, 1080, 1091, 1098, 1099, 1104, 1042, 1053, + /* 270 */ 1105, 1107, 1108, 1115, 1117, }; static const YYACTIONTYPE yy_default[] = { - /* 0 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 10 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 20 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 30 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 40 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 50 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 60 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 70 */ 1478, 1478, 1478, 1478, 1478, 1552, 1478, 1478, 1478, 1478, - /* 80 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 90 */ 1478, 1478, 1550, 1714, 1478, 1889, 1478, 1478, 1478, 1478, - /* 100 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 110 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 120 */ 1478, 1478, 1552, 1478, 1550, 1901, 1901, 1901, 1478, 1478, - /* 130 */ 1478, 1478, 1755, 1755, 1478, 1478, 1478, 1478, 1654, 1478, - /* 140 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1749, 1478, 1970, - /* 150 */ 1478, 1478, 1478, 1924, 1478, 1478, 1478, 1478, 1607, 1916, - /* 160 */ 1893, 1907, 1894, 1891, 1955, 1955, 1955, 1910, 1478, 1920, - /* 170 */ 1478, 1742, 1719, 1478, 1478, 1719, 1716, 1716, 1478, 1478, - /* 180 */ 1478, 1478, 1478, 1478, 1552, 1478, 1552, 1478, 1478, 1552, - /* 190 */ 1478, 1552, 1552, 1552, 1478, 1552, 1478, 1478, 1478, 1478, - /* 200 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 210 */ 1478, 1478, 1550, 1751, 1478, 1550, 1478, 1478, 1478, 1550, - /* 220 */ 1929, 1478, 1478, 1478, 1478, 1929, 1478, 1478, 1550, 1478, - /* 230 */ 1550, 1478, 1478, 1478, 1931, 1929, 1478, 1478, 1931, 1929, - /* 240 */ 1478, 1478, 1478, 1943, 1939, 1931, 1947, 1945, 1922, 1920, - /* 250 */ 1907, 1478, 1478, 1961, 1957, 1973, 1961, 1957, 1961, 1957, - /* 260 */ 1478, 1623, 1478, 1478, 1478, 1550, 1510, 1478, 1744, 1755, - /* 270 */ 1657, 1657, 1657, 1553, 1483, 1478, 1478, 1478, 1478, 1478, - /* 280 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1826, 1942, 1941, - /* 290 */ 1865, 1864, 1863, 1861, 1825, 1478, 1619, 1824, 1823, 1478, - /* 300 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1817, 1818, - /* 310 */ 1816, 1815, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 320 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 330 */ 1478, 1890, 1478, 1958, 1962, 1478, 1478, 1478, 1478, 1478, - /* 340 */ 1801, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 350 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 360 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 370 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 380 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 390 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 400 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 410 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 420 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 430 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1515, 1478, 1478, - /* 440 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 450 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 460 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 470 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 480 */ 1478, 1478, 1590, 1589, 1478, 1478, 1478, 1478, 1478, 1478, - /* 490 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 500 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 510 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 520 */ 1478, 1759, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 530 */ 1478, 1923, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 540 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1801, 1478, 1940, - /* 550 */ 1478, 1900, 1896, 1478, 1478, 1892, 1800, 1478, 1478, 1956, - /* 560 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1885, - /* 570 */ 1478, 1478, 1858, 1843, 1478, 1478, 1478, 1478, 1478, 1478, - /* 580 */ 1478, 1478, 1478, 1478, 1811, 1478, 1478, 1478, 1478, 1478, - /* 590 */ 1651, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 600 */ 1478, 1478, 1478, 1636, 1634, 1633, 1632, 1478, 1629, 1478, - /* 610 */ 1478, 1478, 1478, 1660, 1659, 1478, 1478, 1478, 1478, 1478, - /* 620 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 630 */ 1571, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1563, - /* 640 */ 1478, 1562, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 650 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 660 */ 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, 1478, - /* 670 */ 1478, 1478, 1478, 1478, + /* 0 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 10 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 20 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 30 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 40 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 50 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 60 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 70 */ 1481, 1481, 1481, 1481, 1481, 1555, 1481, 1481, 1481, 1481, + /* 80 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 90 */ 1481, 1481, 1553, 1718, 1481, 1893, 1481, 1481, 1481, 1481, + /* 100 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 110 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 120 */ 1481, 1481, 1555, 1481, 1553, 1905, 1905, 1905, 1481, 1481, + /* 130 */ 1481, 1481, 1759, 1759, 1481, 1481, 1481, 1481, 1658, 1481, + /* 140 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1753, 1481, 1974, + /* 150 */ 1481, 1481, 1481, 1928, 1481, 1481, 1481, 1481, 1611, 1920, + /* 160 */ 1897, 1911, 1898, 1895, 1959, 1959, 1959, 1914, 1481, 1924, + /* 170 */ 1481, 1746, 1723, 1481, 1481, 1723, 1720, 1720, 1481, 1481, + /* 180 */ 1481, 1481, 1481, 1481, 1555, 1481, 1555, 1481, 1481, 1555, + /* 190 */ 1481, 1555, 1555, 1555, 1481, 1555, 1481, 1481, 1481, 1481, + /* 200 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 210 */ 1481, 1481, 1553, 1755, 1481, 1553, 1481, 1481, 1481, 1553, + /* 220 */ 1933, 1481, 1481, 1481, 1481, 1933, 1481, 1481, 1553, 1481, + /* 230 */ 1553, 1481, 1481, 1481, 1935, 1933, 1481, 1481, 1935, 1933, + /* 240 */ 1481, 1481, 1481, 1947, 1943, 1935, 1951, 1949, 1926, 1924, + /* 250 */ 1911, 1481, 1481, 1965, 1961, 1977, 1965, 1961, 1965, 1961, + /* 260 */ 1481, 1627, 1481, 1481, 1481, 1553, 1513, 1481, 1748, 1759, + /* 270 */ 1661, 1661, 1661, 1556, 1486, 1481, 1481, 1481, 1481, 1481, + /* 280 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1830, 1946, 1945, + /* 290 */ 1869, 1868, 1867, 1865, 1829, 1481, 1623, 1828, 1827, 1481, + /* 300 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1821, 1822, + /* 310 */ 1820, 1819, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 320 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 330 */ 1481, 1894, 1481, 1962, 1966, 1481, 1481, 1481, 1481, 1481, + /* 340 */ 1805, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 350 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 360 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 370 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 380 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 390 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 400 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 410 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 420 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 430 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1518, 1481, 1481, + /* 440 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 450 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 460 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 470 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 480 */ 1481, 1481, 1594, 1593, 1481, 1481, 1481, 1481, 1481, 1481, + /* 490 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 500 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 510 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 520 */ 1481, 1763, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 530 */ 1481, 1927, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 540 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1805, 1481, 1944, + /* 550 */ 1481, 1904, 1900, 1481, 1481, 1896, 1804, 1481, 1481, 1960, + /* 560 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1889, + /* 570 */ 1481, 1481, 1862, 1847, 1481, 1481, 1481, 1481, 1481, 1481, + /* 580 */ 1481, 1481, 1481, 1481, 1815, 1481, 1481, 1481, 1481, 1481, + /* 590 */ 1655, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 600 */ 1481, 1481, 1481, 1640, 1638, 1637, 1636, 1481, 1633, 1481, + /* 610 */ 1481, 1481, 1481, 1664, 1663, 1481, 1481, 1481, 1481, 1481, + /* 620 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 630 */ 1575, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 640 */ 1566, 1481, 1565, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 650 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 660 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 670 */ 1481, 1481, 1481, 1481, 1481, }; /********** End of lemon-generated parsing tables *****************************/ @@ -983,6 +993,7 @@ static const YYCODETYPE yyFallback[] = { 0, /* KEEP => nothing */ 0, /* PAGES => nothing */ 0, /* PAGESIZE => nothing */ + 0, /* TSDB_PAGESIZE => nothing */ 0, /* PRECISION => nothing */ 0, /* REPLICA => nothing */ 0, /* STRICT => nothing */ @@ -996,7 +1007,7 @@ static const YYCODETYPE yyFallback[] = { 0, /* WAL_RETENTION_SIZE => nothing */ 0, /* WAL_ROLL_PERIOD => nothing */ 0, /* WAL_SEGMENT_SIZE => nothing */ - 0, /* SST_TRIGGER => nothing */ + 0, /* STT_TRIGGER => nothing */ 0, /* TABLE_PREFIX => nothing */ 0, /* TABLE_SUFFIX => nothing */ 0, /* NK_COLON => nothing */ @@ -1165,58 +1176,58 @@ static const YYCODETYPE yyFallback[] = { 0, /* ASC => nothing */ 0, /* NULLS => nothing */ 0, /* ABORT => nothing */ - 255, /* AFTER => ABORT */ - 255, /* ATTACH => ABORT */ - 255, /* BEFORE => ABORT */ - 255, /* BEGIN => ABORT */ - 255, /* BITAND => ABORT */ - 255, /* BITNOT => ABORT */ - 255, /* BITOR => ABORT */ - 255, /* BLOCKS => ABORT */ - 255, /* CHANGE => ABORT */ - 255, /* COMMA => ABORT */ - 255, /* COMPACT => ABORT */ - 255, /* CONCAT => ABORT */ - 255, /* CONFLICT => ABORT */ - 255, /* COPY => ABORT */ - 255, /* DEFERRED => ABORT */ - 255, /* DELIMITERS => ABORT */ - 255, /* DETACH => ABORT */ - 255, /* DIVIDE => ABORT */ - 255, /* DOT => ABORT */ - 255, /* EACH => ABORT */ - 255, /* END => ABORT */ - 255, /* FAIL => ABORT */ - 255, /* FILE => ABORT */ - 255, /* FOR => ABORT */ - 255, /* GLOB => ABORT */ - 255, /* ID => ABORT */ - 255, /* IMMEDIATE => ABORT */ - 255, /* IMPORT => ABORT */ - 255, /* INITIALLY => ABORT */ - 255, /* INSTEAD => ABORT */ - 255, /* ISNULL => ABORT */ - 255, /* KEY => ABORT */ - 255, /* NK_BITNOT => ABORT */ - 255, /* NK_SEMI => ABORT */ - 255, /* NOTNULL => ABORT */ - 255, /* OF => ABORT */ - 255, /* PLUS => ABORT */ - 255, /* PRIVILEGE => ABORT */ - 255, /* RAISE => ABORT */ - 255, /* REPLACE => ABORT */ - 255, /* RESTRICT => ABORT */ - 255, /* ROW => ABORT */ - 255, /* SEMI => ABORT */ - 255, /* STAR => ABORT */ - 255, /* STATEMENT => ABORT */ - 255, /* STRING => ABORT */ - 255, /* TIMES => ABORT */ - 255, /* UPDATE => ABORT */ - 255, /* VALUES => ABORT */ - 255, /* VARIABLE => ABORT */ - 255, /* VIEW => ABORT */ - 255, /* WAL => ABORT */ + 256, /* AFTER => ABORT */ + 256, /* ATTACH => ABORT */ + 256, /* BEFORE => ABORT */ + 256, /* BEGIN => ABORT */ + 256, /* BITAND => ABORT */ + 256, /* BITNOT => ABORT */ + 256, /* BITOR => ABORT */ + 256, /* BLOCKS => ABORT */ + 256, /* CHANGE => ABORT */ + 256, /* COMMA => ABORT */ + 256, /* COMPACT => ABORT */ + 256, /* CONCAT => ABORT */ + 256, /* CONFLICT => ABORT */ + 256, /* COPY => ABORT */ + 256, /* DEFERRED => ABORT */ + 256, /* DELIMITERS => ABORT */ + 256, /* DETACH => ABORT */ + 256, /* DIVIDE => ABORT */ + 256, /* DOT => ABORT */ + 256, /* EACH => ABORT */ + 256, /* END => ABORT */ + 256, /* FAIL => ABORT */ + 256, /* FILE => ABORT */ + 256, /* FOR => ABORT */ + 256, /* GLOB => ABORT */ + 256, /* ID => ABORT */ + 256, /* IMMEDIATE => ABORT */ + 256, /* IMPORT => ABORT */ + 256, /* INITIALLY => ABORT */ + 256, /* INSTEAD => ABORT */ + 256, /* ISNULL => ABORT */ + 256, /* KEY => ABORT */ + 256, /* NK_BITNOT => ABORT */ + 256, /* NK_SEMI => ABORT */ + 256, /* NOTNULL => ABORT */ + 256, /* OF => ABORT */ + 256, /* PLUS => ABORT */ + 256, /* PRIVILEGE => ABORT */ + 256, /* RAISE => ABORT */ + 256, /* REPLACE => ABORT */ + 256, /* RESTRICT => ABORT */ + 256, /* ROW => ABORT */ + 256, /* SEMI => ABORT */ + 256, /* STAR => ABORT */ + 256, /* STATEMENT => ABORT */ + 256, /* STRING => ABORT */ + 256, /* TIMES => ABORT */ + 256, /* UPDATE => ABORT */ + 256, /* VALUES => ABORT */ + 256, /* VARIABLE => ABORT */ + 256, /* VIEW => ABORT */ + 256, /* WAL => ABORT */ }; #endif /* YYFALLBACK */ @@ -1378,361 +1389,362 @@ static const char *const yyTokenName[] = { /* 71 */ "KEEP", /* 72 */ "PAGES", /* 73 */ "PAGESIZE", - /* 74 */ "PRECISION", - /* 75 */ "REPLICA", - /* 76 */ "STRICT", - /* 77 */ "VGROUPS", - /* 78 */ "SINGLE_STABLE", - /* 79 */ "RETENTIONS", - /* 80 */ "SCHEMALESS", - /* 81 */ "WAL_LEVEL", - /* 82 */ "WAL_FSYNC_PERIOD", - /* 83 */ "WAL_RETENTION_PERIOD", - /* 84 */ "WAL_RETENTION_SIZE", - /* 85 */ "WAL_ROLL_PERIOD", - /* 86 */ "WAL_SEGMENT_SIZE", - /* 87 */ "SST_TRIGGER", - /* 88 */ "TABLE_PREFIX", - /* 89 */ "TABLE_SUFFIX", - /* 90 */ "NK_COLON", - /* 91 */ "TABLE", - /* 92 */ "NK_LP", - /* 93 */ "NK_RP", - /* 94 */ "STABLE", - /* 95 */ "ADD", - /* 96 */ "COLUMN", - /* 97 */ "MODIFY", - /* 98 */ "RENAME", - /* 99 */ "TAG", - /* 100 */ "SET", - /* 101 */ "NK_EQ", - /* 102 */ "USING", - /* 103 */ "TAGS", - /* 104 */ "COMMENT", - /* 105 */ "BOOL", - /* 106 */ "TINYINT", - /* 107 */ "SMALLINT", - /* 108 */ "INT", - /* 109 */ "INTEGER", - /* 110 */ "BIGINT", - /* 111 */ "FLOAT", - /* 112 */ "DOUBLE", - /* 113 */ "BINARY", - /* 114 */ "TIMESTAMP", - /* 115 */ "NCHAR", - /* 116 */ "UNSIGNED", - /* 117 */ "JSON", - /* 118 */ "VARCHAR", - /* 119 */ "MEDIUMBLOB", - /* 120 */ "BLOB", - /* 121 */ "VARBINARY", - /* 122 */ "DECIMAL", - /* 123 */ "MAX_DELAY", - /* 124 */ "WATERMARK", - /* 125 */ "ROLLUP", - /* 126 */ "TTL", - /* 127 */ "SMA", - /* 128 */ "FIRST", - /* 129 */ "LAST", - /* 130 */ "SHOW", - /* 131 */ "DATABASES", - /* 132 */ "TABLES", - /* 133 */ "STABLES", - /* 134 */ "MNODES", - /* 135 */ "MODULES", - /* 136 */ "QNODES", - /* 137 */ "FUNCTIONS", - /* 138 */ "INDEXES", - /* 139 */ "ACCOUNTS", - /* 140 */ "APPS", - /* 141 */ "CONNECTIONS", - /* 142 */ "LICENCES", - /* 143 */ "GRANTS", - /* 144 */ "QUERIES", - /* 145 */ "SCORES", - /* 146 */ "TOPICS", - /* 147 */ "VARIABLES", - /* 148 */ "BNODES", - /* 149 */ "SNODES", - /* 150 */ "CLUSTER", - /* 151 */ "TRANSACTIONS", - /* 152 */ "DISTRIBUTED", - /* 153 */ "CONSUMERS", - /* 154 */ "SUBSCRIPTIONS", - /* 155 */ "VNODES", - /* 156 */ "LIKE", - /* 157 */ "INDEX", - /* 158 */ "FUNCTION", - /* 159 */ "INTERVAL", - /* 160 */ "TOPIC", - /* 161 */ "AS", - /* 162 */ "WITH", - /* 163 */ "META", - /* 164 */ "CONSUMER", - /* 165 */ "GROUP", - /* 166 */ "DESC", - /* 167 */ "DESCRIBE", - /* 168 */ "RESET", - /* 169 */ "QUERY", - /* 170 */ "CACHE", - /* 171 */ "EXPLAIN", - /* 172 */ "ANALYZE", - /* 173 */ "VERBOSE", - /* 174 */ "NK_BOOL", - /* 175 */ "RATIO", - /* 176 */ "NK_FLOAT", - /* 177 */ "OUTPUTTYPE", - /* 178 */ "AGGREGATE", - /* 179 */ "BUFSIZE", - /* 180 */ "STREAM", - /* 181 */ "INTO", - /* 182 */ "TRIGGER", - /* 183 */ "AT_ONCE", - /* 184 */ "WINDOW_CLOSE", - /* 185 */ "IGNORE", - /* 186 */ "EXPIRED", - /* 187 */ "KILL", - /* 188 */ "CONNECTION", - /* 189 */ "TRANSACTION", - /* 190 */ "BALANCE", - /* 191 */ "VGROUP", - /* 192 */ "MERGE", - /* 193 */ "REDISTRIBUTE", - /* 194 */ "SPLIT", - /* 195 */ "DELETE", - /* 196 */ "INSERT", - /* 197 */ "NULL", - /* 198 */ "NK_QUESTION", - /* 199 */ "NK_ARROW", - /* 200 */ "ROWTS", - /* 201 */ "TBNAME", - /* 202 */ "QSTART", - /* 203 */ "QEND", - /* 204 */ "QDURATION", - /* 205 */ "WSTART", - /* 206 */ "WEND", - /* 207 */ "WDURATION", - /* 208 */ "CAST", - /* 209 */ "NOW", - /* 210 */ "TODAY", - /* 211 */ "TIMEZONE", - /* 212 */ "CLIENT_VERSION", - /* 213 */ "SERVER_VERSION", - /* 214 */ "SERVER_STATUS", - /* 215 */ "CURRENT_USER", - /* 216 */ "COUNT", - /* 217 */ "LAST_ROW", - /* 218 */ "BETWEEN", - /* 219 */ "IS", - /* 220 */ "NK_LT", - /* 221 */ "NK_GT", - /* 222 */ "NK_LE", - /* 223 */ "NK_GE", - /* 224 */ "NK_NE", - /* 225 */ "MATCH", - /* 226 */ "NMATCH", - /* 227 */ "CONTAINS", - /* 228 */ "IN", - /* 229 */ "JOIN", - /* 230 */ "INNER", - /* 231 */ "SELECT", - /* 232 */ "DISTINCT", - /* 233 */ "WHERE", - /* 234 */ "PARTITION", - /* 235 */ "BY", - /* 236 */ "SESSION", - /* 237 */ "STATE_WINDOW", - /* 238 */ "SLIDING", - /* 239 */ "FILL", - /* 240 */ "VALUE", - /* 241 */ "NONE", - /* 242 */ "PREV", - /* 243 */ "LINEAR", - /* 244 */ "NEXT", - /* 245 */ "HAVING", - /* 246 */ "RANGE", - /* 247 */ "EVERY", - /* 248 */ "ORDER", - /* 249 */ "SLIMIT", - /* 250 */ "SOFFSET", - /* 251 */ "LIMIT", - /* 252 */ "OFFSET", - /* 253 */ "ASC", - /* 254 */ "NULLS", - /* 255 */ "ABORT", - /* 256 */ "AFTER", - /* 257 */ "ATTACH", - /* 258 */ "BEFORE", - /* 259 */ "BEGIN", - /* 260 */ "BITAND", - /* 261 */ "BITNOT", - /* 262 */ "BITOR", - /* 263 */ "BLOCKS", - /* 264 */ "CHANGE", - /* 265 */ "COMMA", - /* 266 */ "COMPACT", - /* 267 */ "CONCAT", - /* 268 */ "CONFLICT", - /* 269 */ "COPY", - /* 270 */ "DEFERRED", - /* 271 */ "DELIMITERS", - /* 272 */ "DETACH", - /* 273 */ "DIVIDE", - /* 274 */ "DOT", - /* 275 */ "EACH", - /* 276 */ "END", - /* 277 */ "FAIL", - /* 278 */ "FILE", - /* 279 */ "FOR", - /* 280 */ "GLOB", - /* 281 */ "ID", - /* 282 */ "IMMEDIATE", - /* 283 */ "IMPORT", - /* 284 */ "INITIALLY", - /* 285 */ "INSTEAD", - /* 286 */ "ISNULL", - /* 287 */ "KEY", - /* 288 */ "NK_BITNOT", - /* 289 */ "NK_SEMI", - /* 290 */ "NOTNULL", - /* 291 */ "OF", - /* 292 */ "PLUS", - /* 293 */ "PRIVILEGE", - /* 294 */ "RAISE", - /* 295 */ "REPLACE", - /* 296 */ "RESTRICT", - /* 297 */ "ROW", - /* 298 */ "SEMI", - /* 299 */ "STAR", - /* 300 */ "STATEMENT", - /* 301 */ "STRING", - /* 302 */ "TIMES", - /* 303 */ "UPDATE", - /* 304 */ "VALUES", - /* 305 */ "VARIABLE", - /* 306 */ "VIEW", - /* 307 */ "WAL", - /* 308 */ "cmd", - /* 309 */ "account_options", - /* 310 */ "alter_account_options", - /* 311 */ "literal", - /* 312 */ "alter_account_option", - /* 313 */ "user_name", - /* 314 */ "sysinfo_opt", - /* 315 */ "privileges", - /* 316 */ "priv_level", - /* 317 */ "priv_type_list", - /* 318 */ "priv_type", - /* 319 */ "db_name", - /* 320 */ "dnode_endpoint", - /* 321 */ "not_exists_opt", - /* 322 */ "db_options", - /* 323 */ "exists_opt", - /* 324 */ "alter_db_options", - /* 325 */ "integer_list", - /* 326 */ "variable_list", - /* 327 */ "retention_list", - /* 328 */ "alter_db_option", - /* 329 */ "retention", - /* 330 */ "full_table_name", - /* 331 */ "column_def_list", - /* 332 */ "tags_def_opt", - /* 333 */ "table_options", - /* 334 */ "multi_create_clause", - /* 335 */ "tags_def", - /* 336 */ "multi_drop_clause", - /* 337 */ "alter_table_clause", - /* 338 */ "alter_table_options", - /* 339 */ "column_name", - /* 340 */ "type_name", - /* 341 */ "signed_literal", - /* 342 */ "create_subtable_clause", - /* 343 */ "specific_cols_opt", - /* 344 */ "expression_list", - /* 345 */ "drop_table_clause", - /* 346 */ "col_name_list", - /* 347 */ "table_name", - /* 348 */ "column_def", - /* 349 */ "duration_list", - /* 350 */ "rollup_func_list", - /* 351 */ "alter_table_option", - /* 352 */ "duration_literal", - /* 353 */ "rollup_func_name", - /* 354 */ "function_name", - /* 355 */ "col_name", - /* 356 */ "db_name_cond_opt", - /* 357 */ "like_pattern_opt", - /* 358 */ "table_name_cond", - /* 359 */ "from_db_opt", - /* 360 */ "index_options", - /* 361 */ "func_list", - /* 362 */ "sliding_opt", - /* 363 */ "sma_stream_opt", - /* 364 */ "func", - /* 365 */ "stream_options", - /* 366 */ "topic_name", - /* 367 */ "query_expression", - /* 368 */ "cgroup_name", - /* 369 */ "analyze_opt", - /* 370 */ "explain_options", - /* 371 */ "agg_func_opt", - /* 372 */ "bufsize_opt", - /* 373 */ "stream_name", - /* 374 */ "dnode_list", - /* 375 */ "where_clause_opt", - /* 376 */ "signed", - /* 377 */ "literal_func", - /* 378 */ "literal_list", - /* 379 */ "table_alias", - /* 380 */ "column_alias", - /* 381 */ "expression", - /* 382 */ "pseudo_column", - /* 383 */ "column_reference", - /* 384 */ "function_expression", - /* 385 */ "subquery", - /* 386 */ "star_func", - /* 387 */ "star_func_para_list", - /* 388 */ "noarg_func", - /* 389 */ "other_para_list", - /* 390 */ "star_func_para", - /* 391 */ "predicate", - /* 392 */ "compare_op", - /* 393 */ "in_op", - /* 394 */ "in_predicate_value", - /* 395 */ "boolean_value_expression", - /* 396 */ "boolean_primary", - /* 397 */ "common_expression", - /* 398 */ "from_clause_opt", - /* 399 */ "table_reference_list", - /* 400 */ "table_reference", - /* 401 */ "table_primary", - /* 402 */ "joined_table", - /* 403 */ "alias_opt", - /* 404 */ "parenthesized_joined_table", - /* 405 */ "join_type", - /* 406 */ "search_condition", - /* 407 */ "query_specification", - /* 408 */ "set_quantifier_opt", - /* 409 */ "select_list", - /* 410 */ "partition_by_clause_opt", - /* 411 */ "range_opt", - /* 412 */ "every_opt", - /* 413 */ "fill_opt", - /* 414 */ "twindow_clause_opt", - /* 415 */ "group_by_clause_opt", - /* 416 */ "having_clause_opt", - /* 417 */ "select_item", - /* 418 */ "fill_mode", - /* 419 */ "group_by_list", - /* 420 */ "query_expression_body", - /* 421 */ "order_by_clause_opt", - /* 422 */ "slimit_clause_opt", - /* 423 */ "limit_clause_opt", - /* 424 */ "query_primary", - /* 425 */ "sort_specification_list", - /* 426 */ "sort_specification", - /* 427 */ "ordering_specification_opt", - /* 428 */ "null_ordering_opt", + /* 74 */ "TSDB_PAGESIZE", + /* 75 */ "PRECISION", + /* 76 */ "REPLICA", + /* 77 */ "STRICT", + /* 78 */ "VGROUPS", + /* 79 */ "SINGLE_STABLE", + /* 80 */ "RETENTIONS", + /* 81 */ "SCHEMALESS", + /* 82 */ "WAL_LEVEL", + /* 83 */ "WAL_FSYNC_PERIOD", + /* 84 */ "WAL_RETENTION_PERIOD", + /* 85 */ "WAL_RETENTION_SIZE", + /* 86 */ "WAL_ROLL_PERIOD", + /* 87 */ "WAL_SEGMENT_SIZE", + /* 88 */ "STT_TRIGGER", + /* 89 */ "TABLE_PREFIX", + /* 90 */ "TABLE_SUFFIX", + /* 91 */ "NK_COLON", + /* 92 */ "TABLE", + /* 93 */ "NK_LP", + /* 94 */ "NK_RP", + /* 95 */ "STABLE", + /* 96 */ "ADD", + /* 97 */ "COLUMN", + /* 98 */ "MODIFY", + /* 99 */ "RENAME", + /* 100 */ "TAG", + /* 101 */ "SET", + /* 102 */ "NK_EQ", + /* 103 */ "USING", + /* 104 */ "TAGS", + /* 105 */ "COMMENT", + /* 106 */ "BOOL", + /* 107 */ "TINYINT", + /* 108 */ "SMALLINT", + /* 109 */ "INT", + /* 110 */ "INTEGER", + /* 111 */ "BIGINT", + /* 112 */ "FLOAT", + /* 113 */ "DOUBLE", + /* 114 */ "BINARY", + /* 115 */ "TIMESTAMP", + /* 116 */ "NCHAR", + /* 117 */ "UNSIGNED", + /* 118 */ "JSON", + /* 119 */ "VARCHAR", + /* 120 */ "MEDIUMBLOB", + /* 121 */ "BLOB", + /* 122 */ "VARBINARY", + /* 123 */ "DECIMAL", + /* 124 */ "MAX_DELAY", + /* 125 */ "WATERMARK", + /* 126 */ "ROLLUP", + /* 127 */ "TTL", + /* 128 */ "SMA", + /* 129 */ "FIRST", + /* 130 */ "LAST", + /* 131 */ "SHOW", + /* 132 */ "DATABASES", + /* 133 */ "TABLES", + /* 134 */ "STABLES", + /* 135 */ "MNODES", + /* 136 */ "MODULES", + /* 137 */ "QNODES", + /* 138 */ "FUNCTIONS", + /* 139 */ "INDEXES", + /* 140 */ "ACCOUNTS", + /* 141 */ "APPS", + /* 142 */ "CONNECTIONS", + /* 143 */ "LICENCES", + /* 144 */ "GRANTS", + /* 145 */ "QUERIES", + /* 146 */ "SCORES", + /* 147 */ "TOPICS", + /* 148 */ "VARIABLES", + /* 149 */ "BNODES", + /* 150 */ "SNODES", + /* 151 */ "CLUSTER", + /* 152 */ "TRANSACTIONS", + /* 153 */ "DISTRIBUTED", + /* 154 */ "CONSUMERS", + /* 155 */ "SUBSCRIPTIONS", + /* 156 */ "VNODES", + /* 157 */ "LIKE", + /* 158 */ "INDEX", + /* 159 */ "FUNCTION", + /* 160 */ "INTERVAL", + /* 161 */ "TOPIC", + /* 162 */ "AS", + /* 163 */ "WITH", + /* 164 */ "META", + /* 165 */ "CONSUMER", + /* 166 */ "GROUP", + /* 167 */ "DESC", + /* 168 */ "DESCRIBE", + /* 169 */ "RESET", + /* 170 */ "QUERY", + /* 171 */ "CACHE", + /* 172 */ "EXPLAIN", + /* 173 */ "ANALYZE", + /* 174 */ "VERBOSE", + /* 175 */ "NK_BOOL", + /* 176 */ "RATIO", + /* 177 */ "NK_FLOAT", + /* 178 */ "OUTPUTTYPE", + /* 179 */ "AGGREGATE", + /* 180 */ "BUFSIZE", + /* 181 */ "STREAM", + /* 182 */ "INTO", + /* 183 */ "TRIGGER", + /* 184 */ "AT_ONCE", + /* 185 */ "WINDOW_CLOSE", + /* 186 */ "IGNORE", + /* 187 */ "EXPIRED", + /* 188 */ "KILL", + /* 189 */ "CONNECTION", + /* 190 */ "TRANSACTION", + /* 191 */ "BALANCE", + /* 192 */ "VGROUP", + /* 193 */ "MERGE", + /* 194 */ "REDISTRIBUTE", + /* 195 */ "SPLIT", + /* 196 */ "DELETE", + /* 197 */ "INSERT", + /* 198 */ "NULL", + /* 199 */ "NK_QUESTION", + /* 200 */ "NK_ARROW", + /* 201 */ "ROWTS", + /* 202 */ "TBNAME", + /* 203 */ "QSTART", + /* 204 */ "QEND", + /* 205 */ "QDURATION", + /* 206 */ "WSTART", + /* 207 */ "WEND", + /* 208 */ "WDURATION", + /* 209 */ "CAST", + /* 210 */ "NOW", + /* 211 */ "TODAY", + /* 212 */ "TIMEZONE", + /* 213 */ "CLIENT_VERSION", + /* 214 */ "SERVER_VERSION", + /* 215 */ "SERVER_STATUS", + /* 216 */ "CURRENT_USER", + /* 217 */ "COUNT", + /* 218 */ "LAST_ROW", + /* 219 */ "BETWEEN", + /* 220 */ "IS", + /* 221 */ "NK_LT", + /* 222 */ "NK_GT", + /* 223 */ "NK_LE", + /* 224 */ "NK_GE", + /* 225 */ "NK_NE", + /* 226 */ "MATCH", + /* 227 */ "NMATCH", + /* 228 */ "CONTAINS", + /* 229 */ "IN", + /* 230 */ "JOIN", + /* 231 */ "INNER", + /* 232 */ "SELECT", + /* 233 */ "DISTINCT", + /* 234 */ "WHERE", + /* 235 */ "PARTITION", + /* 236 */ "BY", + /* 237 */ "SESSION", + /* 238 */ "STATE_WINDOW", + /* 239 */ "SLIDING", + /* 240 */ "FILL", + /* 241 */ "VALUE", + /* 242 */ "NONE", + /* 243 */ "PREV", + /* 244 */ "LINEAR", + /* 245 */ "NEXT", + /* 246 */ "HAVING", + /* 247 */ "RANGE", + /* 248 */ "EVERY", + /* 249 */ "ORDER", + /* 250 */ "SLIMIT", + /* 251 */ "SOFFSET", + /* 252 */ "LIMIT", + /* 253 */ "OFFSET", + /* 254 */ "ASC", + /* 255 */ "NULLS", + /* 256 */ "ABORT", + /* 257 */ "AFTER", + /* 258 */ "ATTACH", + /* 259 */ "BEFORE", + /* 260 */ "BEGIN", + /* 261 */ "BITAND", + /* 262 */ "BITNOT", + /* 263 */ "BITOR", + /* 264 */ "BLOCKS", + /* 265 */ "CHANGE", + /* 266 */ "COMMA", + /* 267 */ "COMPACT", + /* 268 */ "CONCAT", + /* 269 */ "CONFLICT", + /* 270 */ "COPY", + /* 271 */ "DEFERRED", + /* 272 */ "DELIMITERS", + /* 273 */ "DETACH", + /* 274 */ "DIVIDE", + /* 275 */ "DOT", + /* 276 */ "EACH", + /* 277 */ "END", + /* 278 */ "FAIL", + /* 279 */ "FILE", + /* 280 */ "FOR", + /* 281 */ "GLOB", + /* 282 */ "ID", + /* 283 */ "IMMEDIATE", + /* 284 */ "IMPORT", + /* 285 */ "INITIALLY", + /* 286 */ "INSTEAD", + /* 287 */ "ISNULL", + /* 288 */ "KEY", + /* 289 */ "NK_BITNOT", + /* 290 */ "NK_SEMI", + /* 291 */ "NOTNULL", + /* 292 */ "OF", + /* 293 */ "PLUS", + /* 294 */ "PRIVILEGE", + /* 295 */ "RAISE", + /* 296 */ "REPLACE", + /* 297 */ "RESTRICT", + /* 298 */ "ROW", + /* 299 */ "SEMI", + /* 300 */ "STAR", + /* 301 */ "STATEMENT", + /* 302 */ "STRING", + /* 303 */ "TIMES", + /* 304 */ "UPDATE", + /* 305 */ "VALUES", + /* 306 */ "VARIABLE", + /* 307 */ "VIEW", + /* 308 */ "WAL", + /* 309 */ "cmd", + /* 310 */ "account_options", + /* 311 */ "alter_account_options", + /* 312 */ "literal", + /* 313 */ "alter_account_option", + /* 314 */ "user_name", + /* 315 */ "sysinfo_opt", + /* 316 */ "privileges", + /* 317 */ "priv_level", + /* 318 */ "priv_type_list", + /* 319 */ "priv_type", + /* 320 */ "db_name", + /* 321 */ "dnode_endpoint", + /* 322 */ "not_exists_opt", + /* 323 */ "db_options", + /* 324 */ "exists_opt", + /* 325 */ "alter_db_options", + /* 326 */ "integer_list", + /* 327 */ "variable_list", + /* 328 */ "retention_list", + /* 329 */ "alter_db_option", + /* 330 */ "retention", + /* 331 */ "full_table_name", + /* 332 */ "column_def_list", + /* 333 */ "tags_def_opt", + /* 334 */ "table_options", + /* 335 */ "multi_create_clause", + /* 336 */ "tags_def", + /* 337 */ "multi_drop_clause", + /* 338 */ "alter_table_clause", + /* 339 */ "alter_table_options", + /* 340 */ "column_name", + /* 341 */ "type_name", + /* 342 */ "signed_literal", + /* 343 */ "create_subtable_clause", + /* 344 */ "specific_cols_opt", + /* 345 */ "expression_list", + /* 346 */ "drop_table_clause", + /* 347 */ "col_name_list", + /* 348 */ "table_name", + /* 349 */ "column_def", + /* 350 */ "duration_list", + /* 351 */ "rollup_func_list", + /* 352 */ "alter_table_option", + /* 353 */ "duration_literal", + /* 354 */ "rollup_func_name", + /* 355 */ "function_name", + /* 356 */ "col_name", + /* 357 */ "db_name_cond_opt", + /* 358 */ "like_pattern_opt", + /* 359 */ "table_name_cond", + /* 360 */ "from_db_opt", + /* 361 */ "index_options", + /* 362 */ "func_list", + /* 363 */ "sliding_opt", + /* 364 */ "sma_stream_opt", + /* 365 */ "func", + /* 366 */ "stream_options", + /* 367 */ "topic_name", + /* 368 */ "query_expression", + /* 369 */ "cgroup_name", + /* 370 */ "analyze_opt", + /* 371 */ "explain_options", + /* 372 */ "agg_func_opt", + /* 373 */ "bufsize_opt", + /* 374 */ "stream_name", + /* 375 */ "dnode_list", + /* 376 */ "where_clause_opt", + /* 377 */ "signed", + /* 378 */ "literal_func", + /* 379 */ "literal_list", + /* 380 */ "table_alias", + /* 381 */ "column_alias", + /* 382 */ "expression", + /* 383 */ "pseudo_column", + /* 384 */ "column_reference", + /* 385 */ "function_expression", + /* 386 */ "subquery", + /* 387 */ "star_func", + /* 388 */ "star_func_para_list", + /* 389 */ "noarg_func", + /* 390 */ "other_para_list", + /* 391 */ "star_func_para", + /* 392 */ "predicate", + /* 393 */ "compare_op", + /* 394 */ "in_op", + /* 395 */ "in_predicate_value", + /* 396 */ "boolean_value_expression", + /* 397 */ "boolean_primary", + /* 398 */ "common_expression", + /* 399 */ "from_clause_opt", + /* 400 */ "table_reference_list", + /* 401 */ "table_reference", + /* 402 */ "table_primary", + /* 403 */ "joined_table", + /* 404 */ "alias_opt", + /* 405 */ "parenthesized_joined_table", + /* 406 */ "join_type", + /* 407 */ "search_condition", + /* 408 */ "query_specification", + /* 409 */ "set_quantifier_opt", + /* 410 */ "select_list", + /* 411 */ "partition_by_clause_opt", + /* 412 */ "range_opt", + /* 413 */ "every_opt", + /* 414 */ "fill_opt", + /* 415 */ "twindow_clause_opt", + /* 416 */ "group_by_clause_opt", + /* 417 */ "having_clause_opt", + /* 418 */ "select_item", + /* 419 */ "fill_mode", + /* 420 */ "group_by_list", + /* 421 */ "query_expression_body", + /* 422 */ "order_by_clause_opt", + /* 423 */ "slimit_clause_opt", + /* 424 */ "limit_clause_opt", + /* 425 */ "query_primary", + /* 426 */ "sort_specification_list", + /* 427 */ "sort_specification", + /* 428 */ "ordering_specification_opt", + /* 429 */ "null_ordering_opt", }; #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */ @@ -1825,416 +1837,417 @@ static const char *const yyRuleName[] = { /* 82 */ "db_options ::= db_options KEEP variable_list", /* 83 */ "db_options ::= db_options PAGES NK_INTEGER", /* 84 */ "db_options ::= db_options PAGESIZE NK_INTEGER", - /* 85 */ "db_options ::= db_options PRECISION NK_STRING", - /* 86 */ "db_options ::= db_options REPLICA NK_INTEGER", - /* 87 */ "db_options ::= db_options STRICT NK_STRING", - /* 88 */ "db_options ::= db_options VGROUPS NK_INTEGER", - /* 89 */ "db_options ::= db_options SINGLE_STABLE NK_INTEGER", - /* 90 */ "db_options ::= db_options RETENTIONS retention_list", - /* 91 */ "db_options ::= db_options SCHEMALESS NK_INTEGER", - /* 92 */ "db_options ::= db_options WAL_LEVEL NK_INTEGER", - /* 93 */ "db_options ::= db_options WAL_FSYNC_PERIOD NK_INTEGER", - /* 94 */ "db_options ::= db_options WAL_RETENTION_PERIOD NK_INTEGER", - /* 95 */ "db_options ::= db_options WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER", - /* 96 */ "db_options ::= db_options WAL_RETENTION_SIZE NK_INTEGER", - /* 97 */ "db_options ::= db_options WAL_RETENTION_SIZE NK_MINUS NK_INTEGER", - /* 98 */ "db_options ::= db_options WAL_ROLL_PERIOD NK_INTEGER", - /* 99 */ "db_options ::= db_options WAL_SEGMENT_SIZE NK_INTEGER", - /* 100 */ "db_options ::= db_options SST_TRIGGER NK_INTEGER", - /* 101 */ "db_options ::= db_options TABLE_PREFIX NK_INTEGER", - /* 102 */ "db_options ::= db_options TABLE_SUFFIX NK_INTEGER", - /* 103 */ "alter_db_options ::= alter_db_option", - /* 104 */ "alter_db_options ::= alter_db_options alter_db_option", - /* 105 */ "alter_db_option ::= CACHEMODEL NK_STRING", - /* 106 */ "alter_db_option ::= CACHESIZE NK_INTEGER", - /* 107 */ "alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER", - /* 108 */ "alter_db_option ::= KEEP integer_list", - /* 109 */ "alter_db_option ::= KEEP variable_list", - /* 110 */ "alter_db_option ::= WAL_LEVEL NK_INTEGER", - /* 111 */ "alter_db_option ::= SST_TRIGGER NK_INTEGER", - /* 112 */ "integer_list ::= NK_INTEGER", - /* 113 */ "integer_list ::= integer_list NK_COMMA NK_INTEGER", - /* 114 */ "variable_list ::= NK_VARIABLE", - /* 115 */ "variable_list ::= variable_list NK_COMMA NK_VARIABLE", - /* 116 */ "retention_list ::= retention", - /* 117 */ "retention_list ::= retention_list NK_COMMA retention", - /* 118 */ "retention ::= NK_VARIABLE NK_COLON NK_VARIABLE", - /* 119 */ "cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options", - /* 120 */ "cmd ::= CREATE TABLE multi_create_clause", - /* 121 */ "cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options", - /* 122 */ "cmd ::= DROP TABLE multi_drop_clause", - /* 123 */ "cmd ::= DROP STABLE exists_opt full_table_name", - /* 124 */ "cmd ::= ALTER TABLE alter_table_clause", - /* 125 */ "cmd ::= ALTER STABLE alter_table_clause", - /* 126 */ "alter_table_clause ::= full_table_name alter_table_options", - /* 127 */ "alter_table_clause ::= full_table_name ADD COLUMN column_name type_name", - /* 128 */ "alter_table_clause ::= full_table_name DROP COLUMN column_name", - /* 129 */ "alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name", - /* 130 */ "alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name", - /* 131 */ "alter_table_clause ::= full_table_name ADD TAG column_name type_name", - /* 132 */ "alter_table_clause ::= full_table_name DROP TAG column_name", - /* 133 */ "alter_table_clause ::= full_table_name MODIFY TAG column_name type_name", - /* 134 */ "alter_table_clause ::= full_table_name RENAME TAG column_name column_name", - /* 135 */ "alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal", - /* 136 */ "multi_create_clause ::= create_subtable_clause", - /* 137 */ "multi_create_clause ::= multi_create_clause create_subtable_clause", - /* 138 */ "create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP expression_list NK_RP table_options", - /* 139 */ "multi_drop_clause ::= drop_table_clause", - /* 140 */ "multi_drop_clause ::= multi_drop_clause drop_table_clause", - /* 141 */ "drop_table_clause ::= exists_opt full_table_name", - /* 142 */ "specific_cols_opt ::=", - /* 143 */ "specific_cols_opt ::= NK_LP col_name_list NK_RP", - /* 144 */ "full_table_name ::= table_name", - /* 145 */ "full_table_name ::= db_name NK_DOT table_name", - /* 146 */ "column_def_list ::= column_def", - /* 147 */ "column_def_list ::= column_def_list NK_COMMA column_def", - /* 148 */ "column_def ::= column_name type_name", - /* 149 */ "column_def ::= column_name type_name COMMENT NK_STRING", - /* 150 */ "type_name ::= BOOL", - /* 151 */ "type_name ::= TINYINT", - /* 152 */ "type_name ::= SMALLINT", - /* 153 */ "type_name ::= INT", - /* 154 */ "type_name ::= INTEGER", - /* 155 */ "type_name ::= BIGINT", - /* 156 */ "type_name ::= FLOAT", - /* 157 */ "type_name ::= DOUBLE", - /* 158 */ "type_name ::= BINARY NK_LP NK_INTEGER NK_RP", - /* 159 */ "type_name ::= TIMESTAMP", - /* 160 */ "type_name ::= NCHAR NK_LP NK_INTEGER NK_RP", - /* 161 */ "type_name ::= TINYINT UNSIGNED", - /* 162 */ "type_name ::= SMALLINT UNSIGNED", - /* 163 */ "type_name ::= INT UNSIGNED", - /* 164 */ "type_name ::= BIGINT UNSIGNED", - /* 165 */ "type_name ::= JSON", - /* 166 */ "type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP", - /* 167 */ "type_name ::= MEDIUMBLOB", - /* 168 */ "type_name ::= BLOB", - /* 169 */ "type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP", - /* 170 */ "type_name ::= DECIMAL", - /* 171 */ "type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP", - /* 172 */ "type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP", - /* 173 */ "tags_def_opt ::=", - /* 174 */ "tags_def_opt ::= tags_def", - /* 175 */ "tags_def ::= TAGS NK_LP column_def_list NK_RP", - /* 176 */ "table_options ::=", - /* 177 */ "table_options ::= table_options COMMENT NK_STRING", - /* 178 */ "table_options ::= table_options MAX_DELAY duration_list", - /* 179 */ "table_options ::= table_options WATERMARK duration_list", - /* 180 */ "table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP", - /* 181 */ "table_options ::= table_options TTL NK_INTEGER", - /* 182 */ "table_options ::= table_options SMA NK_LP col_name_list NK_RP", - /* 183 */ "alter_table_options ::= alter_table_option", - /* 184 */ "alter_table_options ::= alter_table_options alter_table_option", - /* 185 */ "alter_table_option ::= COMMENT NK_STRING", - /* 186 */ "alter_table_option ::= TTL NK_INTEGER", - /* 187 */ "duration_list ::= duration_literal", - /* 188 */ "duration_list ::= duration_list NK_COMMA duration_literal", - /* 189 */ "rollup_func_list ::= rollup_func_name", - /* 190 */ "rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name", - /* 191 */ "rollup_func_name ::= function_name", - /* 192 */ "rollup_func_name ::= FIRST", - /* 193 */ "rollup_func_name ::= LAST", - /* 194 */ "col_name_list ::= col_name", - /* 195 */ "col_name_list ::= col_name_list NK_COMMA col_name", - /* 196 */ "col_name ::= column_name", - /* 197 */ "cmd ::= SHOW DNODES", - /* 198 */ "cmd ::= SHOW USERS", - /* 199 */ "cmd ::= SHOW DATABASES", - /* 200 */ "cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt", - /* 201 */ "cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt", - /* 202 */ "cmd ::= SHOW db_name_cond_opt VGROUPS", - /* 203 */ "cmd ::= SHOW MNODES", - /* 204 */ "cmd ::= SHOW MODULES", - /* 205 */ "cmd ::= SHOW QNODES", - /* 206 */ "cmd ::= SHOW FUNCTIONS", - /* 207 */ "cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt", - /* 208 */ "cmd ::= SHOW STREAMS", - /* 209 */ "cmd ::= SHOW ACCOUNTS", - /* 210 */ "cmd ::= SHOW APPS", - /* 211 */ "cmd ::= SHOW CONNECTIONS", - /* 212 */ "cmd ::= SHOW LICENCES", - /* 213 */ "cmd ::= SHOW GRANTS", - /* 214 */ "cmd ::= SHOW CREATE DATABASE db_name", - /* 215 */ "cmd ::= SHOW CREATE TABLE full_table_name", - /* 216 */ "cmd ::= SHOW CREATE STABLE full_table_name", - /* 217 */ "cmd ::= SHOW QUERIES", - /* 218 */ "cmd ::= SHOW SCORES", - /* 219 */ "cmd ::= SHOW TOPICS", - /* 220 */ "cmd ::= SHOW VARIABLES", - /* 221 */ "cmd ::= SHOW LOCAL VARIABLES", - /* 222 */ "cmd ::= SHOW DNODE NK_INTEGER VARIABLES", - /* 223 */ "cmd ::= SHOW BNODES", - /* 224 */ "cmd ::= SHOW SNODES", - /* 225 */ "cmd ::= SHOW CLUSTER", - /* 226 */ "cmd ::= SHOW TRANSACTIONS", - /* 227 */ "cmd ::= SHOW TABLE DISTRIBUTED full_table_name", - /* 228 */ "cmd ::= SHOW CONSUMERS", - /* 229 */ "cmd ::= SHOW SUBSCRIPTIONS", - /* 230 */ "cmd ::= SHOW TAGS FROM table_name_cond from_db_opt", - /* 231 */ "cmd ::= SHOW VNODES NK_INTEGER", - /* 232 */ "cmd ::= SHOW VNODES NK_STRING", - /* 233 */ "db_name_cond_opt ::=", - /* 234 */ "db_name_cond_opt ::= db_name NK_DOT", - /* 235 */ "like_pattern_opt ::=", - /* 236 */ "like_pattern_opt ::= LIKE NK_STRING", - /* 237 */ "table_name_cond ::= table_name", - /* 238 */ "from_db_opt ::=", - /* 239 */ "from_db_opt ::= FROM db_name", - /* 240 */ "cmd ::= CREATE SMA INDEX not_exists_opt full_table_name ON full_table_name index_options", - /* 241 */ "cmd ::= DROP INDEX exists_opt full_table_name", - /* 242 */ "index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt", - /* 243 */ "index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt", - /* 244 */ "func_list ::= func", - /* 245 */ "func_list ::= func_list NK_COMMA func", - /* 246 */ "func ::= function_name NK_LP expression_list NK_RP", - /* 247 */ "sma_stream_opt ::=", - /* 248 */ "sma_stream_opt ::= stream_options WATERMARK duration_literal", - /* 249 */ "sma_stream_opt ::= stream_options MAX_DELAY duration_literal", - /* 250 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression", - /* 251 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name", - /* 252 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS DATABASE db_name", - /* 253 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name", - /* 254 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS STABLE full_table_name", - /* 255 */ "cmd ::= DROP TOPIC exists_opt topic_name", - /* 256 */ "cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name", - /* 257 */ "cmd ::= DESC full_table_name", - /* 258 */ "cmd ::= DESCRIBE full_table_name", - /* 259 */ "cmd ::= RESET QUERY CACHE", - /* 260 */ "cmd ::= EXPLAIN analyze_opt explain_options query_expression", - /* 261 */ "analyze_opt ::=", - /* 262 */ "analyze_opt ::= ANALYZE", - /* 263 */ "explain_options ::=", - /* 264 */ "explain_options ::= explain_options VERBOSE NK_BOOL", - /* 265 */ "explain_options ::= explain_options RATIO NK_FLOAT", - /* 266 */ "cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt", - /* 267 */ "cmd ::= DROP FUNCTION exists_opt function_name", - /* 268 */ "agg_func_opt ::=", - /* 269 */ "agg_func_opt ::= AGGREGATE", - /* 270 */ "bufsize_opt ::=", - /* 271 */ "bufsize_opt ::= BUFSIZE NK_INTEGER", - /* 272 */ "cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name AS query_expression", - /* 273 */ "cmd ::= DROP STREAM exists_opt stream_name", - /* 274 */ "stream_options ::=", - /* 275 */ "stream_options ::= stream_options TRIGGER AT_ONCE", - /* 276 */ "stream_options ::= stream_options TRIGGER WINDOW_CLOSE", - /* 277 */ "stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal", - /* 278 */ "stream_options ::= stream_options WATERMARK duration_literal", - /* 279 */ "stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER", - /* 280 */ "cmd ::= KILL CONNECTION NK_INTEGER", - /* 281 */ "cmd ::= KILL QUERY NK_STRING", - /* 282 */ "cmd ::= KILL TRANSACTION NK_INTEGER", - /* 283 */ "cmd ::= BALANCE VGROUP", - /* 284 */ "cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER", - /* 285 */ "cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list", - /* 286 */ "cmd ::= SPLIT VGROUP NK_INTEGER", - /* 287 */ "dnode_list ::= DNODE NK_INTEGER", - /* 288 */ "dnode_list ::= dnode_list DNODE NK_INTEGER", - /* 289 */ "cmd ::= DELETE FROM full_table_name where_clause_opt", - /* 290 */ "cmd ::= query_expression", - /* 291 */ "cmd ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_expression", - /* 292 */ "cmd ::= INSERT INTO full_table_name query_expression", - /* 293 */ "literal ::= NK_INTEGER", - /* 294 */ "literal ::= NK_FLOAT", - /* 295 */ "literal ::= NK_STRING", - /* 296 */ "literal ::= NK_BOOL", - /* 297 */ "literal ::= TIMESTAMP NK_STRING", - /* 298 */ "literal ::= duration_literal", - /* 299 */ "literal ::= NULL", - /* 300 */ "literal ::= NK_QUESTION", - /* 301 */ "duration_literal ::= NK_VARIABLE", - /* 302 */ "signed ::= NK_INTEGER", - /* 303 */ "signed ::= NK_PLUS NK_INTEGER", - /* 304 */ "signed ::= NK_MINUS NK_INTEGER", - /* 305 */ "signed ::= NK_FLOAT", - /* 306 */ "signed ::= NK_PLUS NK_FLOAT", - /* 307 */ "signed ::= NK_MINUS NK_FLOAT", - /* 308 */ "signed_literal ::= signed", - /* 309 */ "signed_literal ::= NK_STRING", - /* 310 */ "signed_literal ::= NK_BOOL", - /* 311 */ "signed_literal ::= TIMESTAMP NK_STRING", - /* 312 */ "signed_literal ::= duration_literal", - /* 313 */ "signed_literal ::= NULL", - /* 314 */ "signed_literal ::= literal_func", - /* 315 */ "signed_literal ::= NK_QUESTION", - /* 316 */ "literal_list ::= signed_literal", - /* 317 */ "literal_list ::= literal_list NK_COMMA signed_literal", - /* 318 */ "db_name ::= NK_ID", - /* 319 */ "table_name ::= NK_ID", - /* 320 */ "column_name ::= NK_ID", - /* 321 */ "function_name ::= NK_ID", - /* 322 */ "table_alias ::= NK_ID", - /* 323 */ "column_alias ::= NK_ID", - /* 324 */ "user_name ::= NK_ID", - /* 325 */ "topic_name ::= NK_ID", - /* 326 */ "stream_name ::= NK_ID", - /* 327 */ "cgroup_name ::= NK_ID", - /* 328 */ "expression ::= literal", - /* 329 */ "expression ::= pseudo_column", - /* 330 */ "expression ::= column_reference", - /* 331 */ "expression ::= function_expression", - /* 332 */ "expression ::= subquery", - /* 333 */ "expression ::= NK_LP expression NK_RP", - /* 334 */ "expression ::= NK_PLUS expression", - /* 335 */ "expression ::= NK_MINUS expression", - /* 336 */ "expression ::= expression NK_PLUS expression", - /* 337 */ "expression ::= expression NK_MINUS expression", - /* 338 */ "expression ::= expression NK_STAR expression", - /* 339 */ "expression ::= expression NK_SLASH expression", - /* 340 */ "expression ::= expression NK_REM expression", - /* 341 */ "expression ::= column_reference NK_ARROW NK_STRING", - /* 342 */ "expression ::= expression NK_BITAND expression", - /* 343 */ "expression ::= expression NK_BITOR expression", - /* 344 */ "expression_list ::= expression", - /* 345 */ "expression_list ::= expression_list NK_COMMA expression", - /* 346 */ "column_reference ::= column_name", - /* 347 */ "column_reference ::= table_name NK_DOT column_name", - /* 348 */ "pseudo_column ::= ROWTS", - /* 349 */ "pseudo_column ::= TBNAME", - /* 350 */ "pseudo_column ::= table_name NK_DOT TBNAME", - /* 351 */ "pseudo_column ::= QSTART", - /* 352 */ "pseudo_column ::= QEND", - /* 353 */ "pseudo_column ::= QDURATION", - /* 354 */ "pseudo_column ::= WSTART", - /* 355 */ "pseudo_column ::= WEND", - /* 356 */ "pseudo_column ::= WDURATION", - /* 357 */ "function_expression ::= function_name NK_LP expression_list NK_RP", - /* 358 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP", - /* 359 */ "function_expression ::= CAST NK_LP expression AS type_name NK_RP", - /* 360 */ "function_expression ::= literal_func", - /* 361 */ "literal_func ::= noarg_func NK_LP NK_RP", - /* 362 */ "literal_func ::= NOW", - /* 363 */ "noarg_func ::= NOW", - /* 364 */ "noarg_func ::= TODAY", - /* 365 */ "noarg_func ::= TIMEZONE", - /* 366 */ "noarg_func ::= DATABASE", - /* 367 */ "noarg_func ::= CLIENT_VERSION", - /* 368 */ "noarg_func ::= SERVER_VERSION", - /* 369 */ "noarg_func ::= SERVER_STATUS", - /* 370 */ "noarg_func ::= CURRENT_USER", - /* 371 */ "noarg_func ::= USER", - /* 372 */ "star_func ::= COUNT", - /* 373 */ "star_func ::= FIRST", - /* 374 */ "star_func ::= LAST", - /* 375 */ "star_func ::= LAST_ROW", - /* 376 */ "star_func_para_list ::= NK_STAR", - /* 377 */ "star_func_para_list ::= other_para_list", - /* 378 */ "other_para_list ::= star_func_para", - /* 379 */ "other_para_list ::= other_para_list NK_COMMA star_func_para", - /* 380 */ "star_func_para ::= expression", - /* 381 */ "star_func_para ::= table_name NK_DOT NK_STAR", - /* 382 */ "predicate ::= expression compare_op expression", - /* 383 */ "predicate ::= expression BETWEEN expression AND expression", - /* 384 */ "predicate ::= expression NOT BETWEEN expression AND expression", - /* 385 */ "predicate ::= expression IS NULL", - /* 386 */ "predicate ::= expression IS NOT NULL", - /* 387 */ "predicate ::= expression in_op in_predicate_value", - /* 388 */ "compare_op ::= NK_LT", - /* 389 */ "compare_op ::= NK_GT", - /* 390 */ "compare_op ::= NK_LE", - /* 391 */ "compare_op ::= NK_GE", - /* 392 */ "compare_op ::= NK_NE", - /* 393 */ "compare_op ::= NK_EQ", - /* 394 */ "compare_op ::= LIKE", - /* 395 */ "compare_op ::= NOT LIKE", - /* 396 */ "compare_op ::= MATCH", - /* 397 */ "compare_op ::= NMATCH", - /* 398 */ "compare_op ::= CONTAINS", - /* 399 */ "in_op ::= IN", - /* 400 */ "in_op ::= NOT IN", - /* 401 */ "in_predicate_value ::= NK_LP literal_list NK_RP", - /* 402 */ "boolean_value_expression ::= boolean_primary", - /* 403 */ "boolean_value_expression ::= NOT boolean_primary", - /* 404 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression", - /* 405 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression", - /* 406 */ "boolean_primary ::= predicate", - /* 407 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP", - /* 408 */ "common_expression ::= expression", - /* 409 */ "common_expression ::= boolean_value_expression", - /* 410 */ "from_clause_opt ::=", - /* 411 */ "from_clause_opt ::= FROM table_reference_list", - /* 412 */ "table_reference_list ::= table_reference", - /* 413 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference", - /* 414 */ "table_reference ::= table_primary", - /* 415 */ "table_reference ::= joined_table", - /* 416 */ "table_primary ::= table_name alias_opt", - /* 417 */ "table_primary ::= db_name NK_DOT table_name alias_opt", - /* 418 */ "table_primary ::= subquery alias_opt", - /* 419 */ "table_primary ::= parenthesized_joined_table", - /* 420 */ "alias_opt ::=", - /* 421 */ "alias_opt ::= table_alias", - /* 422 */ "alias_opt ::= AS table_alias", - /* 423 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP", - /* 424 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP", - /* 425 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition", - /* 426 */ "join_type ::=", - /* 427 */ "join_type ::= INNER", - /* 428 */ "query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt", - /* 429 */ "set_quantifier_opt ::=", - /* 430 */ "set_quantifier_opt ::= DISTINCT", - /* 431 */ "set_quantifier_opt ::= ALL", - /* 432 */ "select_list ::= select_item", - /* 433 */ "select_list ::= select_list NK_COMMA select_item", - /* 434 */ "select_item ::= NK_STAR", - /* 435 */ "select_item ::= common_expression", - /* 436 */ "select_item ::= common_expression column_alias", - /* 437 */ "select_item ::= common_expression AS column_alias", - /* 438 */ "select_item ::= table_name NK_DOT NK_STAR", - /* 439 */ "where_clause_opt ::=", - /* 440 */ "where_clause_opt ::= WHERE search_condition", - /* 441 */ "partition_by_clause_opt ::=", - /* 442 */ "partition_by_clause_opt ::= PARTITION BY expression_list", - /* 443 */ "twindow_clause_opt ::=", - /* 444 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP", - /* 445 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP", - /* 446 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt", - /* 447 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt", - /* 448 */ "sliding_opt ::=", - /* 449 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP", - /* 450 */ "fill_opt ::=", - /* 451 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", - /* 452 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP", - /* 453 */ "fill_mode ::= NONE", - /* 454 */ "fill_mode ::= PREV", - /* 455 */ "fill_mode ::= NULL", - /* 456 */ "fill_mode ::= LINEAR", - /* 457 */ "fill_mode ::= NEXT", - /* 458 */ "group_by_clause_opt ::=", - /* 459 */ "group_by_clause_opt ::= GROUP BY group_by_list", - /* 460 */ "group_by_list ::= expression", - /* 461 */ "group_by_list ::= group_by_list NK_COMMA expression", - /* 462 */ "having_clause_opt ::=", - /* 463 */ "having_clause_opt ::= HAVING search_condition", - /* 464 */ "range_opt ::=", - /* 465 */ "range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP", - /* 466 */ "every_opt ::=", - /* 467 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP", - /* 468 */ "query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt", - /* 469 */ "query_expression_body ::= query_primary", - /* 470 */ "query_expression_body ::= query_expression_body UNION ALL query_expression_body", - /* 471 */ "query_expression_body ::= query_expression_body UNION query_expression_body", - /* 472 */ "query_primary ::= query_specification", - /* 473 */ "query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP", - /* 474 */ "order_by_clause_opt ::=", - /* 475 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", - /* 476 */ "slimit_clause_opt ::=", - /* 477 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", - /* 478 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", - /* 479 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 480 */ "limit_clause_opt ::=", - /* 481 */ "limit_clause_opt ::= LIMIT NK_INTEGER", - /* 482 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", - /* 483 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 484 */ "subquery ::= NK_LP query_expression NK_RP", - /* 485 */ "search_condition ::= common_expression", - /* 486 */ "sort_specification_list ::= sort_specification", - /* 487 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", - /* 488 */ "sort_specification ::= expression ordering_specification_opt null_ordering_opt", - /* 489 */ "ordering_specification_opt ::=", - /* 490 */ "ordering_specification_opt ::= ASC", - /* 491 */ "ordering_specification_opt ::= DESC", - /* 492 */ "null_ordering_opt ::=", - /* 493 */ "null_ordering_opt ::= NULLS FIRST", - /* 494 */ "null_ordering_opt ::= NULLS LAST", + /* 85 */ "db_options ::= db_options TSDB_PAGESIZE NK_INTEGER", + /* 86 */ "db_options ::= db_options PRECISION NK_STRING", + /* 87 */ "db_options ::= db_options REPLICA NK_INTEGER", + /* 88 */ "db_options ::= db_options STRICT NK_STRING", + /* 89 */ "db_options ::= db_options VGROUPS NK_INTEGER", + /* 90 */ "db_options ::= db_options SINGLE_STABLE NK_INTEGER", + /* 91 */ "db_options ::= db_options RETENTIONS retention_list", + /* 92 */ "db_options ::= db_options SCHEMALESS NK_INTEGER", + /* 93 */ "db_options ::= db_options WAL_LEVEL NK_INTEGER", + /* 94 */ "db_options ::= db_options WAL_FSYNC_PERIOD NK_INTEGER", + /* 95 */ "db_options ::= db_options WAL_RETENTION_PERIOD NK_INTEGER", + /* 96 */ "db_options ::= db_options WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER", + /* 97 */ "db_options ::= db_options WAL_RETENTION_SIZE NK_INTEGER", + /* 98 */ "db_options ::= db_options WAL_RETENTION_SIZE NK_MINUS NK_INTEGER", + /* 99 */ "db_options ::= db_options WAL_ROLL_PERIOD NK_INTEGER", + /* 100 */ "db_options ::= db_options WAL_SEGMENT_SIZE NK_INTEGER", + /* 101 */ "db_options ::= db_options STT_TRIGGER NK_INTEGER", + /* 102 */ "db_options ::= db_options TABLE_PREFIX NK_INTEGER", + /* 103 */ "db_options ::= db_options TABLE_SUFFIX NK_INTEGER", + /* 104 */ "alter_db_options ::= alter_db_option", + /* 105 */ "alter_db_options ::= alter_db_options alter_db_option", + /* 106 */ "alter_db_option ::= CACHEMODEL NK_STRING", + /* 107 */ "alter_db_option ::= CACHESIZE NK_INTEGER", + /* 108 */ "alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER", + /* 109 */ "alter_db_option ::= KEEP integer_list", + /* 110 */ "alter_db_option ::= KEEP variable_list", + /* 111 */ "alter_db_option ::= WAL_LEVEL NK_INTEGER", + /* 112 */ "alter_db_option ::= STT_TRIGGER NK_INTEGER", + /* 113 */ "integer_list ::= NK_INTEGER", + /* 114 */ "integer_list ::= integer_list NK_COMMA NK_INTEGER", + /* 115 */ "variable_list ::= NK_VARIABLE", + /* 116 */ "variable_list ::= variable_list NK_COMMA NK_VARIABLE", + /* 117 */ "retention_list ::= retention", + /* 118 */ "retention_list ::= retention_list NK_COMMA retention", + /* 119 */ "retention ::= NK_VARIABLE NK_COLON NK_VARIABLE", + /* 120 */ "cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options", + /* 121 */ "cmd ::= CREATE TABLE multi_create_clause", + /* 122 */ "cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options", + /* 123 */ "cmd ::= DROP TABLE multi_drop_clause", + /* 124 */ "cmd ::= DROP STABLE exists_opt full_table_name", + /* 125 */ "cmd ::= ALTER TABLE alter_table_clause", + /* 126 */ "cmd ::= ALTER STABLE alter_table_clause", + /* 127 */ "alter_table_clause ::= full_table_name alter_table_options", + /* 128 */ "alter_table_clause ::= full_table_name ADD COLUMN column_name type_name", + /* 129 */ "alter_table_clause ::= full_table_name DROP COLUMN column_name", + /* 130 */ "alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name", + /* 131 */ "alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name", + /* 132 */ "alter_table_clause ::= full_table_name ADD TAG column_name type_name", + /* 133 */ "alter_table_clause ::= full_table_name DROP TAG column_name", + /* 134 */ "alter_table_clause ::= full_table_name MODIFY TAG column_name type_name", + /* 135 */ "alter_table_clause ::= full_table_name RENAME TAG column_name column_name", + /* 136 */ "alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal", + /* 137 */ "multi_create_clause ::= create_subtable_clause", + /* 138 */ "multi_create_clause ::= multi_create_clause create_subtable_clause", + /* 139 */ "create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP expression_list NK_RP table_options", + /* 140 */ "multi_drop_clause ::= drop_table_clause", + /* 141 */ "multi_drop_clause ::= multi_drop_clause drop_table_clause", + /* 142 */ "drop_table_clause ::= exists_opt full_table_name", + /* 143 */ "specific_cols_opt ::=", + /* 144 */ "specific_cols_opt ::= NK_LP col_name_list NK_RP", + /* 145 */ "full_table_name ::= table_name", + /* 146 */ "full_table_name ::= db_name NK_DOT table_name", + /* 147 */ "column_def_list ::= column_def", + /* 148 */ "column_def_list ::= column_def_list NK_COMMA column_def", + /* 149 */ "column_def ::= column_name type_name", + /* 150 */ "column_def ::= column_name type_name COMMENT NK_STRING", + /* 151 */ "type_name ::= BOOL", + /* 152 */ "type_name ::= TINYINT", + /* 153 */ "type_name ::= SMALLINT", + /* 154 */ "type_name ::= INT", + /* 155 */ "type_name ::= INTEGER", + /* 156 */ "type_name ::= BIGINT", + /* 157 */ "type_name ::= FLOAT", + /* 158 */ "type_name ::= DOUBLE", + /* 159 */ "type_name ::= BINARY NK_LP NK_INTEGER NK_RP", + /* 160 */ "type_name ::= TIMESTAMP", + /* 161 */ "type_name ::= NCHAR NK_LP NK_INTEGER NK_RP", + /* 162 */ "type_name ::= TINYINT UNSIGNED", + /* 163 */ "type_name ::= SMALLINT UNSIGNED", + /* 164 */ "type_name ::= INT UNSIGNED", + /* 165 */ "type_name ::= BIGINT UNSIGNED", + /* 166 */ "type_name ::= JSON", + /* 167 */ "type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP", + /* 168 */ "type_name ::= MEDIUMBLOB", + /* 169 */ "type_name ::= BLOB", + /* 170 */ "type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP", + /* 171 */ "type_name ::= DECIMAL", + /* 172 */ "type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP", + /* 173 */ "type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP", + /* 174 */ "tags_def_opt ::=", + /* 175 */ "tags_def_opt ::= tags_def", + /* 176 */ "tags_def ::= TAGS NK_LP column_def_list NK_RP", + /* 177 */ "table_options ::=", + /* 178 */ "table_options ::= table_options COMMENT NK_STRING", + /* 179 */ "table_options ::= table_options MAX_DELAY duration_list", + /* 180 */ "table_options ::= table_options WATERMARK duration_list", + /* 181 */ "table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP", + /* 182 */ "table_options ::= table_options TTL NK_INTEGER", + /* 183 */ "table_options ::= table_options SMA NK_LP col_name_list NK_RP", + /* 184 */ "alter_table_options ::= alter_table_option", + /* 185 */ "alter_table_options ::= alter_table_options alter_table_option", + /* 186 */ "alter_table_option ::= COMMENT NK_STRING", + /* 187 */ "alter_table_option ::= TTL NK_INTEGER", + /* 188 */ "duration_list ::= duration_literal", + /* 189 */ "duration_list ::= duration_list NK_COMMA duration_literal", + /* 190 */ "rollup_func_list ::= rollup_func_name", + /* 191 */ "rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name", + /* 192 */ "rollup_func_name ::= function_name", + /* 193 */ "rollup_func_name ::= FIRST", + /* 194 */ "rollup_func_name ::= LAST", + /* 195 */ "col_name_list ::= col_name", + /* 196 */ "col_name_list ::= col_name_list NK_COMMA col_name", + /* 197 */ "col_name ::= column_name", + /* 198 */ "cmd ::= SHOW DNODES", + /* 199 */ "cmd ::= SHOW USERS", + /* 200 */ "cmd ::= SHOW DATABASES", + /* 201 */ "cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt", + /* 202 */ "cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt", + /* 203 */ "cmd ::= SHOW db_name_cond_opt VGROUPS", + /* 204 */ "cmd ::= SHOW MNODES", + /* 205 */ "cmd ::= SHOW MODULES", + /* 206 */ "cmd ::= SHOW QNODES", + /* 207 */ "cmd ::= SHOW FUNCTIONS", + /* 208 */ "cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt", + /* 209 */ "cmd ::= SHOW STREAMS", + /* 210 */ "cmd ::= SHOW ACCOUNTS", + /* 211 */ "cmd ::= SHOW APPS", + /* 212 */ "cmd ::= SHOW CONNECTIONS", + /* 213 */ "cmd ::= SHOW LICENCES", + /* 214 */ "cmd ::= SHOW GRANTS", + /* 215 */ "cmd ::= SHOW CREATE DATABASE db_name", + /* 216 */ "cmd ::= SHOW CREATE TABLE full_table_name", + /* 217 */ "cmd ::= SHOW CREATE STABLE full_table_name", + /* 218 */ "cmd ::= SHOW QUERIES", + /* 219 */ "cmd ::= SHOW SCORES", + /* 220 */ "cmd ::= SHOW TOPICS", + /* 221 */ "cmd ::= SHOW VARIABLES", + /* 222 */ "cmd ::= SHOW LOCAL VARIABLES", + /* 223 */ "cmd ::= SHOW DNODE NK_INTEGER VARIABLES", + /* 224 */ "cmd ::= SHOW BNODES", + /* 225 */ "cmd ::= SHOW SNODES", + /* 226 */ "cmd ::= SHOW CLUSTER", + /* 227 */ "cmd ::= SHOW TRANSACTIONS", + /* 228 */ "cmd ::= SHOW TABLE DISTRIBUTED full_table_name", + /* 229 */ "cmd ::= SHOW CONSUMERS", + /* 230 */ "cmd ::= SHOW SUBSCRIPTIONS", + /* 231 */ "cmd ::= SHOW TAGS FROM table_name_cond from_db_opt", + /* 232 */ "cmd ::= SHOW VNODES NK_INTEGER", + /* 233 */ "cmd ::= SHOW VNODES NK_STRING", + /* 234 */ "db_name_cond_opt ::=", + /* 235 */ "db_name_cond_opt ::= db_name NK_DOT", + /* 236 */ "like_pattern_opt ::=", + /* 237 */ "like_pattern_opt ::= LIKE NK_STRING", + /* 238 */ "table_name_cond ::= table_name", + /* 239 */ "from_db_opt ::=", + /* 240 */ "from_db_opt ::= FROM db_name", + /* 241 */ "cmd ::= CREATE SMA INDEX not_exists_opt full_table_name ON full_table_name index_options", + /* 242 */ "cmd ::= DROP INDEX exists_opt full_table_name", + /* 243 */ "index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt", + /* 244 */ "index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt", + /* 245 */ "func_list ::= func", + /* 246 */ "func_list ::= func_list NK_COMMA func", + /* 247 */ "func ::= function_name NK_LP expression_list NK_RP", + /* 248 */ "sma_stream_opt ::=", + /* 249 */ "sma_stream_opt ::= stream_options WATERMARK duration_literal", + /* 250 */ "sma_stream_opt ::= stream_options MAX_DELAY duration_literal", + /* 251 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression", + /* 252 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name", + /* 253 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS DATABASE db_name", + /* 254 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name", + /* 255 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS STABLE full_table_name", + /* 256 */ "cmd ::= DROP TOPIC exists_opt topic_name", + /* 257 */ "cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name", + /* 258 */ "cmd ::= DESC full_table_name", + /* 259 */ "cmd ::= DESCRIBE full_table_name", + /* 260 */ "cmd ::= RESET QUERY CACHE", + /* 261 */ "cmd ::= EXPLAIN analyze_opt explain_options query_expression", + /* 262 */ "analyze_opt ::=", + /* 263 */ "analyze_opt ::= ANALYZE", + /* 264 */ "explain_options ::=", + /* 265 */ "explain_options ::= explain_options VERBOSE NK_BOOL", + /* 266 */ "explain_options ::= explain_options RATIO NK_FLOAT", + /* 267 */ "cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt", + /* 268 */ "cmd ::= DROP FUNCTION exists_opt function_name", + /* 269 */ "agg_func_opt ::=", + /* 270 */ "agg_func_opt ::= AGGREGATE", + /* 271 */ "bufsize_opt ::=", + /* 272 */ "bufsize_opt ::= BUFSIZE NK_INTEGER", + /* 273 */ "cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name AS query_expression", + /* 274 */ "cmd ::= DROP STREAM exists_opt stream_name", + /* 275 */ "stream_options ::=", + /* 276 */ "stream_options ::= stream_options TRIGGER AT_ONCE", + /* 277 */ "stream_options ::= stream_options TRIGGER WINDOW_CLOSE", + /* 278 */ "stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal", + /* 279 */ "stream_options ::= stream_options WATERMARK duration_literal", + /* 280 */ "stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER", + /* 281 */ "cmd ::= KILL CONNECTION NK_INTEGER", + /* 282 */ "cmd ::= KILL QUERY NK_STRING", + /* 283 */ "cmd ::= KILL TRANSACTION NK_INTEGER", + /* 284 */ "cmd ::= BALANCE VGROUP", + /* 285 */ "cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER", + /* 286 */ "cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list", + /* 287 */ "cmd ::= SPLIT VGROUP NK_INTEGER", + /* 288 */ "dnode_list ::= DNODE NK_INTEGER", + /* 289 */ "dnode_list ::= dnode_list DNODE NK_INTEGER", + /* 290 */ "cmd ::= DELETE FROM full_table_name where_clause_opt", + /* 291 */ "cmd ::= query_expression", + /* 292 */ "cmd ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_expression", + /* 293 */ "cmd ::= INSERT INTO full_table_name query_expression", + /* 294 */ "literal ::= NK_INTEGER", + /* 295 */ "literal ::= NK_FLOAT", + /* 296 */ "literal ::= NK_STRING", + /* 297 */ "literal ::= NK_BOOL", + /* 298 */ "literal ::= TIMESTAMP NK_STRING", + /* 299 */ "literal ::= duration_literal", + /* 300 */ "literal ::= NULL", + /* 301 */ "literal ::= NK_QUESTION", + /* 302 */ "duration_literal ::= NK_VARIABLE", + /* 303 */ "signed ::= NK_INTEGER", + /* 304 */ "signed ::= NK_PLUS NK_INTEGER", + /* 305 */ "signed ::= NK_MINUS NK_INTEGER", + /* 306 */ "signed ::= NK_FLOAT", + /* 307 */ "signed ::= NK_PLUS NK_FLOAT", + /* 308 */ "signed ::= NK_MINUS NK_FLOAT", + /* 309 */ "signed_literal ::= signed", + /* 310 */ "signed_literal ::= NK_STRING", + /* 311 */ "signed_literal ::= NK_BOOL", + /* 312 */ "signed_literal ::= TIMESTAMP NK_STRING", + /* 313 */ "signed_literal ::= duration_literal", + /* 314 */ "signed_literal ::= NULL", + /* 315 */ "signed_literal ::= literal_func", + /* 316 */ "signed_literal ::= NK_QUESTION", + /* 317 */ "literal_list ::= signed_literal", + /* 318 */ "literal_list ::= literal_list NK_COMMA signed_literal", + /* 319 */ "db_name ::= NK_ID", + /* 320 */ "table_name ::= NK_ID", + /* 321 */ "column_name ::= NK_ID", + /* 322 */ "function_name ::= NK_ID", + /* 323 */ "table_alias ::= NK_ID", + /* 324 */ "column_alias ::= NK_ID", + /* 325 */ "user_name ::= NK_ID", + /* 326 */ "topic_name ::= NK_ID", + /* 327 */ "stream_name ::= NK_ID", + /* 328 */ "cgroup_name ::= NK_ID", + /* 329 */ "expression ::= literal", + /* 330 */ "expression ::= pseudo_column", + /* 331 */ "expression ::= column_reference", + /* 332 */ "expression ::= function_expression", + /* 333 */ "expression ::= subquery", + /* 334 */ "expression ::= NK_LP expression NK_RP", + /* 335 */ "expression ::= NK_PLUS expression", + /* 336 */ "expression ::= NK_MINUS expression", + /* 337 */ "expression ::= expression NK_PLUS expression", + /* 338 */ "expression ::= expression NK_MINUS expression", + /* 339 */ "expression ::= expression NK_STAR expression", + /* 340 */ "expression ::= expression NK_SLASH expression", + /* 341 */ "expression ::= expression NK_REM expression", + /* 342 */ "expression ::= column_reference NK_ARROW NK_STRING", + /* 343 */ "expression ::= expression NK_BITAND expression", + /* 344 */ "expression ::= expression NK_BITOR expression", + /* 345 */ "expression_list ::= expression", + /* 346 */ "expression_list ::= expression_list NK_COMMA expression", + /* 347 */ "column_reference ::= column_name", + /* 348 */ "column_reference ::= table_name NK_DOT column_name", + /* 349 */ "pseudo_column ::= ROWTS", + /* 350 */ "pseudo_column ::= TBNAME", + /* 351 */ "pseudo_column ::= table_name NK_DOT TBNAME", + /* 352 */ "pseudo_column ::= QSTART", + /* 353 */ "pseudo_column ::= QEND", + /* 354 */ "pseudo_column ::= QDURATION", + /* 355 */ "pseudo_column ::= WSTART", + /* 356 */ "pseudo_column ::= WEND", + /* 357 */ "pseudo_column ::= WDURATION", + /* 358 */ "function_expression ::= function_name NK_LP expression_list NK_RP", + /* 359 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP", + /* 360 */ "function_expression ::= CAST NK_LP expression AS type_name NK_RP", + /* 361 */ "function_expression ::= literal_func", + /* 362 */ "literal_func ::= noarg_func NK_LP NK_RP", + /* 363 */ "literal_func ::= NOW", + /* 364 */ "noarg_func ::= NOW", + /* 365 */ "noarg_func ::= TODAY", + /* 366 */ "noarg_func ::= TIMEZONE", + /* 367 */ "noarg_func ::= DATABASE", + /* 368 */ "noarg_func ::= CLIENT_VERSION", + /* 369 */ "noarg_func ::= SERVER_VERSION", + /* 370 */ "noarg_func ::= SERVER_STATUS", + /* 371 */ "noarg_func ::= CURRENT_USER", + /* 372 */ "noarg_func ::= USER", + /* 373 */ "star_func ::= COUNT", + /* 374 */ "star_func ::= FIRST", + /* 375 */ "star_func ::= LAST", + /* 376 */ "star_func ::= LAST_ROW", + /* 377 */ "star_func_para_list ::= NK_STAR", + /* 378 */ "star_func_para_list ::= other_para_list", + /* 379 */ "other_para_list ::= star_func_para", + /* 380 */ "other_para_list ::= other_para_list NK_COMMA star_func_para", + /* 381 */ "star_func_para ::= expression", + /* 382 */ "star_func_para ::= table_name NK_DOT NK_STAR", + /* 383 */ "predicate ::= expression compare_op expression", + /* 384 */ "predicate ::= expression BETWEEN expression AND expression", + /* 385 */ "predicate ::= expression NOT BETWEEN expression AND expression", + /* 386 */ "predicate ::= expression IS NULL", + /* 387 */ "predicate ::= expression IS NOT NULL", + /* 388 */ "predicate ::= expression in_op in_predicate_value", + /* 389 */ "compare_op ::= NK_LT", + /* 390 */ "compare_op ::= NK_GT", + /* 391 */ "compare_op ::= NK_LE", + /* 392 */ "compare_op ::= NK_GE", + /* 393 */ "compare_op ::= NK_NE", + /* 394 */ "compare_op ::= NK_EQ", + /* 395 */ "compare_op ::= LIKE", + /* 396 */ "compare_op ::= NOT LIKE", + /* 397 */ "compare_op ::= MATCH", + /* 398 */ "compare_op ::= NMATCH", + /* 399 */ "compare_op ::= CONTAINS", + /* 400 */ "in_op ::= IN", + /* 401 */ "in_op ::= NOT IN", + /* 402 */ "in_predicate_value ::= NK_LP literal_list NK_RP", + /* 403 */ "boolean_value_expression ::= boolean_primary", + /* 404 */ "boolean_value_expression ::= NOT boolean_primary", + /* 405 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression", + /* 406 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression", + /* 407 */ "boolean_primary ::= predicate", + /* 408 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP", + /* 409 */ "common_expression ::= expression", + /* 410 */ "common_expression ::= boolean_value_expression", + /* 411 */ "from_clause_opt ::=", + /* 412 */ "from_clause_opt ::= FROM table_reference_list", + /* 413 */ "table_reference_list ::= table_reference", + /* 414 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference", + /* 415 */ "table_reference ::= table_primary", + /* 416 */ "table_reference ::= joined_table", + /* 417 */ "table_primary ::= table_name alias_opt", + /* 418 */ "table_primary ::= db_name NK_DOT table_name alias_opt", + /* 419 */ "table_primary ::= subquery alias_opt", + /* 420 */ "table_primary ::= parenthesized_joined_table", + /* 421 */ "alias_opt ::=", + /* 422 */ "alias_opt ::= table_alias", + /* 423 */ "alias_opt ::= AS table_alias", + /* 424 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP", + /* 425 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP", + /* 426 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition", + /* 427 */ "join_type ::=", + /* 428 */ "join_type ::= INNER", + /* 429 */ "query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt", + /* 430 */ "set_quantifier_opt ::=", + /* 431 */ "set_quantifier_opt ::= DISTINCT", + /* 432 */ "set_quantifier_opt ::= ALL", + /* 433 */ "select_list ::= select_item", + /* 434 */ "select_list ::= select_list NK_COMMA select_item", + /* 435 */ "select_item ::= NK_STAR", + /* 436 */ "select_item ::= common_expression", + /* 437 */ "select_item ::= common_expression column_alias", + /* 438 */ "select_item ::= common_expression AS column_alias", + /* 439 */ "select_item ::= table_name NK_DOT NK_STAR", + /* 440 */ "where_clause_opt ::=", + /* 441 */ "where_clause_opt ::= WHERE search_condition", + /* 442 */ "partition_by_clause_opt ::=", + /* 443 */ "partition_by_clause_opt ::= PARTITION BY expression_list", + /* 444 */ "twindow_clause_opt ::=", + /* 445 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP", + /* 446 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP", + /* 447 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt", + /* 448 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt", + /* 449 */ "sliding_opt ::=", + /* 450 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP", + /* 451 */ "fill_opt ::=", + /* 452 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", + /* 453 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP", + /* 454 */ "fill_mode ::= NONE", + /* 455 */ "fill_mode ::= PREV", + /* 456 */ "fill_mode ::= NULL", + /* 457 */ "fill_mode ::= LINEAR", + /* 458 */ "fill_mode ::= NEXT", + /* 459 */ "group_by_clause_opt ::=", + /* 460 */ "group_by_clause_opt ::= GROUP BY group_by_list", + /* 461 */ "group_by_list ::= expression", + /* 462 */ "group_by_list ::= group_by_list NK_COMMA expression", + /* 463 */ "having_clause_opt ::=", + /* 464 */ "having_clause_opt ::= HAVING search_condition", + /* 465 */ "range_opt ::=", + /* 466 */ "range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP", + /* 467 */ "every_opt ::=", + /* 468 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP", + /* 469 */ "query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt", + /* 470 */ "query_expression_body ::= query_primary", + /* 471 */ "query_expression_body ::= query_expression_body UNION ALL query_expression_body", + /* 472 */ "query_expression_body ::= query_expression_body UNION query_expression_body", + /* 473 */ "query_primary ::= query_specification", + /* 474 */ "query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP", + /* 475 */ "order_by_clause_opt ::=", + /* 476 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", + /* 477 */ "slimit_clause_opt ::=", + /* 478 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", + /* 479 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", + /* 480 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 481 */ "limit_clause_opt ::=", + /* 482 */ "limit_clause_opt ::= LIMIT NK_INTEGER", + /* 483 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", + /* 484 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 485 */ "subquery ::= NK_LP query_expression NK_RP", + /* 486 */ "search_condition ::= common_expression", + /* 487 */ "sort_specification_list ::= sort_specification", + /* 488 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", + /* 489 */ "sort_specification ::= expression ordering_specification_opt null_ordering_opt", + /* 490 */ "ordering_specification_opt ::=", + /* 491 */ "ordering_specification_opt ::= ASC", + /* 492 */ "ordering_specification_opt ::= DESC", + /* 493 */ "null_ordering_opt ::=", + /* 494 */ "null_ordering_opt ::= NULLS FIRST", + /* 495 */ "null_ordering_opt ::= NULLS LAST", }; #endif /* NDEBUG */ @@ -2361,179 +2374,179 @@ static void yy_destructor( */ /********* Begin destructor definitions ***************************************/ /* Default NON-TERMINAL Destructor */ - case 308: /* cmd */ - case 311: /* literal */ - case 322: /* db_options */ - case 324: /* alter_db_options */ - case 329: /* retention */ - case 330: /* full_table_name */ - case 333: /* table_options */ - case 337: /* alter_table_clause */ - case 338: /* alter_table_options */ - case 341: /* signed_literal */ - case 342: /* create_subtable_clause */ - case 345: /* drop_table_clause */ - case 348: /* column_def */ - case 352: /* duration_literal */ - case 353: /* rollup_func_name */ - case 355: /* col_name */ - case 356: /* db_name_cond_opt */ - case 357: /* like_pattern_opt */ - case 358: /* table_name_cond */ - case 359: /* from_db_opt */ - case 360: /* index_options */ - case 362: /* sliding_opt */ - case 363: /* sma_stream_opt */ - case 364: /* func */ - case 365: /* stream_options */ - case 367: /* query_expression */ - case 370: /* explain_options */ - case 375: /* where_clause_opt */ - case 376: /* signed */ - case 377: /* literal_func */ - case 381: /* expression */ - case 382: /* pseudo_column */ - case 383: /* column_reference */ - case 384: /* function_expression */ - case 385: /* subquery */ - case 390: /* star_func_para */ - case 391: /* predicate */ - case 394: /* in_predicate_value */ - case 395: /* boolean_value_expression */ - case 396: /* boolean_primary */ - case 397: /* common_expression */ - case 398: /* from_clause_opt */ - case 399: /* table_reference_list */ - case 400: /* table_reference */ - case 401: /* table_primary */ - case 402: /* joined_table */ - case 404: /* parenthesized_joined_table */ - case 406: /* search_condition */ - case 407: /* query_specification */ - case 411: /* range_opt */ - case 412: /* every_opt */ - case 413: /* fill_opt */ - case 414: /* twindow_clause_opt */ - case 416: /* having_clause_opt */ - case 417: /* select_item */ - case 420: /* query_expression_body */ - case 422: /* slimit_clause_opt */ - case 423: /* limit_clause_opt */ - case 424: /* query_primary */ - case 426: /* sort_specification */ + case 309: /* cmd */ + case 312: /* literal */ + case 323: /* db_options */ + case 325: /* alter_db_options */ + case 330: /* retention */ + case 331: /* full_table_name */ + case 334: /* table_options */ + case 338: /* alter_table_clause */ + case 339: /* alter_table_options */ + case 342: /* signed_literal */ + case 343: /* create_subtable_clause */ + case 346: /* drop_table_clause */ + case 349: /* column_def */ + case 353: /* duration_literal */ + case 354: /* rollup_func_name */ + case 356: /* col_name */ + case 357: /* db_name_cond_opt */ + case 358: /* like_pattern_opt */ + case 359: /* table_name_cond */ + case 360: /* from_db_opt */ + case 361: /* index_options */ + case 363: /* sliding_opt */ + case 364: /* sma_stream_opt */ + case 365: /* func */ + case 366: /* stream_options */ + case 368: /* query_expression */ + case 371: /* explain_options */ + case 376: /* where_clause_opt */ + case 377: /* signed */ + case 378: /* literal_func */ + case 382: /* expression */ + case 383: /* pseudo_column */ + case 384: /* column_reference */ + case 385: /* function_expression */ + case 386: /* subquery */ + case 391: /* star_func_para */ + case 392: /* predicate */ + case 395: /* in_predicate_value */ + case 396: /* boolean_value_expression */ + case 397: /* boolean_primary */ + case 398: /* common_expression */ + case 399: /* from_clause_opt */ + case 400: /* table_reference_list */ + case 401: /* table_reference */ + case 402: /* table_primary */ + case 403: /* joined_table */ + case 405: /* parenthesized_joined_table */ + case 407: /* search_condition */ + case 408: /* query_specification */ + case 412: /* range_opt */ + case 413: /* every_opt */ + case 414: /* fill_opt */ + case 415: /* twindow_clause_opt */ + case 417: /* having_clause_opt */ + case 418: /* select_item */ + case 421: /* query_expression_body */ + case 423: /* slimit_clause_opt */ + case 424: /* limit_clause_opt */ + case 425: /* query_primary */ + case 427: /* sort_specification */ { - nodesDestroyNode((yypminor->yy80)); + nodesDestroyNode((yypminor->yy312)); } break; - case 309: /* account_options */ - case 310: /* alter_account_options */ - case 312: /* alter_account_option */ - case 372: /* bufsize_opt */ + case 310: /* account_options */ + case 311: /* alter_account_options */ + case 313: /* alter_account_option */ + case 373: /* bufsize_opt */ { } break; - case 313: /* user_name */ - case 316: /* priv_level */ - case 319: /* db_name */ - case 320: /* dnode_endpoint */ - case 339: /* column_name */ - case 347: /* table_name */ - case 354: /* function_name */ - case 366: /* topic_name */ - case 368: /* cgroup_name */ - case 373: /* stream_name */ - case 379: /* table_alias */ - case 380: /* column_alias */ - case 386: /* star_func */ - case 388: /* noarg_func */ - case 403: /* alias_opt */ + case 314: /* user_name */ + case 317: /* priv_level */ + case 320: /* db_name */ + case 321: /* dnode_endpoint */ + case 340: /* column_name */ + case 348: /* table_name */ + case 355: /* function_name */ + case 367: /* topic_name */ + case 369: /* cgroup_name */ + case 374: /* stream_name */ + case 380: /* table_alias */ + case 381: /* column_alias */ + case 387: /* star_func */ + case 389: /* noarg_func */ + case 404: /* alias_opt */ { } break; - case 314: /* sysinfo_opt */ + case 315: /* sysinfo_opt */ { } break; - case 315: /* privileges */ - case 317: /* priv_type_list */ - case 318: /* priv_type */ + case 316: /* privileges */ + case 318: /* priv_type_list */ + case 319: /* priv_type */ { } break; - case 321: /* not_exists_opt */ - case 323: /* exists_opt */ - case 369: /* analyze_opt */ - case 371: /* agg_func_opt */ - case 408: /* set_quantifier_opt */ + case 322: /* not_exists_opt */ + case 324: /* exists_opt */ + case 370: /* analyze_opt */ + case 372: /* agg_func_opt */ + case 409: /* set_quantifier_opt */ { } break; - case 325: /* integer_list */ - case 326: /* variable_list */ - case 327: /* retention_list */ - case 331: /* column_def_list */ - case 332: /* tags_def_opt */ - case 334: /* multi_create_clause */ - case 335: /* tags_def */ - case 336: /* multi_drop_clause */ - case 343: /* specific_cols_opt */ - case 344: /* expression_list */ - case 346: /* col_name_list */ - case 349: /* duration_list */ - case 350: /* rollup_func_list */ - case 361: /* func_list */ - case 374: /* dnode_list */ - case 378: /* literal_list */ - case 387: /* star_func_para_list */ - case 389: /* other_para_list */ - case 409: /* select_list */ - case 410: /* partition_by_clause_opt */ - case 415: /* group_by_clause_opt */ - case 419: /* group_by_list */ - case 421: /* order_by_clause_opt */ - case 425: /* sort_specification_list */ + case 326: /* integer_list */ + case 327: /* variable_list */ + case 328: /* retention_list */ + case 332: /* column_def_list */ + case 333: /* tags_def_opt */ + case 335: /* multi_create_clause */ + case 336: /* tags_def */ + case 337: /* multi_drop_clause */ + case 344: /* specific_cols_opt */ + case 345: /* expression_list */ + case 347: /* col_name_list */ + case 350: /* duration_list */ + case 351: /* rollup_func_list */ + case 362: /* func_list */ + case 375: /* dnode_list */ + case 379: /* literal_list */ + case 388: /* star_func_para_list */ + case 390: /* other_para_list */ + case 410: /* select_list */ + case 411: /* partition_by_clause_opt */ + case 416: /* group_by_clause_opt */ + case 420: /* group_by_list */ + case 422: /* order_by_clause_opt */ + case 426: /* sort_specification_list */ { - nodesDestroyList((yypminor->yy574)); + nodesDestroyList((yypminor->yy824)); } break; - case 328: /* alter_db_option */ - case 351: /* alter_table_option */ + case 329: /* alter_db_option */ + case 352: /* alter_table_option */ { } break; - case 340: /* type_name */ + case 341: /* type_name */ { } break; - case 392: /* compare_op */ - case 393: /* in_op */ + case 393: /* compare_op */ + case 394: /* in_op */ { } break; - case 405: /* join_type */ + case 406: /* join_type */ { } break; - case 418: /* fill_mode */ + case 419: /* fill_mode */ { } break; - case 427: /* ordering_specification_opt */ + case 428: /* ordering_specification_opt */ { } break; - case 428: /* null_ordering_opt */ + case 429: /* null_ordering_opt */ { } @@ -2832,501 +2845,502 @@ 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[] = { - { 308, -6 }, /* (0) cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */ - { 308, -4 }, /* (1) cmd ::= ALTER ACCOUNT NK_ID alter_account_options */ - { 309, 0 }, /* (2) account_options ::= */ - { 309, -3 }, /* (3) account_options ::= account_options PPS literal */ - { 309, -3 }, /* (4) account_options ::= account_options TSERIES literal */ - { 309, -3 }, /* (5) account_options ::= account_options STORAGE literal */ - { 309, -3 }, /* (6) account_options ::= account_options STREAMS literal */ - { 309, -3 }, /* (7) account_options ::= account_options QTIME literal */ - { 309, -3 }, /* (8) account_options ::= account_options DBS literal */ - { 309, -3 }, /* (9) account_options ::= account_options USERS literal */ - { 309, -3 }, /* (10) account_options ::= account_options CONNS literal */ - { 309, -3 }, /* (11) account_options ::= account_options STATE literal */ - { 310, -1 }, /* (12) alter_account_options ::= alter_account_option */ - { 310, -2 }, /* (13) alter_account_options ::= alter_account_options alter_account_option */ - { 312, -2 }, /* (14) alter_account_option ::= PASS literal */ - { 312, -2 }, /* (15) alter_account_option ::= PPS literal */ - { 312, -2 }, /* (16) alter_account_option ::= TSERIES literal */ - { 312, -2 }, /* (17) alter_account_option ::= STORAGE literal */ - { 312, -2 }, /* (18) alter_account_option ::= STREAMS literal */ - { 312, -2 }, /* (19) alter_account_option ::= QTIME literal */ - { 312, -2 }, /* (20) alter_account_option ::= DBS literal */ - { 312, -2 }, /* (21) alter_account_option ::= USERS literal */ - { 312, -2 }, /* (22) alter_account_option ::= CONNS literal */ - { 312, -2 }, /* (23) alter_account_option ::= STATE literal */ - { 308, -6 }, /* (24) cmd ::= CREATE USER user_name PASS NK_STRING sysinfo_opt */ - { 308, -5 }, /* (25) cmd ::= ALTER USER user_name PASS NK_STRING */ - { 308, -5 }, /* (26) cmd ::= ALTER USER user_name ENABLE NK_INTEGER */ - { 308, -5 }, /* (27) cmd ::= ALTER USER user_name SYSINFO NK_INTEGER */ - { 308, -3 }, /* (28) cmd ::= DROP USER user_name */ - { 314, 0 }, /* (29) sysinfo_opt ::= */ - { 314, -2 }, /* (30) sysinfo_opt ::= SYSINFO NK_INTEGER */ - { 308, -6 }, /* (31) cmd ::= GRANT privileges ON priv_level TO user_name */ - { 308, -6 }, /* (32) cmd ::= REVOKE privileges ON priv_level FROM user_name */ - { 315, -1 }, /* (33) privileges ::= ALL */ - { 315, -1 }, /* (34) privileges ::= priv_type_list */ - { 317, -1 }, /* (35) priv_type_list ::= priv_type */ - { 317, -3 }, /* (36) priv_type_list ::= priv_type_list NK_COMMA priv_type */ - { 318, -1 }, /* (37) priv_type ::= READ */ - { 318, -1 }, /* (38) priv_type ::= WRITE */ - { 316, -3 }, /* (39) priv_level ::= NK_STAR NK_DOT NK_STAR */ - { 316, -3 }, /* (40) priv_level ::= db_name NK_DOT NK_STAR */ - { 308, -3 }, /* (41) cmd ::= CREATE DNODE dnode_endpoint */ - { 308, -5 }, /* (42) cmd ::= CREATE DNODE dnode_endpoint PORT NK_INTEGER */ - { 308, -3 }, /* (43) cmd ::= DROP DNODE NK_INTEGER */ - { 308, -3 }, /* (44) cmd ::= DROP DNODE dnode_endpoint */ - { 308, -4 }, /* (45) cmd ::= ALTER DNODE NK_INTEGER NK_STRING */ - { 308, -5 }, /* (46) cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */ - { 308, -4 }, /* (47) cmd ::= ALTER ALL DNODES NK_STRING */ - { 308, -5 }, /* (48) cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */ - { 320, -1 }, /* (49) dnode_endpoint ::= NK_STRING */ - { 320, -1 }, /* (50) dnode_endpoint ::= NK_ID */ - { 320, -1 }, /* (51) dnode_endpoint ::= NK_IPTOKEN */ - { 308, -3 }, /* (52) cmd ::= ALTER LOCAL NK_STRING */ - { 308, -4 }, /* (53) cmd ::= ALTER LOCAL NK_STRING NK_STRING */ - { 308, -5 }, /* (54) cmd ::= CREATE QNODE ON DNODE NK_INTEGER */ - { 308, -5 }, /* (55) cmd ::= DROP QNODE ON DNODE NK_INTEGER */ - { 308, -5 }, /* (56) cmd ::= CREATE BNODE ON DNODE NK_INTEGER */ - { 308, -5 }, /* (57) cmd ::= DROP BNODE ON DNODE NK_INTEGER */ - { 308, -5 }, /* (58) cmd ::= CREATE SNODE ON DNODE NK_INTEGER */ - { 308, -5 }, /* (59) cmd ::= DROP SNODE ON DNODE NK_INTEGER */ - { 308, -5 }, /* (60) cmd ::= CREATE MNODE ON DNODE NK_INTEGER */ - { 308, -5 }, /* (61) cmd ::= DROP MNODE ON DNODE NK_INTEGER */ - { 308, -5 }, /* (62) cmd ::= CREATE DATABASE not_exists_opt db_name db_options */ - { 308, -4 }, /* (63) cmd ::= DROP DATABASE exists_opt db_name */ - { 308, -2 }, /* (64) cmd ::= USE db_name */ - { 308, -4 }, /* (65) cmd ::= ALTER DATABASE db_name alter_db_options */ - { 308, -3 }, /* (66) cmd ::= FLUSH DATABASE db_name */ - { 308, -3 }, /* (67) cmd ::= TRIM DATABASE db_name */ - { 321, -3 }, /* (68) not_exists_opt ::= IF NOT EXISTS */ - { 321, 0 }, /* (69) not_exists_opt ::= */ - { 323, -2 }, /* (70) exists_opt ::= IF EXISTS */ - { 323, 0 }, /* (71) exists_opt ::= */ - { 322, 0 }, /* (72) db_options ::= */ - { 322, -3 }, /* (73) db_options ::= db_options BUFFER NK_INTEGER */ - { 322, -3 }, /* (74) db_options ::= db_options CACHEMODEL NK_STRING */ - { 322, -3 }, /* (75) db_options ::= db_options CACHESIZE NK_INTEGER */ - { 322, -3 }, /* (76) db_options ::= db_options COMP NK_INTEGER */ - { 322, -3 }, /* (77) db_options ::= db_options DURATION NK_INTEGER */ - { 322, -3 }, /* (78) db_options ::= db_options DURATION NK_VARIABLE */ - { 322, -3 }, /* (79) db_options ::= db_options MAXROWS NK_INTEGER */ - { 322, -3 }, /* (80) db_options ::= db_options MINROWS NK_INTEGER */ - { 322, -3 }, /* (81) db_options ::= db_options KEEP integer_list */ - { 322, -3 }, /* (82) db_options ::= db_options KEEP variable_list */ - { 322, -3 }, /* (83) db_options ::= db_options PAGES NK_INTEGER */ - { 322, -3 }, /* (84) db_options ::= db_options PAGESIZE NK_INTEGER */ - { 322, -3 }, /* (85) db_options ::= db_options PRECISION NK_STRING */ - { 322, -3 }, /* (86) db_options ::= db_options REPLICA NK_INTEGER */ - { 322, -3 }, /* (87) db_options ::= db_options STRICT NK_STRING */ - { 322, -3 }, /* (88) db_options ::= db_options VGROUPS NK_INTEGER */ - { 322, -3 }, /* (89) db_options ::= db_options SINGLE_STABLE NK_INTEGER */ - { 322, -3 }, /* (90) db_options ::= db_options RETENTIONS retention_list */ - { 322, -3 }, /* (91) db_options ::= db_options SCHEMALESS NK_INTEGER */ - { 322, -3 }, /* (92) db_options ::= db_options WAL_LEVEL NK_INTEGER */ - { 322, -3 }, /* (93) db_options ::= db_options WAL_FSYNC_PERIOD NK_INTEGER */ - { 322, -3 }, /* (94) db_options ::= db_options WAL_RETENTION_PERIOD NK_INTEGER */ - { 322, -4 }, /* (95) db_options ::= db_options WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ - { 322, -3 }, /* (96) db_options ::= db_options WAL_RETENTION_SIZE NK_INTEGER */ - { 322, -4 }, /* (97) db_options ::= db_options WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ - { 322, -3 }, /* (98) db_options ::= db_options WAL_ROLL_PERIOD NK_INTEGER */ - { 322, -3 }, /* (99) db_options ::= db_options WAL_SEGMENT_SIZE NK_INTEGER */ - { 322, -3 }, /* (100) db_options ::= db_options SST_TRIGGER NK_INTEGER */ - { 322, -3 }, /* (101) db_options ::= db_options TABLE_PREFIX NK_INTEGER */ - { 322, -3 }, /* (102) db_options ::= db_options TABLE_SUFFIX NK_INTEGER */ - { 324, -1 }, /* (103) alter_db_options ::= alter_db_option */ - { 324, -2 }, /* (104) alter_db_options ::= alter_db_options alter_db_option */ - { 328, -2 }, /* (105) alter_db_option ::= CACHEMODEL NK_STRING */ - { 328, -2 }, /* (106) alter_db_option ::= CACHESIZE NK_INTEGER */ - { 328, -2 }, /* (107) alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */ - { 328, -2 }, /* (108) alter_db_option ::= KEEP integer_list */ - { 328, -2 }, /* (109) alter_db_option ::= KEEP variable_list */ - { 328, -2 }, /* (110) alter_db_option ::= WAL_LEVEL NK_INTEGER */ - { 328, -2 }, /* (111) alter_db_option ::= SST_TRIGGER NK_INTEGER */ - { 325, -1 }, /* (112) integer_list ::= NK_INTEGER */ - { 325, -3 }, /* (113) integer_list ::= integer_list NK_COMMA NK_INTEGER */ - { 326, -1 }, /* (114) variable_list ::= NK_VARIABLE */ - { 326, -3 }, /* (115) variable_list ::= variable_list NK_COMMA NK_VARIABLE */ - { 327, -1 }, /* (116) retention_list ::= retention */ - { 327, -3 }, /* (117) retention_list ::= retention_list NK_COMMA retention */ - { 329, -3 }, /* (118) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ - { 308, -9 }, /* (119) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ - { 308, -3 }, /* (120) cmd ::= CREATE TABLE multi_create_clause */ - { 308, -9 }, /* (121) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ - { 308, -3 }, /* (122) cmd ::= DROP TABLE multi_drop_clause */ - { 308, -4 }, /* (123) cmd ::= DROP STABLE exists_opt full_table_name */ - { 308, -3 }, /* (124) cmd ::= ALTER TABLE alter_table_clause */ - { 308, -3 }, /* (125) cmd ::= ALTER STABLE alter_table_clause */ - { 337, -2 }, /* (126) alter_table_clause ::= full_table_name alter_table_options */ - { 337, -5 }, /* (127) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ - { 337, -4 }, /* (128) alter_table_clause ::= full_table_name DROP COLUMN column_name */ - { 337, -5 }, /* (129) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ - { 337, -5 }, /* (130) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ - { 337, -5 }, /* (131) alter_table_clause ::= full_table_name ADD TAG column_name type_name */ - { 337, -4 }, /* (132) alter_table_clause ::= full_table_name DROP TAG column_name */ - { 337, -5 }, /* (133) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ - { 337, -5 }, /* (134) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ - { 337, -6 }, /* (135) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ - { 334, -1 }, /* (136) multi_create_clause ::= create_subtable_clause */ - { 334, -2 }, /* (137) multi_create_clause ::= multi_create_clause create_subtable_clause */ - { 342, -10 }, /* (138) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP expression_list NK_RP table_options */ - { 336, -1 }, /* (139) multi_drop_clause ::= drop_table_clause */ - { 336, -2 }, /* (140) multi_drop_clause ::= multi_drop_clause drop_table_clause */ - { 345, -2 }, /* (141) drop_table_clause ::= exists_opt full_table_name */ - { 343, 0 }, /* (142) specific_cols_opt ::= */ - { 343, -3 }, /* (143) specific_cols_opt ::= NK_LP col_name_list NK_RP */ - { 330, -1 }, /* (144) full_table_name ::= table_name */ - { 330, -3 }, /* (145) full_table_name ::= db_name NK_DOT table_name */ - { 331, -1 }, /* (146) column_def_list ::= column_def */ - { 331, -3 }, /* (147) column_def_list ::= column_def_list NK_COMMA column_def */ - { 348, -2 }, /* (148) column_def ::= column_name type_name */ - { 348, -4 }, /* (149) column_def ::= column_name type_name COMMENT NK_STRING */ - { 340, -1 }, /* (150) type_name ::= BOOL */ - { 340, -1 }, /* (151) type_name ::= TINYINT */ - { 340, -1 }, /* (152) type_name ::= SMALLINT */ - { 340, -1 }, /* (153) type_name ::= INT */ - { 340, -1 }, /* (154) type_name ::= INTEGER */ - { 340, -1 }, /* (155) type_name ::= BIGINT */ - { 340, -1 }, /* (156) type_name ::= FLOAT */ - { 340, -1 }, /* (157) type_name ::= DOUBLE */ - { 340, -4 }, /* (158) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ - { 340, -1 }, /* (159) type_name ::= TIMESTAMP */ - { 340, -4 }, /* (160) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ - { 340, -2 }, /* (161) type_name ::= TINYINT UNSIGNED */ - { 340, -2 }, /* (162) type_name ::= SMALLINT UNSIGNED */ - { 340, -2 }, /* (163) type_name ::= INT UNSIGNED */ - { 340, -2 }, /* (164) type_name ::= BIGINT UNSIGNED */ - { 340, -1 }, /* (165) type_name ::= JSON */ - { 340, -4 }, /* (166) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ - { 340, -1 }, /* (167) type_name ::= MEDIUMBLOB */ - { 340, -1 }, /* (168) type_name ::= BLOB */ - { 340, -4 }, /* (169) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ - { 340, -1 }, /* (170) type_name ::= DECIMAL */ - { 340, -4 }, /* (171) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ - { 340, -6 }, /* (172) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ - { 332, 0 }, /* (173) tags_def_opt ::= */ - { 332, -1 }, /* (174) tags_def_opt ::= tags_def */ - { 335, -4 }, /* (175) tags_def ::= TAGS NK_LP column_def_list NK_RP */ - { 333, 0 }, /* (176) table_options ::= */ - { 333, -3 }, /* (177) table_options ::= table_options COMMENT NK_STRING */ - { 333, -3 }, /* (178) table_options ::= table_options MAX_DELAY duration_list */ - { 333, -3 }, /* (179) table_options ::= table_options WATERMARK duration_list */ - { 333, -5 }, /* (180) table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ - { 333, -3 }, /* (181) table_options ::= table_options TTL NK_INTEGER */ - { 333, -5 }, /* (182) table_options ::= table_options SMA NK_LP col_name_list NK_RP */ - { 338, -1 }, /* (183) alter_table_options ::= alter_table_option */ - { 338, -2 }, /* (184) alter_table_options ::= alter_table_options alter_table_option */ - { 351, -2 }, /* (185) alter_table_option ::= COMMENT NK_STRING */ - { 351, -2 }, /* (186) alter_table_option ::= TTL NK_INTEGER */ - { 349, -1 }, /* (187) duration_list ::= duration_literal */ - { 349, -3 }, /* (188) duration_list ::= duration_list NK_COMMA duration_literal */ - { 350, -1 }, /* (189) rollup_func_list ::= rollup_func_name */ - { 350, -3 }, /* (190) rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ - { 353, -1 }, /* (191) rollup_func_name ::= function_name */ - { 353, -1 }, /* (192) rollup_func_name ::= FIRST */ - { 353, -1 }, /* (193) rollup_func_name ::= LAST */ - { 346, -1 }, /* (194) col_name_list ::= col_name */ - { 346, -3 }, /* (195) col_name_list ::= col_name_list NK_COMMA col_name */ - { 355, -1 }, /* (196) col_name ::= column_name */ - { 308, -2 }, /* (197) cmd ::= SHOW DNODES */ - { 308, -2 }, /* (198) cmd ::= SHOW USERS */ - { 308, -2 }, /* (199) cmd ::= SHOW DATABASES */ - { 308, -4 }, /* (200) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */ - { 308, -4 }, /* (201) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ - { 308, -3 }, /* (202) cmd ::= SHOW db_name_cond_opt VGROUPS */ - { 308, -2 }, /* (203) cmd ::= SHOW MNODES */ - { 308, -2 }, /* (204) cmd ::= SHOW MODULES */ - { 308, -2 }, /* (205) cmd ::= SHOW QNODES */ - { 308, -2 }, /* (206) cmd ::= SHOW FUNCTIONS */ - { 308, -5 }, /* (207) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ - { 308, -2 }, /* (208) cmd ::= SHOW STREAMS */ - { 308, -2 }, /* (209) cmd ::= SHOW ACCOUNTS */ - { 308, -2 }, /* (210) cmd ::= SHOW APPS */ - { 308, -2 }, /* (211) cmd ::= SHOW CONNECTIONS */ - { 308, -2 }, /* (212) cmd ::= SHOW LICENCES */ - { 308, -2 }, /* (213) cmd ::= SHOW GRANTS */ - { 308, -4 }, /* (214) cmd ::= SHOW CREATE DATABASE db_name */ - { 308, -4 }, /* (215) cmd ::= SHOW CREATE TABLE full_table_name */ - { 308, -4 }, /* (216) cmd ::= SHOW CREATE STABLE full_table_name */ - { 308, -2 }, /* (217) cmd ::= SHOW QUERIES */ - { 308, -2 }, /* (218) cmd ::= SHOW SCORES */ - { 308, -2 }, /* (219) cmd ::= SHOW TOPICS */ - { 308, -2 }, /* (220) cmd ::= SHOW VARIABLES */ - { 308, -3 }, /* (221) cmd ::= SHOW LOCAL VARIABLES */ - { 308, -4 }, /* (222) cmd ::= SHOW DNODE NK_INTEGER VARIABLES */ - { 308, -2 }, /* (223) cmd ::= SHOW BNODES */ - { 308, -2 }, /* (224) cmd ::= SHOW SNODES */ - { 308, -2 }, /* (225) cmd ::= SHOW CLUSTER */ - { 308, -2 }, /* (226) cmd ::= SHOW TRANSACTIONS */ - { 308, -4 }, /* (227) cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ - { 308, -2 }, /* (228) cmd ::= SHOW CONSUMERS */ - { 308, -2 }, /* (229) cmd ::= SHOW SUBSCRIPTIONS */ - { 308, -5 }, /* (230) cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ - { 308, -3 }, /* (231) cmd ::= SHOW VNODES NK_INTEGER */ - { 308, -3 }, /* (232) cmd ::= SHOW VNODES NK_STRING */ - { 356, 0 }, /* (233) db_name_cond_opt ::= */ - { 356, -2 }, /* (234) db_name_cond_opt ::= db_name NK_DOT */ - { 357, 0 }, /* (235) like_pattern_opt ::= */ - { 357, -2 }, /* (236) like_pattern_opt ::= LIKE NK_STRING */ - { 358, -1 }, /* (237) table_name_cond ::= table_name */ - { 359, 0 }, /* (238) from_db_opt ::= */ - { 359, -2 }, /* (239) from_db_opt ::= FROM db_name */ - { 308, -8 }, /* (240) cmd ::= CREATE SMA INDEX not_exists_opt full_table_name ON full_table_name index_options */ - { 308, -4 }, /* (241) cmd ::= DROP INDEX exists_opt full_table_name */ - { 360, -10 }, /* (242) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ - { 360, -12 }, /* (243) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt */ - { 361, -1 }, /* (244) func_list ::= func */ - { 361, -3 }, /* (245) func_list ::= func_list NK_COMMA func */ - { 364, -4 }, /* (246) func ::= function_name NK_LP expression_list NK_RP */ - { 363, 0 }, /* (247) sma_stream_opt ::= */ - { 363, -3 }, /* (248) sma_stream_opt ::= stream_options WATERMARK duration_literal */ - { 363, -3 }, /* (249) sma_stream_opt ::= stream_options MAX_DELAY duration_literal */ - { 308, -6 }, /* (250) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression */ - { 308, -7 }, /* (251) cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name */ - { 308, -9 }, /* (252) cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS DATABASE db_name */ - { 308, -7 }, /* (253) cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name */ - { 308, -9 }, /* (254) cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS STABLE full_table_name */ - { 308, -4 }, /* (255) cmd ::= DROP TOPIC exists_opt topic_name */ - { 308, -7 }, /* (256) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ - { 308, -2 }, /* (257) cmd ::= DESC full_table_name */ - { 308, -2 }, /* (258) cmd ::= DESCRIBE full_table_name */ - { 308, -3 }, /* (259) cmd ::= RESET QUERY CACHE */ - { 308, -4 }, /* (260) cmd ::= EXPLAIN analyze_opt explain_options query_expression */ - { 369, 0 }, /* (261) analyze_opt ::= */ - { 369, -1 }, /* (262) analyze_opt ::= ANALYZE */ - { 370, 0 }, /* (263) explain_options ::= */ - { 370, -3 }, /* (264) explain_options ::= explain_options VERBOSE NK_BOOL */ - { 370, -3 }, /* (265) explain_options ::= explain_options RATIO NK_FLOAT */ - { 308, -10 }, /* (266) cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */ - { 308, -4 }, /* (267) cmd ::= DROP FUNCTION exists_opt function_name */ - { 371, 0 }, /* (268) agg_func_opt ::= */ - { 371, -1 }, /* (269) agg_func_opt ::= AGGREGATE */ - { 372, 0 }, /* (270) bufsize_opt ::= */ - { 372, -2 }, /* (271) bufsize_opt ::= BUFSIZE NK_INTEGER */ - { 308, -9 }, /* (272) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name AS query_expression */ - { 308, -4 }, /* (273) cmd ::= DROP STREAM exists_opt stream_name */ - { 365, 0 }, /* (274) stream_options ::= */ - { 365, -3 }, /* (275) stream_options ::= stream_options TRIGGER AT_ONCE */ - { 365, -3 }, /* (276) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ - { 365, -4 }, /* (277) stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ - { 365, -3 }, /* (278) stream_options ::= stream_options WATERMARK duration_literal */ - { 365, -4 }, /* (279) stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ - { 308, -3 }, /* (280) cmd ::= KILL CONNECTION NK_INTEGER */ - { 308, -3 }, /* (281) cmd ::= KILL QUERY NK_STRING */ - { 308, -3 }, /* (282) cmd ::= KILL TRANSACTION NK_INTEGER */ - { 308, -2 }, /* (283) cmd ::= BALANCE VGROUP */ - { 308, -4 }, /* (284) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ - { 308, -4 }, /* (285) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ - { 308, -3 }, /* (286) cmd ::= SPLIT VGROUP NK_INTEGER */ - { 374, -2 }, /* (287) dnode_list ::= DNODE NK_INTEGER */ - { 374, -3 }, /* (288) dnode_list ::= dnode_list DNODE NK_INTEGER */ - { 308, -4 }, /* (289) cmd ::= DELETE FROM full_table_name where_clause_opt */ - { 308, -1 }, /* (290) cmd ::= query_expression */ - { 308, -7 }, /* (291) cmd ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_expression */ - { 308, -4 }, /* (292) cmd ::= INSERT INTO full_table_name query_expression */ - { 311, -1 }, /* (293) literal ::= NK_INTEGER */ - { 311, -1 }, /* (294) literal ::= NK_FLOAT */ - { 311, -1 }, /* (295) literal ::= NK_STRING */ - { 311, -1 }, /* (296) literal ::= NK_BOOL */ - { 311, -2 }, /* (297) literal ::= TIMESTAMP NK_STRING */ - { 311, -1 }, /* (298) literal ::= duration_literal */ - { 311, -1 }, /* (299) literal ::= NULL */ - { 311, -1 }, /* (300) literal ::= NK_QUESTION */ - { 352, -1 }, /* (301) duration_literal ::= NK_VARIABLE */ - { 376, -1 }, /* (302) signed ::= NK_INTEGER */ - { 376, -2 }, /* (303) signed ::= NK_PLUS NK_INTEGER */ - { 376, -2 }, /* (304) signed ::= NK_MINUS NK_INTEGER */ - { 376, -1 }, /* (305) signed ::= NK_FLOAT */ - { 376, -2 }, /* (306) signed ::= NK_PLUS NK_FLOAT */ - { 376, -2 }, /* (307) signed ::= NK_MINUS NK_FLOAT */ - { 341, -1 }, /* (308) signed_literal ::= signed */ - { 341, -1 }, /* (309) signed_literal ::= NK_STRING */ - { 341, -1 }, /* (310) signed_literal ::= NK_BOOL */ - { 341, -2 }, /* (311) signed_literal ::= TIMESTAMP NK_STRING */ - { 341, -1 }, /* (312) signed_literal ::= duration_literal */ - { 341, -1 }, /* (313) signed_literal ::= NULL */ - { 341, -1 }, /* (314) signed_literal ::= literal_func */ - { 341, -1 }, /* (315) signed_literal ::= NK_QUESTION */ - { 378, -1 }, /* (316) literal_list ::= signed_literal */ - { 378, -3 }, /* (317) literal_list ::= literal_list NK_COMMA signed_literal */ - { 319, -1 }, /* (318) db_name ::= NK_ID */ - { 347, -1 }, /* (319) table_name ::= NK_ID */ - { 339, -1 }, /* (320) column_name ::= NK_ID */ - { 354, -1 }, /* (321) function_name ::= NK_ID */ - { 379, -1 }, /* (322) table_alias ::= NK_ID */ - { 380, -1 }, /* (323) column_alias ::= NK_ID */ - { 313, -1 }, /* (324) user_name ::= NK_ID */ - { 366, -1 }, /* (325) topic_name ::= NK_ID */ - { 373, -1 }, /* (326) stream_name ::= NK_ID */ - { 368, -1 }, /* (327) cgroup_name ::= NK_ID */ - { 381, -1 }, /* (328) expression ::= literal */ - { 381, -1 }, /* (329) expression ::= pseudo_column */ - { 381, -1 }, /* (330) expression ::= column_reference */ - { 381, -1 }, /* (331) expression ::= function_expression */ - { 381, -1 }, /* (332) expression ::= subquery */ - { 381, -3 }, /* (333) expression ::= NK_LP expression NK_RP */ - { 381, -2 }, /* (334) expression ::= NK_PLUS expression */ - { 381, -2 }, /* (335) expression ::= NK_MINUS expression */ - { 381, -3 }, /* (336) expression ::= expression NK_PLUS expression */ - { 381, -3 }, /* (337) expression ::= expression NK_MINUS expression */ - { 381, -3 }, /* (338) expression ::= expression NK_STAR expression */ - { 381, -3 }, /* (339) expression ::= expression NK_SLASH expression */ - { 381, -3 }, /* (340) expression ::= expression NK_REM expression */ - { 381, -3 }, /* (341) expression ::= column_reference NK_ARROW NK_STRING */ - { 381, -3 }, /* (342) expression ::= expression NK_BITAND expression */ - { 381, -3 }, /* (343) expression ::= expression NK_BITOR expression */ - { 344, -1 }, /* (344) expression_list ::= expression */ - { 344, -3 }, /* (345) expression_list ::= expression_list NK_COMMA expression */ - { 383, -1 }, /* (346) column_reference ::= column_name */ - { 383, -3 }, /* (347) column_reference ::= table_name NK_DOT column_name */ - { 382, -1 }, /* (348) pseudo_column ::= ROWTS */ - { 382, -1 }, /* (349) pseudo_column ::= TBNAME */ - { 382, -3 }, /* (350) pseudo_column ::= table_name NK_DOT TBNAME */ - { 382, -1 }, /* (351) pseudo_column ::= QSTART */ - { 382, -1 }, /* (352) pseudo_column ::= QEND */ - { 382, -1 }, /* (353) pseudo_column ::= QDURATION */ - { 382, -1 }, /* (354) pseudo_column ::= WSTART */ - { 382, -1 }, /* (355) pseudo_column ::= WEND */ - { 382, -1 }, /* (356) pseudo_column ::= WDURATION */ - { 384, -4 }, /* (357) function_expression ::= function_name NK_LP expression_list NK_RP */ - { 384, -4 }, /* (358) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ - { 384, -6 }, /* (359) function_expression ::= CAST NK_LP expression AS type_name NK_RP */ - { 384, -1 }, /* (360) function_expression ::= literal_func */ - { 377, -3 }, /* (361) literal_func ::= noarg_func NK_LP NK_RP */ - { 377, -1 }, /* (362) literal_func ::= NOW */ - { 388, -1 }, /* (363) noarg_func ::= NOW */ - { 388, -1 }, /* (364) noarg_func ::= TODAY */ - { 388, -1 }, /* (365) noarg_func ::= TIMEZONE */ - { 388, -1 }, /* (366) noarg_func ::= DATABASE */ - { 388, -1 }, /* (367) noarg_func ::= CLIENT_VERSION */ - { 388, -1 }, /* (368) noarg_func ::= SERVER_VERSION */ - { 388, -1 }, /* (369) noarg_func ::= SERVER_STATUS */ - { 388, -1 }, /* (370) noarg_func ::= CURRENT_USER */ - { 388, -1 }, /* (371) noarg_func ::= USER */ - { 386, -1 }, /* (372) star_func ::= COUNT */ - { 386, -1 }, /* (373) star_func ::= FIRST */ - { 386, -1 }, /* (374) star_func ::= LAST */ - { 386, -1 }, /* (375) star_func ::= LAST_ROW */ - { 387, -1 }, /* (376) star_func_para_list ::= NK_STAR */ - { 387, -1 }, /* (377) star_func_para_list ::= other_para_list */ - { 389, -1 }, /* (378) other_para_list ::= star_func_para */ - { 389, -3 }, /* (379) other_para_list ::= other_para_list NK_COMMA star_func_para */ - { 390, -1 }, /* (380) star_func_para ::= expression */ - { 390, -3 }, /* (381) star_func_para ::= table_name NK_DOT NK_STAR */ - { 391, -3 }, /* (382) predicate ::= expression compare_op expression */ - { 391, -5 }, /* (383) predicate ::= expression BETWEEN expression AND expression */ - { 391, -6 }, /* (384) predicate ::= expression NOT BETWEEN expression AND expression */ - { 391, -3 }, /* (385) predicate ::= expression IS NULL */ - { 391, -4 }, /* (386) predicate ::= expression IS NOT NULL */ - { 391, -3 }, /* (387) predicate ::= expression in_op in_predicate_value */ - { 392, -1 }, /* (388) compare_op ::= NK_LT */ - { 392, -1 }, /* (389) compare_op ::= NK_GT */ - { 392, -1 }, /* (390) compare_op ::= NK_LE */ - { 392, -1 }, /* (391) compare_op ::= NK_GE */ - { 392, -1 }, /* (392) compare_op ::= NK_NE */ - { 392, -1 }, /* (393) compare_op ::= NK_EQ */ - { 392, -1 }, /* (394) compare_op ::= LIKE */ - { 392, -2 }, /* (395) compare_op ::= NOT LIKE */ - { 392, -1 }, /* (396) compare_op ::= MATCH */ - { 392, -1 }, /* (397) compare_op ::= NMATCH */ - { 392, -1 }, /* (398) compare_op ::= CONTAINS */ - { 393, -1 }, /* (399) in_op ::= IN */ - { 393, -2 }, /* (400) in_op ::= NOT IN */ - { 394, -3 }, /* (401) in_predicate_value ::= NK_LP literal_list NK_RP */ - { 395, -1 }, /* (402) boolean_value_expression ::= boolean_primary */ - { 395, -2 }, /* (403) boolean_value_expression ::= NOT boolean_primary */ - { 395, -3 }, /* (404) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ - { 395, -3 }, /* (405) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ - { 396, -1 }, /* (406) boolean_primary ::= predicate */ - { 396, -3 }, /* (407) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ - { 397, -1 }, /* (408) common_expression ::= expression */ - { 397, -1 }, /* (409) common_expression ::= boolean_value_expression */ - { 398, 0 }, /* (410) from_clause_opt ::= */ - { 398, -2 }, /* (411) from_clause_opt ::= FROM table_reference_list */ - { 399, -1 }, /* (412) table_reference_list ::= table_reference */ - { 399, -3 }, /* (413) table_reference_list ::= table_reference_list NK_COMMA table_reference */ - { 400, -1 }, /* (414) table_reference ::= table_primary */ - { 400, -1 }, /* (415) table_reference ::= joined_table */ - { 401, -2 }, /* (416) table_primary ::= table_name alias_opt */ - { 401, -4 }, /* (417) table_primary ::= db_name NK_DOT table_name alias_opt */ - { 401, -2 }, /* (418) table_primary ::= subquery alias_opt */ - { 401, -1 }, /* (419) table_primary ::= parenthesized_joined_table */ - { 403, 0 }, /* (420) alias_opt ::= */ - { 403, -1 }, /* (421) alias_opt ::= table_alias */ - { 403, -2 }, /* (422) alias_opt ::= AS table_alias */ - { 404, -3 }, /* (423) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - { 404, -3 }, /* (424) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ - { 402, -6 }, /* (425) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ - { 405, 0 }, /* (426) join_type ::= */ - { 405, -1 }, /* (427) join_type ::= INNER */ - { 407, -12 }, /* (428) query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ - { 408, 0 }, /* (429) set_quantifier_opt ::= */ - { 408, -1 }, /* (430) set_quantifier_opt ::= DISTINCT */ - { 408, -1 }, /* (431) set_quantifier_opt ::= ALL */ - { 409, -1 }, /* (432) select_list ::= select_item */ - { 409, -3 }, /* (433) select_list ::= select_list NK_COMMA select_item */ - { 417, -1 }, /* (434) select_item ::= NK_STAR */ - { 417, -1 }, /* (435) select_item ::= common_expression */ - { 417, -2 }, /* (436) select_item ::= common_expression column_alias */ - { 417, -3 }, /* (437) select_item ::= common_expression AS column_alias */ - { 417, -3 }, /* (438) select_item ::= table_name NK_DOT NK_STAR */ - { 375, 0 }, /* (439) where_clause_opt ::= */ - { 375, -2 }, /* (440) where_clause_opt ::= WHERE search_condition */ - { 410, 0 }, /* (441) partition_by_clause_opt ::= */ - { 410, -3 }, /* (442) partition_by_clause_opt ::= PARTITION BY expression_list */ - { 414, 0 }, /* (443) twindow_clause_opt ::= */ - { 414, -6 }, /* (444) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ - { 414, -4 }, /* (445) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */ - { 414, -6 }, /* (446) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ - { 414, -8 }, /* (447) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ - { 362, 0 }, /* (448) sliding_opt ::= */ - { 362, -4 }, /* (449) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ - { 413, 0 }, /* (450) fill_opt ::= */ - { 413, -4 }, /* (451) fill_opt ::= FILL NK_LP fill_mode NK_RP */ - { 413, -6 }, /* (452) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ - { 418, -1 }, /* (453) fill_mode ::= NONE */ - { 418, -1 }, /* (454) fill_mode ::= PREV */ - { 418, -1 }, /* (455) fill_mode ::= NULL */ - { 418, -1 }, /* (456) fill_mode ::= LINEAR */ - { 418, -1 }, /* (457) fill_mode ::= NEXT */ - { 415, 0 }, /* (458) group_by_clause_opt ::= */ - { 415, -3 }, /* (459) group_by_clause_opt ::= GROUP BY group_by_list */ - { 419, -1 }, /* (460) group_by_list ::= expression */ - { 419, -3 }, /* (461) group_by_list ::= group_by_list NK_COMMA expression */ - { 416, 0 }, /* (462) having_clause_opt ::= */ - { 416, -2 }, /* (463) having_clause_opt ::= HAVING search_condition */ - { 411, 0 }, /* (464) range_opt ::= */ - { 411, -6 }, /* (465) range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP */ - { 412, 0 }, /* (466) every_opt ::= */ - { 412, -4 }, /* (467) every_opt ::= EVERY NK_LP duration_literal NK_RP */ - { 367, -4 }, /* (468) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ - { 420, -1 }, /* (469) query_expression_body ::= query_primary */ - { 420, -4 }, /* (470) query_expression_body ::= query_expression_body UNION ALL query_expression_body */ - { 420, -3 }, /* (471) query_expression_body ::= query_expression_body UNION query_expression_body */ - { 424, -1 }, /* (472) query_primary ::= query_specification */ - { 424, -6 }, /* (473) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */ - { 421, 0 }, /* (474) order_by_clause_opt ::= */ - { 421, -3 }, /* (475) order_by_clause_opt ::= ORDER BY sort_specification_list */ - { 422, 0 }, /* (476) slimit_clause_opt ::= */ - { 422, -2 }, /* (477) slimit_clause_opt ::= SLIMIT NK_INTEGER */ - { 422, -4 }, /* (478) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - { 422, -4 }, /* (479) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - { 423, 0 }, /* (480) limit_clause_opt ::= */ - { 423, -2 }, /* (481) limit_clause_opt ::= LIMIT NK_INTEGER */ - { 423, -4 }, /* (482) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ - { 423, -4 }, /* (483) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - { 385, -3 }, /* (484) subquery ::= NK_LP query_expression NK_RP */ - { 406, -1 }, /* (485) search_condition ::= common_expression */ - { 425, -1 }, /* (486) sort_specification_list ::= sort_specification */ - { 425, -3 }, /* (487) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ - { 426, -3 }, /* (488) sort_specification ::= expression ordering_specification_opt null_ordering_opt */ - { 427, 0 }, /* (489) ordering_specification_opt ::= */ - { 427, -1 }, /* (490) ordering_specification_opt ::= ASC */ - { 427, -1 }, /* (491) ordering_specification_opt ::= DESC */ - { 428, 0 }, /* (492) null_ordering_opt ::= */ - { 428, -2 }, /* (493) null_ordering_opt ::= NULLS FIRST */ - { 428, -2 }, /* (494) null_ordering_opt ::= NULLS LAST */ + { 309, -6 }, /* (0) cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */ + { 309, -4 }, /* (1) cmd ::= ALTER ACCOUNT NK_ID alter_account_options */ + { 310, 0 }, /* (2) account_options ::= */ + { 310, -3 }, /* (3) account_options ::= account_options PPS literal */ + { 310, -3 }, /* (4) account_options ::= account_options TSERIES literal */ + { 310, -3 }, /* (5) account_options ::= account_options STORAGE literal */ + { 310, -3 }, /* (6) account_options ::= account_options STREAMS literal */ + { 310, -3 }, /* (7) account_options ::= account_options QTIME literal */ + { 310, -3 }, /* (8) account_options ::= account_options DBS literal */ + { 310, -3 }, /* (9) account_options ::= account_options USERS literal */ + { 310, -3 }, /* (10) account_options ::= account_options CONNS literal */ + { 310, -3 }, /* (11) account_options ::= account_options STATE literal */ + { 311, -1 }, /* (12) alter_account_options ::= alter_account_option */ + { 311, -2 }, /* (13) alter_account_options ::= alter_account_options alter_account_option */ + { 313, -2 }, /* (14) alter_account_option ::= PASS literal */ + { 313, -2 }, /* (15) alter_account_option ::= PPS literal */ + { 313, -2 }, /* (16) alter_account_option ::= TSERIES literal */ + { 313, -2 }, /* (17) alter_account_option ::= STORAGE literal */ + { 313, -2 }, /* (18) alter_account_option ::= STREAMS literal */ + { 313, -2 }, /* (19) alter_account_option ::= QTIME literal */ + { 313, -2 }, /* (20) alter_account_option ::= DBS literal */ + { 313, -2 }, /* (21) alter_account_option ::= USERS literal */ + { 313, -2 }, /* (22) alter_account_option ::= CONNS literal */ + { 313, -2 }, /* (23) alter_account_option ::= STATE literal */ + { 309, -6 }, /* (24) cmd ::= CREATE USER user_name PASS NK_STRING sysinfo_opt */ + { 309, -5 }, /* (25) cmd ::= ALTER USER user_name PASS NK_STRING */ + { 309, -5 }, /* (26) cmd ::= ALTER USER user_name ENABLE NK_INTEGER */ + { 309, -5 }, /* (27) cmd ::= ALTER USER user_name SYSINFO NK_INTEGER */ + { 309, -3 }, /* (28) cmd ::= DROP USER user_name */ + { 315, 0 }, /* (29) sysinfo_opt ::= */ + { 315, -2 }, /* (30) sysinfo_opt ::= SYSINFO NK_INTEGER */ + { 309, -6 }, /* (31) cmd ::= GRANT privileges ON priv_level TO user_name */ + { 309, -6 }, /* (32) cmd ::= REVOKE privileges ON priv_level FROM user_name */ + { 316, -1 }, /* (33) privileges ::= ALL */ + { 316, -1 }, /* (34) privileges ::= priv_type_list */ + { 318, -1 }, /* (35) priv_type_list ::= priv_type */ + { 318, -3 }, /* (36) priv_type_list ::= priv_type_list NK_COMMA priv_type */ + { 319, -1 }, /* (37) priv_type ::= READ */ + { 319, -1 }, /* (38) priv_type ::= WRITE */ + { 317, -3 }, /* (39) priv_level ::= NK_STAR NK_DOT NK_STAR */ + { 317, -3 }, /* (40) priv_level ::= db_name NK_DOT NK_STAR */ + { 309, -3 }, /* (41) cmd ::= CREATE DNODE dnode_endpoint */ + { 309, -5 }, /* (42) cmd ::= CREATE DNODE dnode_endpoint PORT NK_INTEGER */ + { 309, -3 }, /* (43) cmd ::= DROP DNODE NK_INTEGER */ + { 309, -3 }, /* (44) cmd ::= DROP DNODE dnode_endpoint */ + { 309, -4 }, /* (45) cmd ::= ALTER DNODE NK_INTEGER NK_STRING */ + { 309, -5 }, /* (46) cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */ + { 309, -4 }, /* (47) cmd ::= ALTER ALL DNODES NK_STRING */ + { 309, -5 }, /* (48) cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */ + { 321, -1 }, /* (49) dnode_endpoint ::= NK_STRING */ + { 321, -1 }, /* (50) dnode_endpoint ::= NK_ID */ + { 321, -1 }, /* (51) dnode_endpoint ::= NK_IPTOKEN */ + { 309, -3 }, /* (52) cmd ::= ALTER LOCAL NK_STRING */ + { 309, -4 }, /* (53) cmd ::= ALTER LOCAL NK_STRING NK_STRING */ + { 309, -5 }, /* (54) cmd ::= CREATE QNODE ON DNODE NK_INTEGER */ + { 309, -5 }, /* (55) cmd ::= DROP QNODE ON DNODE NK_INTEGER */ + { 309, -5 }, /* (56) cmd ::= CREATE BNODE ON DNODE NK_INTEGER */ + { 309, -5 }, /* (57) cmd ::= DROP BNODE ON DNODE NK_INTEGER */ + { 309, -5 }, /* (58) cmd ::= CREATE SNODE ON DNODE NK_INTEGER */ + { 309, -5 }, /* (59) cmd ::= DROP SNODE ON DNODE NK_INTEGER */ + { 309, -5 }, /* (60) cmd ::= CREATE MNODE ON DNODE NK_INTEGER */ + { 309, -5 }, /* (61) cmd ::= DROP MNODE ON DNODE NK_INTEGER */ + { 309, -5 }, /* (62) cmd ::= CREATE DATABASE not_exists_opt db_name db_options */ + { 309, -4 }, /* (63) cmd ::= DROP DATABASE exists_opt db_name */ + { 309, -2 }, /* (64) cmd ::= USE db_name */ + { 309, -4 }, /* (65) cmd ::= ALTER DATABASE db_name alter_db_options */ + { 309, -3 }, /* (66) cmd ::= FLUSH DATABASE db_name */ + { 309, -3 }, /* (67) cmd ::= TRIM DATABASE db_name */ + { 322, -3 }, /* (68) not_exists_opt ::= IF NOT EXISTS */ + { 322, 0 }, /* (69) not_exists_opt ::= */ + { 324, -2 }, /* (70) exists_opt ::= IF EXISTS */ + { 324, 0 }, /* (71) exists_opt ::= */ + { 323, 0 }, /* (72) db_options ::= */ + { 323, -3 }, /* (73) db_options ::= db_options BUFFER NK_INTEGER */ + { 323, -3 }, /* (74) db_options ::= db_options CACHEMODEL NK_STRING */ + { 323, -3 }, /* (75) db_options ::= db_options CACHESIZE NK_INTEGER */ + { 323, -3 }, /* (76) db_options ::= db_options COMP NK_INTEGER */ + { 323, -3 }, /* (77) db_options ::= db_options DURATION NK_INTEGER */ + { 323, -3 }, /* (78) db_options ::= db_options DURATION NK_VARIABLE */ + { 323, -3 }, /* (79) db_options ::= db_options MAXROWS NK_INTEGER */ + { 323, -3 }, /* (80) db_options ::= db_options MINROWS NK_INTEGER */ + { 323, -3 }, /* (81) db_options ::= db_options KEEP integer_list */ + { 323, -3 }, /* (82) db_options ::= db_options KEEP variable_list */ + { 323, -3 }, /* (83) db_options ::= db_options PAGES NK_INTEGER */ + { 323, -3 }, /* (84) db_options ::= db_options PAGESIZE NK_INTEGER */ + { 323, -3 }, /* (85) db_options ::= db_options TSDB_PAGESIZE NK_INTEGER */ + { 323, -3 }, /* (86) db_options ::= db_options PRECISION NK_STRING */ + { 323, -3 }, /* (87) db_options ::= db_options REPLICA NK_INTEGER */ + { 323, -3 }, /* (88) db_options ::= db_options STRICT NK_STRING */ + { 323, -3 }, /* (89) db_options ::= db_options VGROUPS NK_INTEGER */ + { 323, -3 }, /* (90) db_options ::= db_options SINGLE_STABLE NK_INTEGER */ + { 323, -3 }, /* (91) db_options ::= db_options RETENTIONS retention_list */ + { 323, -3 }, /* (92) db_options ::= db_options SCHEMALESS NK_INTEGER */ + { 323, -3 }, /* (93) db_options ::= db_options WAL_LEVEL NK_INTEGER */ + { 323, -3 }, /* (94) db_options ::= db_options WAL_FSYNC_PERIOD NK_INTEGER */ + { 323, -3 }, /* (95) db_options ::= db_options WAL_RETENTION_PERIOD NK_INTEGER */ + { 323, -4 }, /* (96) db_options ::= db_options WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ + { 323, -3 }, /* (97) db_options ::= db_options WAL_RETENTION_SIZE NK_INTEGER */ + { 323, -4 }, /* (98) db_options ::= db_options WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ + { 323, -3 }, /* (99) db_options ::= db_options WAL_ROLL_PERIOD NK_INTEGER */ + { 323, -3 }, /* (100) db_options ::= db_options WAL_SEGMENT_SIZE NK_INTEGER */ + { 323, -3 }, /* (101) db_options ::= db_options STT_TRIGGER NK_INTEGER */ + { 323, -3 }, /* (102) db_options ::= db_options TABLE_PREFIX NK_INTEGER */ + { 323, -3 }, /* (103) db_options ::= db_options TABLE_SUFFIX NK_INTEGER */ + { 325, -1 }, /* (104) alter_db_options ::= alter_db_option */ + { 325, -2 }, /* (105) alter_db_options ::= alter_db_options alter_db_option */ + { 329, -2 }, /* (106) alter_db_option ::= CACHEMODEL NK_STRING */ + { 329, -2 }, /* (107) alter_db_option ::= CACHESIZE NK_INTEGER */ + { 329, -2 }, /* (108) alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */ + { 329, -2 }, /* (109) alter_db_option ::= KEEP integer_list */ + { 329, -2 }, /* (110) alter_db_option ::= KEEP variable_list */ + { 329, -2 }, /* (111) alter_db_option ::= WAL_LEVEL NK_INTEGER */ + { 329, -2 }, /* (112) alter_db_option ::= STT_TRIGGER NK_INTEGER */ + { 326, -1 }, /* (113) integer_list ::= NK_INTEGER */ + { 326, -3 }, /* (114) integer_list ::= integer_list NK_COMMA NK_INTEGER */ + { 327, -1 }, /* (115) variable_list ::= NK_VARIABLE */ + { 327, -3 }, /* (116) variable_list ::= variable_list NK_COMMA NK_VARIABLE */ + { 328, -1 }, /* (117) retention_list ::= retention */ + { 328, -3 }, /* (118) retention_list ::= retention_list NK_COMMA retention */ + { 330, -3 }, /* (119) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ + { 309, -9 }, /* (120) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ + { 309, -3 }, /* (121) cmd ::= CREATE TABLE multi_create_clause */ + { 309, -9 }, /* (122) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ + { 309, -3 }, /* (123) cmd ::= DROP TABLE multi_drop_clause */ + { 309, -4 }, /* (124) cmd ::= DROP STABLE exists_opt full_table_name */ + { 309, -3 }, /* (125) cmd ::= ALTER TABLE alter_table_clause */ + { 309, -3 }, /* (126) cmd ::= ALTER STABLE alter_table_clause */ + { 338, -2 }, /* (127) alter_table_clause ::= full_table_name alter_table_options */ + { 338, -5 }, /* (128) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ + { 338, -4 }, /* (129) alter_table_clause ::= full_table_name DROP COLUMN column_name */ + { 338, -5 }, /* (130) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ + { 338, -5 }, /* (131) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ + { 338, -5 }, /* (132) alter_table_clause ::= full_table_name ADD TAG column_name type_name */ + { 338, -4 }, /* (133) alter_table_clause ::= full_table_name DROP TAG column_name */ + { 338, -5 }, /* (134) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ + { 338, -5 }, /* (135) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ + { 338, -6 }, /* (136) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ + { 335, -1 }, /* (137) multi_create_clause ::= create_subtable_clause */ + { 335, -2 }, /* (138) multi_create_clause ::= multi_create_clause create_subtable_clause */ + { 343, -10 }, /* (139) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP expression_list NK_RP table_options */ + { 337, -1 }, /* (140) multi_drop_clause ::= drop_table_clause */ + { 337, -2 }, /* (141) multi_drop_clause ::= multi_drop_clause drop_table_clause */ + { 346, -2 }, /* (142) drop_table_clause ::= exists_opt full_table_name */ + { 344, 0 }, /* (143) specific_cols_opt ::= */ + { 344, -3 }, /* (144) specific_cols_opt ::= NK_LP col_name_list NK_RP */ + { 331, -1 }, /* (145) full_table_name ::= table_name */ + { 331, -3 }, /* (146) full_table_name ::= db_name NK_DOT table_name */ + { 332, -1 }, /* (147) column_def_list ::= column_def */ + { 332, -3 }, /* (148) column_def_list ::= column_def_list NK_COMMA column_def */ + { 349, -2 }, /* (149) column_def ::= column_name type_name */ + { 349, -4 }, /* (150) column_def ::= column_name type_name COMMENT NK_STRING */ + { 341, -1 }, /* (151) type_name ::= BOOL */ + { 341, -1 }, /* (152) type_name ::= TINYINT */ + { 341, -1 }, /* (153) type_name ::= SMALLINT */ + { 341, -1 }, /* (154) type_name ::= INT */ + { 341, -1 }, /* (155) type_name ::= INTEGER */ + { 341, -1 }, /* (156) type_name ::= BIGINT */ + { 341, -1 }, /* (157) type_name ::= FLOAT */ + { 341, -1 }, /* (158) type_name ::= DOUBLE */ + { 341, -4 }, /* (159) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ + { 341, -1 }, /* (160) type_name ::= TIMESTAMP */ + { 341, -4 }, /* (161) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ + { 341, -2 }, /* (162) type_name ::= TINYINT UNSIGNED */ + { 341, -2 }, /* (163) type_name ::= SMALLINT UNSIGNED */ + { 341, -2 }, /* (164) type_name ::= INT UNSIGNED */ + { 341, -2 }, /* (165) type_name ::= BIGINT UNSIGNED */ + { 341, -1 }, /* (166) type_name ::= JSON */ + { 341, -4 }, /* (167) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ + { 341, -1 }, /* (168) type_name ::= MEDIUMBLOB */ + { 341, -1 }, /* (169) type_name ::= BLOB */ + { 341, -4 }, /* (170) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ + { 341, -1 }, /* (171) type_name ::= DECIMAL */ + { 341, -4 }, /* (172) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ + { 341, -6 }, /* (173) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ + { 333, 0 }, /* (174) tags_def_opt ::= */ + { 333, -1 }, /* (175) tags_def_opt ::= tags_def */ + { 336, -4 }, /* (176) tags_def ::= TAGS NK_LP column_def_list NK_RP */ + { 334, 0 }, /* (177) table_options ::= */ + { 334, -3 }, /* (178) table_options ::= table_options COMMENT NK_STRING */ + { 334, -3 }, /* (179) table_options ::= table_options MAX_DELAY duration_list */ + { 334, -3 }, /* (180) table_options ::= table_options WATERMARK duration_list */ + { 334, -5 }, /* (181) table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ + { 334, -3 }, /* (182) table_options ::= table_options TTL NK_INTEGER */ + { 334, -5 }, /* (183) table_options ::= table_options SMA NK_LP col_name_list NK_RP */ + { 339, -1 }, /* (184) alter_table_options ::= alter_table_option */ + { 339, -2 }, /* (185) alter_table_options ::= alter_table_options alter_table_option */ + { 352, -2 }, /* (186) alter_table_option ::= COMMENT NK_STRING */ + { 352, -2 }, /* (187) alter_table_option ::= TTL NK_INTEGER */ + { 350, -1 }, /* (188) duration_list ::= duration_literal */ + { 350, -3 }, /* (189) duration_list ::= duration_list NK_COMMA duration_literal */ + { 351, -1 }, /* (190) rollup_func_list ::= rollup_func_name */ + { 351, -3 }, /* (191) rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ + { 354, -1 }, /* (192) rollup_func_name ::= function_name */ + { 354, -1 }, /* (193) rollup_func_name ::= FIRST */ + { 354, -1 }, /* (194) rollup_func_name ::= LAST */ + { 347, -1 }, /* (195) col_name_list ::= col_name */ + { 347, -3 }, /* (196) col_name_list ::= col_name_list NK_COMMA col_name */ + { 356, -1 }, /* (197) col_name ::= column_name */ + { 309, -2 }, /* (198) cmd ::= SHOW DNODES */ + { 309, -2 }, /* (199) cmd ::= SHOW USERS */ + { 309, -2 }, /* (200) cmd ::= SHOW DATABASES */ + { 309, -4 }, /* (201) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */ + { 309, -4 }, /* (202) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ + { 309, -3 }, /* (203) cmd ::= SHOW db_name_cond_opt VGROUPS */ + { 309, -2 }, /* (204) cmd ::= SHOW MNODES */ + { 309, -2 }, /* (205) cmd ::= SHOW MODULES */ + { 309, -2 }, /* (206) cmd ::= SHOW QNODES */ + { 309, -2 }, /* (207) cmd ::= SHOW FUNCTIONS */ + { 309, -5 }, /* (208) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ + { 309, -2 }, /* (209) cmd ::= SHOW STREAMS */ + { 309, -2 }, /* (210) cmd ::= SHOW ACCOUNTS */ + { 309, -2 }, /* (211) cmd ::= SHOW APPS */ + { 309, -2 }, /* (212) cmd ::= SHOW CONNECTIONS */ + { 309, -2 }, /* (213) cmd ::= SHOW LICENCES */ + { 309, -2 }, /* (214) cmd ::= SHOW GRANTS */ + { 309, -4 }, /* (215) cmd ::= SHOW CREATE DATABASE db_name */ + { 309, -4 }, /* (216) cmd ::= SHOW CREATE TABLE full_table_name */ + { 309, -4 }, /* (217) cmd ::= SHOW CREATE STABLE full_table_name */ + { 309, -2 }, /* (218) cmd ::= SHOW QUERIES */ + { 309, -2 }, /* (219) cmd ::= SHOW SCORES */ + { 309, -2 }, /* (220) cmd ::= SHOW TOPICS */ + { 309, -2 }, /* (221) cmd ::= SHOW VARIABLES */ + { 309, -3 }, /* (222) cmd ::= SHOW LOCAL VARIABLES */ + { 309, -4 }, /* (223) cmd ::= SHOW DNODE NK_INTEGER VARIABLES */ + { 309, -2 }, /* (224) cmd ::= SHOW BNODES */ + { 309, -2 }, /* (225) cmd ::= SHOW SNODES */ + { 309, -2 }, /* (226) cmd ::= SHOW CLUSTER */ + { 309, -2 }, /* (227) cmd ::= SHOW TRANSACTIONS */ + { 309, -4 }, /* (228) cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ + { 309, -2 }, /* (229) cmd ::= SHOW CONSUMERS */ + { 309, -2 }, /* (230) cmd ::= SHOW SUBSCRIPTIONS */ + { 309, -5 }, /* (231) cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ + { 309, -3 }, /* (232) cmd ::= SHOW VNODES NK_INTEGER */ + { 309, -3 }, /* (233) cmd ::= SHOW VNODES NK_STRING */ + { 357, 0 }, /* (234) db_name_cond_opt ::= */ + { 357, -2 }, /* (235) db_name_cond_opt ::= db_name NK_DOT */ + { 358, 0 }, /* (236) like_pattern_opt ::= */ + { 358, -2 }, /* (237) like_pattern_opt ::= LIKE NK_STRING */ + { 359, -1 }, /* (238) table_name_cond ::= table_name */ + { 360, 0 }, /* (239) from_db_opt ::= */ + { 360, -2 }, /* (240) from_db_opt ::= FROM db_name */ + { 309, -8 }, /* (241) cmd ::= CREATE SMA INDEX not_exists_opt full_table_name ON full_table_name index_options */ + { 309, -4 }, /* (242) cmd ::= DROP INDEX exists_opt full_table_name */ + { 361, -10 }, /* (243) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ + { 361, -12 }, /* (244) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt */ + { 362, -1 }, /* (245) func_list ::= func */ + { 362, -3 }, /* (246) func_list ::= func_list NK_COMMA func */ + { 365, -4 }, /* (247) func ::= function_name NK_LP expression_list NK_RP */ + { 364, 0 }, /* (248) sma_stream_opt ::= */ + { 364, -3 }, /* (249) sma_stream_opt ::= stream_options WATERMARK duration_literal */ + { 364, -3 }, /* (250) sma_stream_opt ::= stream_options MAX_DELAY duration_literal */ + { 309, -6 }, /* (251) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression */ + { 309, -7 }, /* (252) cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name */ + { 309, -9 }, /* (253) cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS DATABASE db_name */ + { 309, -7 }, /* (254) cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name */ + { 309, -9 }, /* (255) cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS STABLE full_table_name */ + { 309, -4 }, /* (256) cmd ::= DROP TOPIC exists_opt topic_name */ + { 309, -7 }, /* (257) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ + { 309, -2 }, /* (258) cmd ::= DESC full_table_name */ + { 309, -2 }, /* (259) cmd ::= DESCRIBE full_table_name */ + { 309, -3 }, /* (260) cmd ::= RESET QUERY CACHE */ + { 309, -4 }, /* (261) cmd ::= EXPLAIN analyze_opt explain_options query_expression */ + { 370, 0 }, /* (262) analyze_opt ::= */ + { 370, -1 }, /* (263) analyze_opt ::= ANALYZE */ + { 371, 0 }, /* (264) explain_options ::= */ + { 371, -3 }, /* (265) explain_options ::= explain_options VERBOSE NK_BOOL */ + { 371, -3 }, /* (266) explain_options ::= explain_options RATIO NK_FLOAT */ + { 309, -10 }, /* (267) cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */ + { 309, -4 }, /* (268) cmd ::= DROP FUNCTION exists_opt function_name */ + { 372, 0 }, /* (269) agg_func_opt ::= */ + { 372, -1 }, /* (270) agg_func_opt ::= AGGREGATE */ + { 373, 0 }, /* (271) bufsize_opt ::= */ + { 373, -2 }, /* (272) bufsize_opt ::= BUFSIZE NK_INTEGER */ + { 309, -9 }, /* (273) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name AS query_expression */ + { 309, -4 }, /* (274) cmd ::= DROP STREAM exists_opt stream_name */ + { 366, 0 }, /* (275) stream_options ::= */ + { 366, -3 }, /* (276) stream_options ::= stream_options TRIGGER AT_ONCE */ + { 366, -3 }, /* (277) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ + { 366, -4 }, /* (278) stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ + { 366, -3 }, /* (279) stream_options ::= stream_options WATERMARK duration_literal */ + { 366, -4 }, /* (280) stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ + { 309, -3 }, /* (281) cmd ::= KILL CONNECTION NK_INTEGER */ + { 309, -3 }, /* (282) cmd ::= KILL QUERY NK_STRING */ + { 309, -3 }, /* (283) cmd ::= KILL TRANSACTION NK_INTEGER */ + { 309, -2 }, /* (284) cmd ::= BALANCE VGROUP */ + { 309, -4 }, /* (285) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ + { 309, -4 }, /* (286) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ + { 309, -3 }, /* (287) cmd ::= SPLIT VGROUP NK_INTEGER */ + { 375, -2 }, /* (288) dnode_list ::= DNODE NK_INTEGER */ + { 375, -3 }, /* (289) dnode_list ::= dnode_list DNODE NK_INTEGER */ + { 309, -4 }, /* (290) cmd ::= DELETE FROM full_table_name where_clause_opt */ + { 309, -1 }, /* (291) cmd ::= query_expression */ + { 309, -7 }, /* (292) cmd ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_expression */ + { 309, -4 }, /* (293) cmd ::= INSERT INTO full_table_name query_expression */ + { 312, -1 }, /* (294) literal ::= NK_INTEGER */ + { 312, -1 }, /* (295) literal ::= NK_FLOAT */ + { 312, -1 }, /* (296) literal ::= NK_STRING */ + { 312, -1 }, /* (297) literal ::= NK_BOOL */ + { 312, -2 }, /* (298) literal ::= TIMESTAMP NK_STRING */ + { 312, -1 }, /* (299) literal ::= duration_literal */ + { 312, -1 }, /* (300) literal ::= NULL */ + { 312, -1 }, /* (301) literal ::= NK_QUESTION */ + { 353, -1 }, /* (302) duration_literal ::= NK_VARIABLE */ + { 377, -1 }, /* (303) signed ::= NK_INTEGER */ + { 377, -2 }, /* (304) signed ::= NK_PLUS NK_INTEGER */ + { 377, -2 }, /* (305) signed ::= NK_MINUS NK_INTEGER */ + { 377, -1 }, /* (306) signed ::= NK_FLOAT */ + { 377, -2 }, /* (307) signed ::= NK_PLUS NK_FLOAT */ + { 377, -2 }, /* (308) signed ::= NK_MINUS NK_FLOAT */ + { 342, -1 }, /* (309) signed_literal ::= signed */ + { 342, -1 }, /* (310) signed_literal ::= NK_STRING */ + { 342, -1 }, /* (311) signed_literal ::= NK_BOOL */ + { 342, -2 }, /* (312) signed_literal ::= TIMESTAMP NK_STRING */ + { 342, -1 }, /* (313) signed_literal ::= duration_literal */ + { 342, -1 }, /* (314) signed_literal ::= NULL */ + { 342, -1 }, /* (315) signed_literal ::= literal_func */ + { 342, -1 }, /* (316) signed_literal ::= NK_QUESTION */ + { 379, -1 }, /* (317) literal_list ::= signed_literal */ + { 379, -3 }, /* (318) literal_list ::= literal_list NK_COMMA signed_literal */ + { 320, -1 }, /* (319) db_name ::= NK_ID */ + { 348, -1 }, /* (320) table_name ::= NK_ID */ + { 340, -1 }, /* (321) column_name ::= NK_ID */ + { 355, -1 }, /* (322) function_name ::= NK_ID */ + { 380, -1 }, /* (323) table_alias ::= NK_ID */ + { 381, -1 }, /* (324) column_alias ::= NK_ID */ + { 314, -1 }, /* (325) user_name ::= NK_ID */ + { 367, -1 }, /* (326) topic_name ::= NK_ID */ + { 374, -1 }, /* (327) stream_name ::= NK_ID */ + { 369, -1 }, /* (328) cgroup_name ::= NK_ID */ + { 382, -1 }, /* (329) expression ::= literal */ + { 382, -1 }, /* (330) expression ::= pseudo_column */ + { 382, -1 }, /* (331) expression ::= column_reference */ + { 382, -1 }, /* (332) expression ::= function_expression */ + { 382, -1 }, /* (333) expression ::= subquery */ + { 382, -3 }, /* (334) expression ::= NK_LP expression NK_RP */ + { 382, -2 }, /* (335) expression ::= NK_PLUS expression */ + { 382, -2 }, /* (336) expression ::= NK_MINUS expression */ + { 382, -3 }, /* (337) expression ::= expression NK_PLUS expression */ + { 382, -3 }, /* (338) expression ::= expression NK_MINUS expression */ + { 382, -3 }, /* (339) expression ::= expression NK_STAR expression */ + { 382, -3 }, /* (340) expression ::= expression NK_SLASH expression */ + { 382, -3 }, /* (341) expression ::= expression NK_REM expression */ + { 382, -3 }, /* (342) expression ::= column_reference NK_ARROW NK_STRING */ + { 382, -3 }, /* (343) expression ::= expression NK_BITAND expression */ + { 382, -3 }, /* (344) expression ::= expression NK_BITOR expression */ + { 345, -1 }, /* (345) expression_list ::= expression */ + { 345, -3 }, /* (346) expression_list ::= expression_list NK_COMMA expression */ + { 384, -1 }, /* (347) column_reference ::= column_name */ + { 384, -3 }, /* (348) column_reference ::= table_name NK_DOT column_name */ + { 383, -1 }, /* (349) pseudo_column ::= ROWTS */ + { 383, -1 }, /* (350) pseudo_column ::= TBNAME */ + { 383, -3 }, /* (351) pseudo_column ::= table_name NK_DOT TBNAME */ + { 383, -1 }, /* (352) pseudo_column ::= QSTART */ + { 383, -1 }, /* (353) pseudo_column ::= QEND */ + { 383, -1 }, /* (354) pseudo_column ::= QDURATION */ + { 383, -1 }, /* (355) pseudo_column ::= WSTART */ + { 383, -1 }, /* (356) pseudo_column ::= WEND */ + { 383, -1 }, /* (357) pseudo_column ::= WDURATION */ + { 385, -4 }, /* (358) function_expression ::= function_name NK_LP expression_list NK_RP */ + { 385, -4 }, /* (359) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ + { 385, -6 }, /* (360) function_expression ::= CAST NK_LP expression AS type_name NK_RP */ + { 385, -1 }, /* (361) function_expression ::= literal_func */ + { 378, -3 }, /* (362) literal_func ::= noarg_func NK_LP NK_RP */ + { 378, -1 }, /* (363) literal_func ::= NOW */ + { 389, -1 }, /* (364) noarg_func ::= NOW */ + { 389, -1 }, /* (365) noarg_func ::= TODAY */ + { 389, -1 }, /* (366) noarg_func ::= TIMEZONE */ + { 389, -1 }, /* (367) noarg_func ::= DATABASE */ + { 389, -1 }, /* (368) noarg_func ::= CLIENT_VERSION */ + { 389, -1 }, /* (369) noarg_func ::= SERVER_VERSION */ + { 389, -1 }, /* (370) noarg_func ::= SERVER_STATUS */ + { 389, -1 }, /* (371) noarg_func ::= CURRENT_USER */ + { 389, -1 }, /* (372) noarg_func ::= USER */ + { 387, -1 }, /* (373) star_func ::= COUNT */ + { 387, -1 }, /* (374) star_func ::= FIRST */ + { 387, -1 }, /* (375) star_func ::= LAST */ + { 387, -1 }, /* (376) star_func ::= LAST_ROW */ + { 388, -1 }, /* (377) star_func_para_list ::= NK_STAR */ + { 388, -1 }, /* (378) star_func_para_list ::= other_para_list */ + { 390, -1 }, /* (379) other_para_list ::= star_func_para */ + { 390, -3 }, /* (380) other_para_list ::= other_para_list NK_COMMA star_func_para */ + { 391, -1 }, /* (381) star_func_para ::= expression */ + { 391, -3 }, /* (382) star_func_para ::= table_name NK_DOT NK_STAR */ + { 392, -3 }, /* (383) predicate ::= expression compare_op expression */ + { 392, -5 }, /* (384) predicate ::= expression BETWEEN expression AND expression */ + { 392, -6 }, /* (385) predicate ::= expression NOT BETWEEN expression AND expression */ + { 392, -3 }, /* (386) predicate ::= expression IS NULL */ + { 392, -4 }, /* (387) predicate ::= expression IS NOT NULL */ + { 392, -3 }, /* (388) predicate ::= expression in_op in_predicate_value */ + { 393, -1 }, /* (389) compare_op ::= NK_LT */ + { 393, -1 }, /* (390) compare_op ::= NK_GT */ + { 393, -1 }, /* (391) compare_op ::= NK_LE */ + { 393, -1 }, /* (392) compare_op ::= NK_GE */ + { 393, -1 }, /* (393) compare_op ::= NK_NE */ + { 393, -1 }, /* (394) compare_op ::= NK_EQ */ + { 393, -1 }, /* (395) compare_op ::= LIKE */ + { 393, -2 }, /* (396) compare_op ::= NOT LIKE */ + { 393, -1 }, /* (397) compare_op ::= MATCH */ + { 393, -1 }, /* (398) compare_op ::= NMATCH */ + { 393, -1 }, /* (399) compare_op ::= CONTAINS */ + { 394, -1 }, /* (400) in_op ::= IN */ + { 394, -2 }, /* (401) in_op ::= NOT IN */ + { 395, -3 }, /* (402) in_predicate_value ::= NK_LP literal_list NK_RP */ + { 396, -1 }, /* (403) boolean_value_expression ::= boolean_primary */ + { 396, -2 }, /* (404) boolean_value_expression ::= NOT boolean_primary */ + { 396, -3 }, /* (405) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ + { 396, -3 }, /* (406) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ + { 397, -1 }, /* (407) boolean_primary ::= predicate */ + { 397, -3 }, /* (408) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ + { 398, -1 }, /* (409) common_expression ::= expression */ + { 398, -1 }, /* (410) common_expression ::= boolean_value_expression */ + { 399, 0 }, /* (411) from_clause_opt ::= */ + { 399, -2 }, /* (412) from_clause_opt ::= FROM table_reference_list */ + { 400, -1 }, /* (413) table_reference_list ::= table_reference */ + { 400, -3 }, /* (414) table_reference_list ::= table_reference_list NK_COMMA table_reference */ + { 401, -1 }, /* (415) table_reference ::= table_primary */ + { 401, -1 }, /* (416) table_reference ::= joined_table */ + { 402, -2 }, /* (417) table_primary ::= table_name alias_opt */ + { 402, -4 }, /* (418) table_primary ::= db_name NK_DOT table_name alias_opt */ + { 402, -2 }, /* (419) table_primary ::= subquery alias_opt */ + { 402, -1 }, /* (420) table_primary ::= parenthesized_joined_table */ + { 404, 0 }, /* (421) alias_opt ::= */ + { 404, -1 }, /* (422) alias_opt ::= table_alias */ + { 404, -2 }, /* (423) alias_opt ::= AS table_alias */ + { 405, -3 }, /* (424) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ + { 405, -3 }, /* (425) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ + { 403, -6 }, /* (426) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ + { 406, 0 }, /* (427) join_type ::= */ + { 406, -1 }, /* (428) join_type ::= INNER */ + { 408, -12 }, /* (429) query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ + { 409, 0 }, /* (430) set_quantifier_opt ::= */ + { 409, -1 }, /* (431) set_quantifier_opt ::= DISTINCT */ + { 409, -1 }, /* (432) set_quantifier_opt ::= ALL */ + { 410, -1 }, /* (433) select_list ::= select_item */ + { 410, -3 }, /* (434) select_list ::= select_list NK_COMMA select_item */ + { 418, -1 }, /* (435) select_item ::= NK_STAR */ + { 418, -1 }, /* (436) select_item ::= common_expression */ + { 418, -2 }, /* (437) select_item ::= common_expression column_alias */ + { 418, -3 }, /* (438) select_item ::= common_expression AS column_alias */ + { 418, -3 }, /* (439) select_item ::= table_name NK_DOT NK_STAR */ + { 376, 0 }, /* (440) where_clause_opt ::= */ + { 376, -2 }, /* (441) where_clause_opt ::= WHERE search_condition */ + { 411, 0 }, /* (442) partition_by_clause_opt ::= */ + { 411, -3 }, /* (443) partition_by_clause_opt ::= PARTITION BY expression_list */ + { 415, 0 }, /* (444) twindow_clause_opt ::= */ + { 415, -6 }, /* (445) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ + { 415, -4 }, /* (446) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */ + { 415, -6 }, /* (447) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ + { 415, -8 }, /* (448) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ + { 363, 0 }, /* (449) sliding_opt ::= */ + { 363, -4 }, /* (450) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ + { 414, 0 }, /* (451) fill_opt ::= */ + { 414, -4 }, /* (452) fill_opt ::= FILL NK_LP fill_mode NK_RP */ + { 414, -6 }, /* (453) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ + { 419, -1 }, /* (454) fill_mode ::= NONE */ + { 419, -1 }, /* (455) fill_mode ::= PREV */ + { 419, -1 }, /* (456) fill_mode ::= NULL */ + { 419, -1 }, /* (457) fill_mode ::= LINEAR */ + { 419, -1 }, /* (458) fill_mode ::= NEXT */ + { 416, 0 }, /* (459) group_by_clause_opt ::= */ + { 416, -3 }, /* (460) group_by_clause_opt ::= GROUP BY group_by_list */ + { 420, -1 }, /* (461) group_by_list ::= expression */ + { 420, -3 }, /* (462) group_by_list ::= group_by_list NK_COMMA expression */ + { 417, 0 }, /* (463) having_clause_opt ::= */ + { 417, -2 }, /* (464) having_clause_opt ::= HAVING search_condition */ + { 412, 0 }, /* (465) range_opt ::= */ + { 412, -6 }, /* (466) range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP */ + { 413, 0 }, /* (467) every_opt ::= */ + { 413, -4 }, /* (468) every_opt ::= EVERY NK_LP duration_literal NK_RP */ + { 368, -4 }, /* (469) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ + { 421, -1 }, /* (470) query_expression_body ::= query_primary */ + { 421, -4 }, /* (471) query_expression_body ::= query_expression_body UNION ALL query_expression_body */ + { 421, -3 }, /* (472) query_expression_body ::= query_expression_body UNION query_expression_body */ + { 425, -1 }, /* (473) query_primary ::= query_specification */ + { 425, -6 }, /* (474) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */ + { 422, 0 }, /* (475) order_by_clause_opt ::= */ + { 422, -3 }, /* (476) order_by_clause_opt ::= ORDER BY sort_specification_list */ + { 423, 0 }, /* (477) slimit_clause_opt ::= */ + { 423, -2 }, /* (478) slimit_clause_opt ::= SLIMIT NK_INTEGER */ + { 423, -4 }, /* (479) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + { 423, -4 }, /* (480) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + { 424, 0 }, /* (481) limit_clause_opt ::= */ + { 424, -2 }, /* (482) limit_clause_opt ::= LIMIT NK_INTEGER */ + { 424, -4 }, /* (483) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ + { 424, -4 }, /* (484) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + { 386, -3 }, /* (485) subquery ::= NK_LP query_expression NK_RP */ + { 407, -1 }, /* (486) search_condition ::= common_expression */ + { 426, -1 }, /* (487) sort_specification_list ::= sort_specification */ + { 426, -3 }, /* (488) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ + { 427, -3 }, /* (489) sort_specification ::= expression ordering_specification_opt null_ordering_opt */ + { 428, 0 }, /* (490) ordering_specification_opt ::= */ + { 428, -1 }, /* (491) ordering_specification_opt ::= ASC */ + { 428, -1 }, /* (492) ordering_specification_opt ::= DESC */ + { 429, 0 }, /* (493) null_ordering_opt ::= */ + { 429, -2 }, /* (494) null_ordering_opt ::= NULLS FIRST */ + { 429, -2 }, /* (495) null_ordering_opt ::= NULLS LAST */ }; static void yy_accept(yyParser*); /* Forward Declaration */ @@ -3415,11 +3429,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,309,&yymsp[0].minor); + yy_destructor(yypParser,310,&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,310,&yymsp[0].minor); + yy_destructor(yypParser,311,&yymsp[0].minor); break; case 2: /* account_options ::= */ { } @@ -3433,20 +3447,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,309,&yymsp[-2].minor); +{ yy_destructor(yypParser,310,&yymsp[-2].minor); { } - yy_destructor(yypParser,311,&yymsp[0].minor); + yy_destructor(yypParser,312,&yymsp[0].minor); } break; case 12: /* alter_account_options ::= alter_account_option */ -{ yy_destructor(yypParser,312,&yymsp[0].minor); +{ yy_destructor(yypParser,313,&yymsp[0].minor); { } } break; case 13: /* alter_account_options ::= alter_account_options alter_account_option */ -{ yy_destructor(yypParser,310,&yymsp[-1].minor); +{ yy_destructor(yypParser,311,&yymsp[-1].minor); { } - yy_destructor(yypParser,312,&yymsp[0].minor); + yy_destructor(yypParser,313,&yymsp[0].minor); } break; case 14: /* alter_account_option ::= PASS literal */ @@ -3460,72 +3474,72 @@ 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,311,&yymsp[0].minor); + yy_destructor(yypParser,312,&yymsp[0].minor); break; case 24: /* cmd ::= CREATE USER user_name PASS NK_STRING sysinfo_opt */ -{ pCxt->pRootNode = createCreateUserStmt(pCxt, &yymsp[-3].minor.yy239, &yymsp[-1].minor.yy0, yymsp[0].minor.yy509); } +{ pCxt->pRootNode = createCreateUserStmt(pCxt, &yymsp[-3].minor.yy149, &yymsp[-1].minor.yy0, yymsp[0].minor.yy363); } break; case 25: /* cmd ::= ALTER USER user_name PASS NK_STRING */ -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy239, TSDB_ALTER_USER_PASSWD, &yymsp[0].minor.yy0); } +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy149, TSDB_ALTER_USER_PASSWD, &yymsp[0].minor.yy0); } break; case 26: /* cmd ::= ALTER USER user_name ENABLE NK_INTEGER */ -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy239, TSDB_ALTER_USER_ENABLE, &yymsp[0].minor.yy0); } +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy149, TSDB_ALTER_USER_ENABLE, &yymsp[0].minor.yy0); } break; case 27: /* cmd ::= ALTER USER user_name SYSINFO NK_INTEGER */ -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy239, TSDB_ALTER_USER_SYSINFO, &yymsp[0].minor.yy0); } +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy149, TSDB_ALTER_USER_SYSINFO, &yymsp[0].minor.yy0); } break; case 28: /* cmd ::= DROP USER user_name */ -{ pCxt->pRootNode = createDropUserStmt(pCxt, &yymsp[0].minor.yy239); } +{ pCxt->pRootNode = createDropUserStmt(pCxt, &yymsp[0].minor.yy149); } break; case 29: /* sysinfo_opt ::= */ -{ yymsp[1].minor.yy509 = 1; } +{ yymsp[1].minor.yy363 = 1; } break; case 30: /* sysinfo_opt ::= SYSINFO NK_INTEGER */ -{ yymsp[-1].minor.yy509 = taosStr2Int8(yymsp[0].minor.yy0.z, NULL, 10); } +{ yymsp[-1].minor.yy363 = taosStr2Int8(yymsp[0].minor.yy0.z, NULL, 10); } break; case 31: /* cmd ::= GRANT privileges ON priv_level TO user_name */ -{ pCxt->pRootNode = createGrantStmt(pCxt, yymsp[-4].minor.yy129, &yymsp[-2].minor.yy239, &yymsp[0].minor.yy239); } +{ pCxt->pRootNode = createGrantStmt(pCxt, yymsp[-4].minor.yy49, &yymsp[-2].minor.yy149, &yymsp[0].minor.yy149); } break; case 32: /* cmd ::= REVOKE privileges ON priv_level FROM user_name */ -{ pCxt->pRootNode = createRevokeStmt(pCxt, yymsp[-4].minor.yy129, &yymsp[-2].minor.yy239, &yymsp[0].minor.yy239); } +{ pCxt->pRootNode = createRevokeStmt(pCxt, yymsp[-4].minor.yy49, &yymsp[-2].minor.yy149, &yymsp[0].minor.yy149); } break; case 33: /* privileges ::= ALL */ -{ yymsp[0].minor.yy129 = PRIVILEGE_TYPE_ALL; } +{ yymsp[0].minor.yy49 = PRIVILEGE_TYPE_ALL; } break; case 34: /* privileges ::= priv_type_list */ case 35: /* priv_type_list ::= priv_type */ yytestcase(yyruleno==35); -{ yylhsminor.yy129 = yymsp[0].minor.yy129; } - yymsp[0].minor.yy129 = yylhsminor.yy129; +{ yylhsminor.yy49 = yymsp[0].minor.yy49; } + yymsp[0].minor.yy49 = yylhsminor.yy49; break; case 36: /* priv_type_list ::= priv_type_list NK_COMMA priv_type */ -{ yylhsminor.yy129 = yymsp[-2].minor.yy129 | yymsp[0].minor.yy129; } - yymsp[-2].minor.yy129 = yylhsminor.yy129; +{ yylhsminor.yy49 = yymsp[-2].minor.yy49 | yymsp[0].minor.yy49; } + yymsp[-2].minor.yy49 = yylhsminor.yy49; break; case 37: /* priv_type ::= READ */ -{ yymsp[0].minor.yy129 = PRIVILEGE_TYPE_READ; } +{ yymsp[0].minor.yy49 = PRIVILEGE_TYPE_READ; } break; case 38: /* priv_type ::= WRITE */ -{ yymsp[0].minor.yy129 = PRIVILEGE_TYPE_WRITE; } +{ yymsp[0].minor.yy49 = PRIVILEGE_TYPE_WRITE; } break; case 39: /* priv_level ::= NK_STAR NK_DOT NK_STAR */ -{ yylhsminor.yy239 = yymsp[-2].minor.yy0; } - yymsp[-2].minor.yy239 = yylhsminor.yy239; +{ yylhsminor.yy149 = yymsp[-2].minor.yy0; } + yymsp[-2].minor.yy149 = yylhsminor.yy149; break; case 40: /* priv_level ::= db_name NK_DOT NK_STAR */ -{ yylhsminor.yy239 = yymsp[-2].minor.yy239; } - yymsp[-2].minor.yy239 = yylhsminor.yy239; +{ yylhsminor.yy149 = yymsp[-2].minor.yy149; } + yymsp[-2].minor.yy149 = yylhsminor.yy149; break; case 41: /* cmd ::= CREATE DNODE dnode_endpoint */ -{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[0].minor.yy239, NULL); } +{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[0].minor.yy149, NULL); } break; case 42: /* cmd ::= CREATE DNODE dnode_endpoint PORT NK_INTEGER */ -{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[-2].minor.yy239, &yymsp[0].minor.yy0); } +{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[-2].minor.yy149, &yymsp[0].minor.yy0); } break; case 43: /* cmd ::= DROP DNODE NK_INTEGER */ { pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[0].minor.yy0); } break; case 44: /* cmd ::= DROP DNODE dnode_endpoint */ -{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[0].minor.yy239); } +{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[0].minor.yy149); } break; case 45: /* cmd ::= ALTER DNODE NK_INTEGER NK_STRING */ { pCxt->pRootNode = createAlterDnodeStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, NULL); } @@ -3542,31 +3556,31 @@ static YYACTIONTYPE yy_reduce( case 49: /* dnode_endpoint ::= NK_STRING */ case 50: /* dnode_endpoint ::= NK_ID */ yytestcase(yyruleno==50); case 51: /* dnode_endpoint ::= NK_IPTOKEN */ yytestcase(yyruleno==51); - case 318: /* db_name ::= NK_ID */ yytestcase(yyruleno==318); - case 319: /* table_name ::= NK_ID */ yytestcase(yyruleno==319); - case 320: /* column_name ::= NK_ID */ yytestcase(yyruleno==320); - case 321: /* function_name ::= NK_ID */ yytestcase(yyruleno==321); - case 322: /* table_alias ::= NK_ID */ yytestcase(yyruleno==322); - case 323: /* column_alias ::= NK_ID */ yytestcase(yyruleno==323); - case 324: /* user_name ::= NK_ID */ yytestcase(yyruleno==324); - case 325: /* topic_name ::= NK_ID */ yytestcase(yyruleno==325); - case 326: /* stream_name ::= NK_ID */ yytestcase(yyruleno==326); - case 327: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==327); - case 363: /* noarg_func ::= NOW */ yytestcase(yyruleno==363); - case 364: /* noarg_func ::= TODAY */ yytestcase(yyruleno==364); - case 365: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==365); - case 366: /* noarg_func ::= DATABASE */ yytestcase(yyruleno==366); - case 367: /* noarg_func ::= CLIENT_VERSION */ yytestcase(yyruleno==367); - case 368: /* noarg_func ::= SERVER_VERSION */ yytestcase(yyruleno==368); - case 369: /* noarg_func ::= SERVER_STATUS */ yytestcase(yyruleno==369); - case 370: /* noarg_func ::= CURRENT_USER */ yytestcase(yyruleno==370); - case 371: /* noarg_func ::= USER */ yytestcase(yyruleno==371); - case 372: /* star_func ::= COUNT */ yytestcase(yyruleno==372); - case 373: /* star_func ::= FIRST */ yytestcase(yyruleno==373); - case 374: /* star_func ::= LAST */ yytestcase(yyruleno==374); - case 375: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==375); -{ yylhsminor.yy239 = yymsp[0].minor.yy0; } - yymsp[0].minor.yy239 = yylhsminor.yy239; + case 319: /* db_name ::= NK_ID */ yytestcase(yyruleno==319); + case 320: /* table_name ::= NK_ID */ yytestcase(yyruleno==320); + case 321: /* column_name ::= NK_ID */ yytestcase(yyruleno==321); + case 322: /* function_name ::= NK_ID */ yytestcase(yyruleno==322); + case 323: /* table_alias ::= NK_ID */ yytestcase(yyruleno==323); + case 324: /* column_alias ::= NK_ID */ yytestcase(yyruleno==324); + case 325: /* user_name ::= NK_ID */ yytestcase(yyruleno==325); + case 326: /* topic_name ::= NK_ID */ yytestcase(yyruleno==326); + case 327: /* stream_name ::= NK_ID */ yytestcase(yyruleno==327); + case 328: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==328); + case 364: /* noarg_func ::= NOW */ yytestcase(yyruleno==364); + case 365: /* noarg_func ::= TODAY */ yytestcase(yyruleno==365); + case 366: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==366); + case 367: /* noarg_func ::= DATABASE */ yytestcase(yyruleno==367); + case 368: /* noarg_func ::= CLIENT_VERSION */ yytestcase(yyruleno==368); + case 369: /* noarg_func ::= SERVER_VERSION */ yytestcase(yyruleno==369); + case 370: /* noarg_func ::= SERVER_STATUS */ yytestcase(yyruleno==370); + case 371: /* noarg_func ::= CURRENT_USER */ yytestcase(yyruleno==371); + case 372: /* noarg_func ::= USER */ yytestcase(yyruleno==372); + case 373: /* star_func ::= COUNT */ yytestcase(yyruleno==373); + case 374: /* star_func ::= FIRST */ yytestcase(yyruleno==374); + case 375: /* star_func ::= LAST */ yytestcase(yyruleno==375); + case 376: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==376); +{ yylhsminor.yy149 = yymsp[0].minor.yy0; } + yymsp[0].minor.yy149 = yylhsminor.yy149; break; case 52: /* cmd ::= ALTER LOCAL NK_STRING */ { pCxt->pRootNode = createAlterLocalStmt(pCxt, &yymsp[0].minor.yy0, NULL); } @@ -3599,1282 +3613,1286 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createDropComponentNodeStmt(pCxt, QUERY_NODE_DROP_MNODE_STMT, &yymsp[0].minor.yy0); } break; case 62: /* cmd ::= CREATE DATABASE not_exists_opt db_name db_options */ -{ pCxt->pRootNode = createCreateDatabaseStmt(pCxt, yymsp[-2].minor.yy845, &yymsp[-1].minor.yy239, yymsp[0].minor.yy80); } +{ pCxt->pRootNode = createCreateDatabaseStmt(pCxt, yymsp[-2].minor.yy497, &yymsp[-1].minor.yy149, yymsp[0].minor.yy312); } break; case 63: /* cmd ::= DROP DATABASE exists_opt db_name */ -{ pCxt->pRootNode = createDropDatabaseStmt(pCxt, yymsp[-1].minor.yy845, &yymsp[0].minor.yy239); } +{ pCxt->pRootNode = createDropDatabaseStmt(pCxt, yymsp[-1].minor.yy497, &yymsp[0].minor.yy149); } break; case 64: /* cmd ::= USE db_name */ -{ pCxt->pRootNode = createUseDatabaseStmt(pCxt, &yymsp[0].minor.yy239); } +{ pCxt->pRootNode = createUseDatabaseStmt(pCxt, &yymsp[0].minor.yy149); } break; case 65: /* cmd ::= ALTER DATABASE db_name alter_db_options */ -{ pCxt->pRootNode = createAlterDatabaseStmt(pCxt, &yymsp[-1].minor.yy239, yymsp[0].minor.yy80); } +{ pCxt->pRootNode = createAlterDatabaseStmt(pCxt, &yymsp[-1].minor.yy149, yymsp[0].minor.yy312); } break; case 66: /* cmd ::= FLUSH DATABASE db_name */ -{ pCxt->pRootNode = createFlushDatabaseStmt(pCxt, &yymsp[0].minor.yy239); } +{ pCxt->pRootNode = createFlushDatabaseStmt(pCxt, &yymsp[0].minor.yy149); } break; case 67: /* cmd ::= TRIM DATABASE db_name */ -{ pCxt->pRootNode = createTrimDatabaseStmt(pCxt, &yymsp[0].minor.yy239); } +{ pCxt->pRootNode = createTrimDatabaseStmt(pCxt, &yymsp[0].minor.yy149); } break; case 68: /* not_exists_opt ::= IF NOT EXISTS */ -{ yymsp[-2].minor.yy845 = true; } +{ yymsp[-2].minor.yy497 = true; } break; case 69: /* not_exists_opt ::= */ case 71: /* exists_opt ::= */ yytestcase(yyruleno==71); - case 261: /* analyze_opt ::= */ yytestcase(yyruleno==261); - case 268: /* agg_func_opt ::= */ yytestcase(yyruleno==268); - case 429: /* set_quantifier_opt ::= */ yytestcase(yyruleno==429); -{ yymsp[1].minor.yy845 = false; } + case 262: /* analyze_opt ::= */ yytestcase(yyruleno==262); + case 269: /* agg_func_opt ::= */ yytestcase(yyruleno==269); + case 430: /* set_quantifier_opt ::= */ yytestcase(yyruleno==430); +{ yymsp[1].minor.yy497 = false; } break; case 70: /* exists_opt ::= IF EXISTS */ -{ yymsp[-1].minor.yy845 = true; } +{ yymsp[-1].minor.yy497 = true; } break; case 72: /* db_options ::= */ -{ yymsp[1].minor.yy80 = createDefaultDatabaseOptions(pCxt); } +{ yymsp[1].minor.yy312 = createDefaultDatabaseOptions(pCxt); } break; case 73: /* db_options ::= db_options BUFFER NK_INTEGER */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_BUFFER, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_BUFFER, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; case 74: /* db_options ::= db_options CACHEMODEL NK_STRING */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_CACHEMODEL, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_CACHEMODEL, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; case 75: /* db_options ::= db_options CACHESIZE NK_INTEGER */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_CACHESIZE, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_CACHESIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; case 76: /* db_options ::= db_options COMP NK_INTEGER */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_COMP, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_COMP, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; case 77: /* db_options ::= db_options DURATION NK_INTEGER */ case 78: /* db_options ::= db_options DURATION NK_VARIABLE */ yytestcase(yyruleno==78); -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_DAYS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_DAYS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; case 79: /* db_options ::= db_options MAXROWS NK_INTEGER */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_MAXROWS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_MAXROWS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; case 80: /* db_options ::= db_options MINROWS NK_INTEGER */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_MINROWS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_MINROWS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; case 81: /* db_options ::= db_options KEEP integer_list */ case 82: /* db_options ::= db_options KEEP variable_list */ yytestcase(yyruleno==82); -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_KEEP, yymsp[0].minor.yy574); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_KEEP, yymsp[0].minor.yy824); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; case 83: /* db_options ::= db_options PAGES NK_INTEGER */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_PAGES, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_PAGES, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; case 84: /* db_options ::= db_options PAGESIZE NK_INTEGER */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_PAGESIZE, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_PAGESIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 85: /* db_options ::= db_options PRECISION NK_STRING */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_PRECISION, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 85: /* db_options ::= db_options TSDB_PAGESIZE NK_INTEGER */ +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_TSDB_PAGESIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 86: /* db_options ::= db_options REPLICA NK_INTEGER */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_REPLICA, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 86: /* db_options ::= db_options PRECISION NK_STRING */ +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_PRECISION, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 87: /* db_options ::= db_options STRICT NK_STRING */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_STRICT, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 87: /* db_options ::= db_options REPLICA NK_INTEGER */ +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_REPLICA, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 88: /* db_options ::= db_options VGROUPS NK_INTEGER */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_VGROUPS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 88: /* db_options ::= db_options STRICT NK_STRING */ +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_STRICT, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 89: /* db_options ::= db_options SINGLE_STABLE NK_INTEGER */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_SINGLE_STABLE, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 89: /* db_options ::= db_options VGROUPS NK_INTEGER */ +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_VGROUPS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 90: /* db_options ::= db_options RETENTIONS retention_list */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_RETENTIONS, yymsp[0].minor.yy574); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 90: /* db_options ::= db_options SINGLE_STABLE NK_INTEGER */ +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_SINGLE_STABLE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 91: /* db_options ::= db_options SCHEMALESS NK_INTEGER */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_SCHEMALESS, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 91: /* db_options ::= db_options RETENTIONS retention_list */ +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_RETENTIONS, yymsp[0].minor.yy824); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 92: /* db_options ::= db_options WAL_LEVEL NK_INTEGER */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_WAL, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 92: /* db_options ::= db_options SCHEMALESS NK_INTEGER */ +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_SCHEMALESS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 93: /* db_options ::= db_options WAL_FSYNC_PERIOD NK_INTEGER */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_FSYNC, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 93: /* db_options ::= db_options WAL_LEVEL NK_INTEGER */ +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_WAL, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 94: /* db_options ::= db_options WAL_RETENTION_PERIOD NK_INTEGER */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_WAL_RETENTION_PERIOD, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 94: /* db_options ::= db_options WAL_FSYNC_PERIOD NK_INTEGER */ +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_FSYNC, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 95: /* db_options ::= db_options WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ + case 95: /* db_options ::= db_options WAL_RETENTION_PERIOD NK_INTEGER */ +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_WAL_RETENTION_PERIOD, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; + break; + case 96: /* db_options ::= db_options WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-3].minor.yy80, DB_OPTION_WAL_RETENTION_PERIOD, &t); + yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-3].minor.yy312, DB_OPTION_WAL_RETENTION_PERIOD, &t); } - yymsp[-3].minor.yy80 = yylhsminor.yy80; + yymsp[-3].minor.yy312 = yylhsminor.yy312; break; - case 96: /* db_options ::= db_options WAL_RETENTION_SIZE NK_INTEGER */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_WAL_RETENTION_SIZE, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 97: /* db_options ::= db_options WAL_RETENTION_SIZE NK_INTEGER */ +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_WAL_RETENTION_SIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 97: /* db_options ::= db_options WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ + case 98: /* db_options ::= db_options WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-3].minor.yy80, DB_OPTION_WAL_RETENTION_SIZE, &t); + yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-3].minor.yy312, DB_OPTION_WAL_RETENTION_SIZE, &t); } - yymsp[-3].minor.yy80 = yylhsminor.yy80; - break; - case 98: /* db_options ::= db_options WAL_ROLL_PERIOD NK_INTEGER */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_WAL_ROLL_PERIOD, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; - break; - case 99: /* db_options ::= db_options WAL_SEGMENT_SIZE NK_INTEGER */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_WAL_SEGMENT_SIZE, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; - break; - case 100: /* db_options ::= db_options SST_TRIGGER NK_INTEGER */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_SST_TRIGGER, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; - break; - case 101: /* db_options ::= db_options TABLE_PREFIX NK_INTEGER */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_TABLE_PREFIX, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; - break; - case 102: /* db_options ::= db_options TABLE_SUFFIX NK_INTEGER */ -{ yylhsminor.yy80 = setDatabaseOption(pCxt, yymsp[-2].minor.yy80, DB_OPTION_TABLE_SUFFIX, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; - break; - case 103: /* alter_db_options ::= alter_db_option */ -{ yylhsminor.yy80 = createAlterDatabaseOptions(pCxt); yylhsminor.yy80 = setAlterDatabaseOption(pCxt, yylhsminor.yy80, &yymsp[0].minor.yy299); } - yymsp[0].minor.yy80 = yylhsminor.yy80; - break; - case 104: /* alter_db_options ::= alter_db_options alter_db_option */ -{ yylhsminor.yy80 = setAlterDatabaseOption(pCxt, yymsp[-1].minor.yy80, &yymsp[0].minor.yy299); } - yymsp[-1].minor.yy80 = yylhsminor.yy80; - break; - case 105: /* alter_db_option ::= CACHEMODEL NK_STRING */ -{ yymsp[-1].minor.yy299.type = DB_OPTION_CACHEMODEL; yymsp[-1].minor.yy299.val = yymsp[0].minor.yy0; } - break; - case 106: /* alter_db_option ::= CACHESIZE NK_INTEGER */ -{ yymsp[-1].minor.yy299.type = DB_OPTION_CACHESIZE; yymsp[-1].minor.yy299.val = yymsp[0].minor.yy0; } - break; - case 107: /* alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */ -{ yymsp[-1].minor.yy299.type = DB_OPTION_FSYNC; yymsp[-1].minor.yy299.val = yymsp[0].minor.yy0; } - break; - case 108: /* alter_db_option ::= KEEP integer_list */ - case 109: /* alter_db_option ::= KEEP variable_list */ yytestcase(yyruleno==109); -{ yymsp[-1].minor.yy299.type = DB_OPTION_KEEP; yymsp[-1].minor.yy299.pList = yymsp[0].minor.yy574; } - break; - case 110: /* alter_db_option ::= WAL_LEVEL NK_INTEGER */ -{ yymsp[-1].minor.yy299.type = DB_OPTION_WAL; yymsp[-1].minor.yy299.val = yymsp[0].minor.yy0; } - break; - case 111: /* alter_db_option ::= SST_TRIGGER NK_INTEGER */ -{ yymsp[-1].minor.yy299.type = DB_OPTION_SST_TRIGGER; yymsp[-1].minor.yy299.val = yymsp[0].minor.yy0; } - break; - case 112: /* integer_list ::= NK_INTEGER */ -{ yylhsminor.yy574 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy574 = yylhsminor.yy574; - break; - case 113: /* integer_list ::= integer_list NK_COMMA NK_INTEGER */ - case 288: /* dnode_list ::= dnode_list DNODE NK_INTEGER */ yytestcase(yyruleno==288); -{ yylhsminor.yy574 = addNodeToList(pCxt, yymsp[-2].minor.yy574, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } - yymsp[-2].minor.yy574 = yylhsminor.yy574; - break; - case 114: /* variable_list ::= NK_VARIABLE */ -{ yylhsminor.yy574 = createNodeList(pCxt, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy574 = yylhsminor.yy574; - break; - case 115: /* variable_list ::= variable_list NK_COMMA NK_VARIABLE */ -{ yylhsminor.yy574 = addNodeToList(pCxt, yymsp[-2].minor.yy574, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[-2].minor.yy574 = yylhsminor.yy574; - break; - case 116: /* retention_list ::= retention */ - case 136: /* multi_create_clause ::= create_subtable_clause */ yytestcase(yyruleno==136); - case 139: /* multi_drop_clause ::= drop_table_clause */ yytestcase(yyruleno==139); - case 146: /* column_def_list ::= column_def */ yytestcase(yyruleno==146); - case 189: /* rollup_func_list ::= rollup_func_name */ yytestcase(yyruleno==189); - case 194: /* col_name_list ::= col_name */ yytestcase(yyruleno==194); - case 244: /* func_list ::= func */ yytestcase(yyruleno==244); - case 316: /* literal_list ::= signed_literal */ yytestcase(yyruleno==316); - case 378: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==378); - case 432: /* select_list ::= select_item */ yytestcase(yyruleno==432); - case 486: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==486); -{ yylhsminor.yy574 = createNodeList(pCxt, yymsp[0].minor.yy80); } - yymsp[0].minor.yy574 = yylhsminor.yy574; - break; - case 117: /* retention_list ::= retention_list NK_COMMA retention */ - case 147: /* column_def_list ::= column_def_list NK_COMMA column_def */ yytestcase(yyruleno==147); - case 190: /* rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ yytestcase(yyruleno==190); - case 195: /* col_name_list ::= col_name_list NK_COMMA col_name */ yytestcase(yyruleno==195); - case 245: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==245); - case 317: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==317); - case 379: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==379); - case 433: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==433); - case 487: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==487); -{ yylhsminor.yy574 = addNodeToList(pCxt, yymsp[-2].minor.yy574, yymsp[0].minor.yy80); } - yymsp[-2].minor.yy574 = yylhsminor.yy574; - break; - case 118: /* retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ -{ yylhsminor.yy80 = createNodeListNodeEx(pCxt, createDurationValueNode(pCxt, &yymsp[-2].minor.yy0), createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; - break; - case 119: /* cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ - case 121: /* cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ yytestcase(yyruleno==121); -{ pCxt->pRootNode = createCreateTableStmt(pCxt, yymsp[-6].minor.yy845, yymsp[-5].minor.yy80, yymsp[-3].minor.yy574, yymsp[-1].minor.yy574, yymsp[0].minor.yy80); } - break; - case 120: /* cmd ::= CREATE TABLE multi_create_clause */ -{ pCxt->pRootNode = createCreateMultiTableStmt(pCxt, yymsp[0].minor.yy574); } - break; - case 122: /* cmd ::= DROP TABLE multi_drop_clause */ -{ pCxt->pRootNode = createDropTableStmt(pCxt, yymsp[0].minor.yy574); } - break; - case 123: /* cmd ::= DROP STABLE exists_opt full_table_name */ -{ pCxt->pRootNode = createDropSuperTableStmt(pCxt, yymsp[-1].minor.yy845, yymsp[0].minor.yy80); } - break; - case 124: /* cmd ::= ALTER TABLE alter_table_clause */ - case 290: /* cmd ::= query_expression */ yytestcase(yyruleno==290); -{ pCxt->pRootNode = yymsp[0].minor.yy80; } - break; - case 125: /* cmd ::= ALTER STABLE alter_table_clause */ -{ pCxt->pRootNode = setAlterSuperTableType(yymsp[0].minor.yy80); } - break; - case 126: /* alter_table_clause ::= full_table_name alter_table_options */ -{ yylhsminor.yy80 = createAlterTableModifyOptions(pCxt, yymsp[-1].minor.yy80, yymsp[0].minor.yy80); } - yymsp[-1].minor.yy80 = yylhsminor.yy80; - break; - case 127: /* alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ -{ yylhsminor.yy80 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy80, TSDB_ALTER_TABLE_ADD_COLUMN, &yymsp[-1].minor.yy239, yymsp[0].minor.yy136); } - yymsp[-4].minor.yy80 = yylhsminor.yy80; - break; - case 128: /* alter_table_clause ::= full_table_name DROP COLUMN column_name */ -{ yylhsminor.yy80 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy80, TSDB_ALTER_TABLE_DROP_COLUMN, &yymsp[0].minor.yy239); } - yymsp[-3].minor.yy80 = yylhsminor.yy80; - break; - case 129: /* alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ -{ yylhsminor.yy80 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy80, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, &yymsp[-1].minor.yy239, yymsp[0].minor.yy136); } - yymsp[-4].minor.yy80 = yylhsminor.yy80; + yymsp[-3].minor.yy312 = yylhsminor.yy312; + break; + case 99: /* db_options ::= db_options WAL_ROLL_PERIOD NK_INTEGER */ +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_WAL_ROLL_PERIOD, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; + break; + case 100: /* db_options ::= db_options WAL_SEGMENT_SIZE NK_INTEGER */ +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_WAL_SEGMENT_SIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; + break; + case 101: /* db_options ::= db_options STT_TRIGGER NK_INTEGER */ +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_STT_TRIGGER, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; + break; + case 102: /* db_options ::= db_options TABLE_PREFIX NK_INTEGER */ +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_TABLE_PREFIX, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; + break; + case 103: /* db_options ::= db_options TABLE_SUFFIX NK_INTEGER */ +{ yylhsminor.yy312 = setDatabaseOption(pCxt, yymsp[-2].minor.yy312, DB_OPTION_TABLE_SUFFIX, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; + break; + case 104: /* alter_db_options ::= alter_db_option */ +{ yylhsminor.yy312 = createAlterDatabaseOptions(pCxt); yylhsminor.yy312 = setAlterDatabaseOption(pCxt, yylhsminor.yy312, &yymsp[0].minor.yy405); } + yymsp[0].minor.yy312 = yylhsminor.yy312; + break; + case 105: /* alter_db_options ::= alter_db_options alter_db_option */ +{ yylhsminor.yy312 = setAlterDatabaseOption(pCxt, yymsp[-1].minor.yy312, &yymsp[0].minor.yy405); } + yymsp[-1].minor.yy312 = yylhsminor.yy312; + break; + case 106: /* alter_db_option ::= CACHEMODEL NK_STRING */ +{ yymsp[-1].minor.yy405.type = DB_OPTION_CACHEMODEL; yymsp[-1].minor.yy405.val = yymsp[0].minor.yy0; } + break; + case 107: /* alter_db_option ::= CACHESIZE NK_INTEGER */ +{ yymsp[-1].minor.yy405.type = DB_OPTION_CACHESIZE; yymsp[-1].minor.yy405.val = yymsp[0].minor.yy0; } + break; + case 108: /* alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */ +{ yymsp[-1].minor.yy405.type = DB_OPTION_FSYNC; yymsp[-1].minor.yy405.val = yymsp[0].minor.yy0; } + break; + case 109: /* alter_db_option ::= KEEP integer_list */ + case 110: /* alter_db_option ::= KEEP variable_list */ yytestcase(yyruleno==110); +{ yymsp[-1].minor.yy405.type = DB_OPTION_KEEP; yymsp[-1].minor.yy405.pList = yymsp[0].minor.yy824; } + break; + case 111: /* alter_db_option ::= WAL_LEVEL NK_INTEGER */ +{ yymsp[-1].minor.yy405.type = DB_OPTION_WAL; yymsp[-1].minor.yy405.val = yymsp[0].minor.yy0; } + break; + case 112: /* alter_db_option ::= STT_TRIGGER NK_INTEGER */ +{ yymsp[-1].minor.yy405.type = DB_OPTION_STT_TRIGGER; yymsp[-1].minor.yy405.val = yymsp[0].minor.yy0; } + break; + case 113: /* integer_list ::= NK_INTEGER */ +{ yylhsminor.yy824 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy824 = yylhsminor.yy824; + break; + case 114: /* integer_list ::= integer_list NK_COMMA NK_INTEGER */ + case 289: /* dnode_list ::= dnode_list DNODE NK_INTEGER */ yytestcase(yyruleno==289); +{ yylhsminor.yy824 = addNodeToList(pCxt, yymsp[-2].minor.yy824, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy824 = yylhsminor.yy824; + break; + case 115: /* variable_list ::= NK_VARIABLE */ +{ yylhsminor.yy824 = createNodeList(pCxt, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy824 = yylhsminor.yy824; + break; + case 116: /* variable_list ::= variable_list NK_COMMA NK_VARIABLE */ +{ yylhsminor.yy824 = addNodeToList(pCxt, yymsp[-2].minor.yy824, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy824 = yylhsminor.yy824; + break; + case 117: /* retention_list ::= retention */ + case 137: /* multi_create_clause ::= create_subtable_clause */ yytestcase(yyruleno==137); + case 140: /* multi_drop_clause ::= drop_table_clause */ yytestcase(yyruleno==140); + case 147: /* column_def_list ::= column_def */ yytestcase(yyruleno==147); + case 190: /* rollup_func_list ::= rollup_func_name */ yytestcase(yyruleno==190); + case 195: /* col_name_list ::= col_name */ yytestcase(yyruleno==195); + case 245: /* func_list ::= func */ yytestcase(yyruleno==245); + case 317: /* literal_list ::= signed_literal */ yytestcase(yyruleno==317); + case 379: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==379); + case 433: /* select_list ::= select_item */ yytestcase(yyruleno==433); + case 487: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==487); +{ yylhsminor.yy824 = createNodeList(pCxt, yymsp[0].minor.yy312); } + yymsp[0].minor.yy824 = yylhsminor.yy824; + break; + case 118: /* retention_list ::= retention_list NK_COMMA retention */ + case 148: /* column_def_list ::= column_def_list NK_COMMA column_def */ yytestcase(yyruleno==148); + case 191: /* rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ yytestcase(yyruleno==191); + case 196: /* col_name_list ::= col_name_list NK_COMMA col_name */ yytestcase(yyruleno==196); + case 246: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==246); + case 318: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==318); + case 380: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==380); + case 434: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==434); + case 488: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==488); +{ yylhsminor.yy824 = addNodeToList(pCxt, yymsp[-2].minor.yy824, yymsp[0].minor.yy312); } + yymsp[-2].minor.yy824 = yylhsminor.yy824; + break; + case 119: /* retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ +{ yylhsminor.yy312 = createNodeListNodeEx(pCxt, createDurationValueNode(pCxt, &yymsp[-2].minor.yy0), createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; + break; + case 120: /* cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ + case 122: /* cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ yytestcase(yyruleno==122); +{ pCxt->pRootNode = createCreateTableStmt(pCxt, yymsp[-6].minor.yy497, yymsp[-5].minor.yy312, yymsp[-3].minor.yy824, yymsp[-1].minor.yy824, yymsp[0].minor.yy312); } + break; + case 121: /* cmd ::= CREATE TABLE multi_create_clause */ +{ pCxt->pRootNode = createCreateMultiTableStmt(pCxt, yymsp[0].minor.yy824); } + break; + case 123: /* cmd ::= DROP TABLE multi_drop_clause */ +{ pCxt->pRootNode = createDropTableStmt(pCxt, yymsp[0].minor.yy824); } + break; + case 124: /* cmd ::= DROP STABLE exists_opt full_table_name */ +{ pCxt->pRootNode = createDropSuperTableStmt(pCxt, yymsp[-1].minor.yy497, yymsp[0].minor.yy312); } + break; + case 125: /* cmd ::= ALTER TABLE alter_table_clause */ + case 291: /* cmd ::= query_expression */ yytestcase(yyruleno==291); +{ pCxt->pRootNode = yymsp[0].minor.yy312; } + break; + case 126: /* cmd ::= ALTER STABLE alter_table_clause */ +{ pCxt->pRootNode = setAlterSuperTableType(yymsp[0].minor.yy312); } + break; + case 127: /* alter_table_clause ::= full_table_name alter_table_options */ +{ yylhsminor.yy312 = createAlterTableModifyOptions(pCxt, yymsp[-1].minor.yy312, yymsp[0].minor.yy312); } + yymsp[-1].minor.yy312 = yylhsminor.yy312; + break; + case 128: /* alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ +{ yylhsminor.yy312 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy312, TSDB_ALTER_TABLE_ADD_COLUMN, &yymsp[-1].minor.yy149, yymsp[0].minor.yy84); } + yymsp[-4].minor.yy312 = yylhsminor.yy312; + break; + case 129: /* alter_table_clause ::= full_table_name DROP COLUMN column_name */ +{ yylhsminor.yy312 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy312, TSDB_ALTER_TABLE_DROP_COLUMN, &yymsp[0].minor.yy149); } + yymsp[-3].minor.yy312 = yylhsminor.yy312; + break; + case 130: /* alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ +{ yylhsminor.yy312 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy312, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, &yymsp[-1].minor.yy149, yymsp[0].minor.yy84); } + yymsp[-4].minor.yy312 = yylhsminor.yy312; break; - case 130: /* alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ -{ yylhsminor.yy80 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy80, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &yymsp[-1].minor.yy239, &yymsp[0].minor.yy239); } - yymsp[-4].minor.yy80 = yylhsminor.yy80; + case 131: /* alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ +{ yylhsminor.yy312 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy312, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &yymsp[-1].minor.yy149, &yymsp[0].minor.yy149); } + yymsp[-4].minor.yy312 = yylhsminor.yy312; break; - case 131: /* alter_table_clause ::= full_table_name ADD TAG column_name type_name */ -{ yylhsminor.yy80 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy80, TSDB_ALTER_TABLE_ADD_TAG, &yymsp[-1].minor.yy239, yymsp[0].minor.yy136); } - yymsp[-4].minor.yy80 = yylhsminor.yy80; - break; - case 132: /* alter_table_clause ::= full_table_name DROP TAG column_name */ -{ yylhsminor.yy80 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy80, TSDB_ALTER_TABLE_DROP_TAG, &yymsp[0].minor.yy239); } - yymsp[-3].minor.yy80 = yylhsminor.yy80; + case 132: /* alter_table_clause ::= full_table_name ADD TAG column_name type_name */ +{ yylhsminor.yy312 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy312, TSDB_ALTER_TABLE_ADD_TAG, &yymsp[-1].minor.yy149, yymsp[0].minor.yy84); } + yymsp[-4].minor.yy312 = yylhsminor.yy312; + break; + case 133: /* alter_table_clause ::= full_table_name DROP TAG column_name */ +{ yylhsminor.yy312 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy312, TSDB_ALTER_TABLE_DROP_TAG, &yymsp[0].minor.yy149); } + yymsp[-3].minor.yy312 = yylhsminor.yy312; break; - case 133: /* alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ -{ yylhsminor.yy80 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy80, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &yymsp[-1].minor.yy239, yymsp[0].minor.yy136); } - yymsp[-4].minor.yy80 = yylhsminor.yy80; + case 134: /* alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ +{ yylhsminor.yy312 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy312, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &yymsp[-1].minor.yy149, yymsp[0].minor.yy84); } + yymsp[-4].minor.yy312 = yylhsminor.yy312; break; - case 134: /* alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ -{ yylhsminor.yy80 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy80, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &yymsp[-1].minor.yy239, &yymsp[0].minor.yy239); } - yymsp[-4].minor.yy80 = yylhsminor.yy80; + case 135: /* alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ +{ yylhsminor.yy312 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy312, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &yymsp[-1].minor.yy149, &yymsp[0].minor.yy149); } + yymsp[-4].minor.yy312 = yylhsminor.yy312; break; - case 135: /* alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ -{ yylhsminor.yy80 = createAlterTableSetTag(pCxt, yymsp[-5].minor.yy80, &yymsp[-2].minor.yy239, yymsp[0].minor.yy80); } - yymsp[-5].minor.yy80 = yylhsminor.yy80; + case 136: /* alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ +{ yylhsminor.yy312 = createAlterTableSetTag(pCxt, yymsp[-5].minor.yy312, &yymsp[-2].minor.yy149, yymsp[0].minor.yy312); } + yymsp[-5].minor.yy312 = yylhsminor.yy312; break; - case 137: /* multi_create_clause ::= multi_create_clause create_subtable_clause */ - case 140: /* multi_drop_clause ::= multi_drop_clause drop_table_clause */ yytestcase(yyruleno==140); -{ yylhsminor.yy574 = addNodeToList(pCxt, yymsp[-1].minor.yy574, yymsp[0].minor.yy80); } - yymsp[-1].minor.yy574 = yylhsminor.yy574; + case 138: /* multi_create_clause ::= multi_create_clause create_subtable_clause */ + case 141: /* multi_drop_clause ::= multi_drop_clause drop_table_clause */ yytestcase(yyruleno==141); +{ yylhsminor.yy824 = addNodeToList(pCxt, yymsp[-1].minor.yy824, yymsp[0].minor.yy312); } + yymsp[-1].minor.yy824 = yylhsminor.yy824; break; - case 138: /* create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP expression_list NK_RP table_options */ -{ yylhsminor.yy80 = createCreateSubTableClause(pCxt, yymsp[-9].minor.yy845, yymsp[-8].minor.yy80, yymsp[-6].minor.yy80, yymsp[-5].minor.yy574, yymsp[-2].minor.yy574, yymsp[0].minor.yy80); } - yymsp[-9].minor.yy80 = yylhsminor.yy80; + case 139: /* create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP expression_list NK_RP table_options */ +{ yylhsminor.yy312 = createCreateSubTableClause(pCxt, yymsp[-9].minor.yy497, yymsp[-8].minor.yy312, yymsp[-6].minor.yy312, yymsp[-5].minor.yy824, yymsp[-2].minor.yy824, yymsp[0].minor.yy312); } + yymsp[-9].minor.yy312 = yylhsminor.yy312; break; - case 141: /* drop_table_clause ::= exists_opt full_table_name */ -{ yylhsminor.yy80 = createDropTableClause(pCxt, yymsp[-1].minor.yy845, yymsp[0].minor.yy80); } - yymsp[-1].minor.yy80 = yylhsminor.yy80; + case 142: /* drop_table_clause ::= exists_opt full_table_name */ +{ yylhsminor.yy312 = createDropTableClause(pCxt, yymsp[-1].minor.yy497, yymsp[0].minor.yy312); } + yymsp[-1].minor.yy312 = yylhsminor.yy312; break; - case 142: /* specific_cols_opt ::= */ - case 173: /* tags_def_opt ::= */ yytestcase(yyruleno==173); - case 441: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==441); - case 458: /* group_by_clause_opt ::= */ yytestcase(yyruleno==458); - case 474: /* order_by_clause_opt ::= */ yytestcase(yyruleno==474); -{ yymsp[1].minor.yy574 = NULL; } + case 143: /* specific_cols_opt ::= */ + case 174: /* tags_def_opt ::= */ yytestcase(yyruleno==174); + case 442: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==442); + case 459: /* group_by_clause_opt ::= */ yytestcase(yyruleno==459); + case 475: /* order_by_clause_opt ::= */ yytestcase(yyruleno==475); +{ yymsp[1].minor.yy824 = NULL; } break; - case 143: /* specific_cols_opt ::= NK_LP col_name_list NK_RP */ -{ yymsp[-2].minor.yy574 = yymsp[-1].minor.yy574; } + case 144: /* specific_cols_opt ::= NK_LP col_name_list NK_RP */ +{ yymsp[-2].minor.yy824 = yymsp[-1].minor.yy824; } break; - case 144: /* full_table_name ::= table_name */ -{ yylhsminor.yy80 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy239, NULL); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 145: /* full_table_name ::= table_name */ +{ yylhsminor.yy312 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy149, NULL); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 145: /* full_table_name ::= db_name NK_DOT table_name */ -{ yylhsminor.yy80 = createRealTableNode(pCxt, &yymsp[-2].minor.yy239, &yymsp[0].minor.yy239, NULL); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 146: /* full_table_name ::= db_name NK_DOT table_name */ +{ yylhsminor.yy312 = createRealTableNode(pCxt, &yymsp[-2].minor.yy149, &yymsp[0].minor.yy149, NULL); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 148: /* column_def ::= column_name type_name */ -{ yylhsminor.yy80 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy239, yymsp[0].minor.yy136, NULL); } - yymsp[-1].minor.yy80 = yylhsminor.yy80; + case 149: /* column_def ::= column_name type_name */ +{ yylhsminor.yy312 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy149, yymsp[0].minor.yy84, NULL); } + yymsp[-1].minor.yy312 = yylhsminor.yy312; break; - case 149: /* column_def ::= column_name type_name COMMENT NK_STRING */ -{ yylhsminor.yy80 = createColumnDefNode(pCxt, &yymsp[-3].minor.yy239, yymsp[-2].minor.yy136, &yymsp[0].minor.yy0); } - yymsp[-3].minor.yy80 = yylhsminor.yy80; + case 150: /* column_def ::= column_name type_name COMMENT NK_STRING */ +{ yylhsminor.yy312 = createColumnDefNode(pCxt, &yymsp[-3].minor.yy149, yymsp[-2].minor.yy84, &yymsp[0].minor.yy0); } + yymsp[-3].minor.yy312 = yylhsminor.yy312; break; - case 150: /* type_name ::= BOOL */ -{ yymsp[0].minor.yy136 = createDataType(TSDB_DATA_TYPE_BOOL); } + case 151: /* type_name ::= BOOL */ +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_BOOL); } break; - case 151: /* type_name ::= TINYINT */ -{ yymsp[0].minor.yy136 = createDataType(TSDB_DATA_TYPE_TINYINT); } + case 152: /* type_name ::= TINYINT */ +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_TINYINT); } break; - case 152: /* type_name ::= SMALLINT */ -{ yymsp[0].minor.yy136 = createDataType(TSDB_DATA_TYPE_SMALLINT); } + case 153: /* type_name ::= SMALLINT */ +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_SMALLINT); } break; - case 153: /* type_name ::= INT */ - case 154: /* type_name ::= INTEGER */ yytestcase(yyruleno==154); -{ yymsp[0].minor.yy136 = createDataType(TSDB_DATA_TYPE_INT); } + case 154: /* type_name ::= INT */ + case 155: /* type_name ::= INTEGER */ yytestcase(yyruleno==155); +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_INT); } break; - case 155: /* type_name ::= BIGINT */ -{ yymsp[0].minor.yy136 = createDataType(TSDB_DATA_TYPE_BIGINT); } + case 156: /* type_name ::= BIGINT */ +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_BIGINT); } break; - case 156: /* type_name ::= FLOAT */ -{ yymsp[0].minor.yy136 = createDataType(TSDB_DATA_TYPE_FLOAT); } + case 157: /* type_name ::= FLOAT */ +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_FLOAT); } break; - case 157: /* type_name ::= DOUBLE */ -{ yymsp[0].minor.yy136 = createDataType(TSDB_DATA_TYPE_DOUBLE); } + case 158: /* type_name ::= DOUBLE */ +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_DOUBLE); } break; - case 158: /* type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy136 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy0); } + case 159: /* type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ +{ yymsp[-3].minor.yy84 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy0); } break; - case 159: /* type_name ::= TIMESTAMP */ -{ yymsp[0].minor.yy136 = createDataType(TSDB_DATA_TYPE_TIMESTAMP); } + case 160: /* type_name ::= TIMESTAMP */ +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_TIMESTAMP); } break; - case 160: /* type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy136 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, &yymsp[-1].minor.yy0); } + case 161: /* type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ +{ yymsp[-3].minor.yy84 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, &yymsp[-1].minor.yy0); } break; - case 161: /* type_name ::= TINYINT UNSIGNED */ -{ yymsp[-1].minor.yy136 = createDataType(TSDB_DATA_TYPE_UTINYINT); } + case 162: /* type_name ::= TINYINT UNSIGNED */ +{ yymsp[-1].minor.yy84 = createDataType(TSDB_DATA_TYPE_UTINYINT); } break; - case 162: /* type_name ::= SMALLINT UNSIGNED */ -{ yymsp[-1].minor.yy136 = createDataType(TSDB_DATA_TYPE_USMALLINT); } + case 163: /* type_name ::= SMALLINT UNSIGNED */ +{ yymsp[-1].minor.yy84 = createDataType(TSDB_DATA_TYPE_USMALLINT); } break; - case 163: /* type_name ::= INT UNSIGNED */ -{ yymsp[-1].minor.yy136 = createDataType(TSDB_DATA_TYPE_UINT); } + case 164: /* type_name ::= INT UNSIGNED */ +{ yymsp[-1].minor.yy84 = createDataType(TSDB_DATA_TYPE_UINT); } break; - case 164: /* type_name ::= BIGINT UNSIGNED */ -{ yymsp[-1].minor.yy136 = createDataType(TSDB_DATA_TYPE_UBIGINT); } + case 165: /* type_name ::= BIGINT UNSIGNED */ +{ yymsp[-1].minor.yy84 = createDataType(TSDB_DATA_TYPE_UBIGINT); } break; - case 165: /* type_name ::= JSON */ -{ yymsp[0].minor.yy136 = createDataType(TSDB_DATA_TYPE_JSON); } + case 166: /* type_name ::= JSON */ +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_JSON); } break; - case 166: /* type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy136 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, &yymsp[-1].minor.yy0); } + case 167: /* type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ +{ yymsp[-3].minor.yy84 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, &yymsp[-1].minor.yy0); } break; - case 167: /* type_name ::= MEDIUMBLOB */ -{ yymsp[0].minor.yy136 = createDataType(TSDB_DATA_TYPE_MEDIUMBLOB); } + case 168: /* type_name ::= MEDIUMBLOB */ +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_MEDIUMBLOB); } break; - case 168: /* type_name ::= BLOB */ -{ yymsp[0].minor.yy136 = createDataType(TSDB_DATA_TYPE_BLOB); } + case 169: /* type_name ::= BLOB */ +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_BLOB); } break; - case 169: /* type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy136 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, &yymsp[-1].minor.yy0); } + case 170: /* type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ +{ yymsp[-3].minor.yy84 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, &yymsp[-1].minor.yy0); } break; - case 170: /* type_name ::= DECIMAL */ -{ yymsp[0].minor.yy136 = createDataType(TSDB_DATA_TYPE_DECIMAL); } + case 171: /* type_name ::= DECIMAL */ +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; - case 171: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ -{ yymsp[-3].minor.yy136 = createDataType(TSDB_DATA_TYPE_DECIMAL); } + case 172: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ +{ yymsp[-3].minor.yy84 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; - case 172: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ -{ yymsp[-5].minor.yy136 = createDataType(TSDB_DATA_TYPE_DECIMAL); } + case 173: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ +{ yymsp[-5].minor.yy84 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; - case 174: /* tags_def_opt ::= tags_def */ - case 377: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==377); -{ yylhsminor.yy574 = yymsp[0].minor.yy574; } - yymsp[0].minor.yy574 = yylhsminor.yy574; + case 175: /* tags_def_opt ::= tags_def */ + case 378: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==378); +{ yylhsminor.yy824 = yymsp[0].minor.yy824; } + yymsp[0].minor.yy824 = yylhsminor.yy824; break; - case 175: /* tags_def ::= TAGS NK_LP column_def_list NK_RP */ -{ yymsp[-3].minor.yy574 = yymsp[-1].minor.yy574; } + case 176: /* tags_def ::= TAGS NK_LP column_def_list NK_RP */ +{ yymsp[-3].minor.yy824 = yymsp[-1].minor.yy824; } break; - case 176: /* table_options ::= */ -{ yymsp[1].minor.yy80 = createDefaultTableOptions(pCxt); } + case 177: /* table_options ::= */ +{ yymsp[1].minor.yy312 = createDefaultTableOptions(pCxt); } break; - case 177: /* table_options ::= table_options COMMENT NK_STRING */ -{ yylhsminor.yy80 = setTableOption(pCxt, yymsp[-2].minor.yy80, TABLE_OPTION_COMMENT, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 178: /* table_options ::= table_options COMMENT NK_STRING */ +{ yylhsminor.yy312 = setTableOption(pCxt, yymsp[-2].minor.yy312, TABLE_OPTION_COMMENT, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 178: /* table_options ::= table_options MAX_DELAY duration_list */ -{ yylhsminor.yy80 = setTableOption(pCxt, yymsp[-2].minor.yy80, TABLE_OPTION_MAXDELAY, yymsp[0].minor.yy574); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 179: /* table_options ::= table_options MAX_DELAY duration_list */ +{ yylhsminor.yy312 = setTableOption(pCxt, yymsp[-2].minor.yy312, TABLE_OPTION_MAXDELAY, yymsp[0].minor.yy824); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 179: /* table_options ::= table_options WATERMARK duration_list */ -{ yylhsminor.yy80 = setTableOption(pCxt, yymsp[-2].minor.yy80, TABLE_OPTION_WATERMARK, yymsp[0].minor.yy574); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 180: /* table_options ::= table_options WATERMARK duration_list */ +{ yylhsminor.yy312 = setTableOption(pCxt, yymsp[-2].minor.yy312, TABLE_OPTION_WATERMARK, yymsp[0].minor.yy824); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 180: /* table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ -{ yylhsminor.yy80 = setTableOption(pCxt, yymsp[-4].minor.yy80, TABLE_OPTION_ROLLUP, yymsp[-1].minor.yy574); } - yymsp[-4].minor.yy80 = yylhsminor.yy80; + case 181: /* table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ +{ yylhsminor.yy312 = setTableOption(pCxt, yymsp[-4].minor.yy312, TABLE_OPTION_ROLLUP, yymsp[-1].minor.yy824); } + yymsp[-4].minor.yy312 = yylhsminor.yy312; break; - case 181: /* table_options ::= table_options TTL NK_INTEGER */ -{ yylhsminor.yy80 = setTableOption(pCxt, yymsp[-2].minor.yy80, TABLE_OPTION_TTL, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 182: /* table_options ::= table_options TTL NK_INTEGER */ +{ yylhsminor.yy312 = setTableOption(pCxt, yymsp[-2].minor.yy312, TABLE_OPTION_TTL, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 182: /* table_options ::= table_options SMA NK_LP col_name_list NK_RP */ -{ yylhsminor.yy80 = setTableOption(pCxt, yymsp[-4].minor.yy80, TABLE_OPTION_SMA, yymsp[-1].minor.yy574); } - yymsp[-4].minor.yy80 = yylhsminor.yy80; + case 183: /* table_options ::= table_options SMA NK_LP col_name_list NK_RP */ +{ yylhsminor.yy312 = setTableOption(pCxt, yymsp[-4].minor.yy312, TABLE_OPTION_SMA, yymsp[-1].minor.yy824); } + yymsp[-4].minor.yy312 = yylhsminor.yy312; break; - case 183: /* alter_table_options ::= alter_table_option */ -{ yylhsminor.yy80 = createAlterTableOptions(pCxt); yylhsminor.yy80 = setTableOption(pCxt, yylhsminor.yy80, yymsp[0].minor.yy299.type, &yymsp[0].minor.yy299.val); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 184: /* alter_table_options ::= alter_table_option */ +{ yylhsminor.yy312 = createAlterTableOptions(pCxt); yylhsminor.yy312 = setTableOption(pCxt, yylhsminor.yy312, yymsp[0].minor.yy405.type, &yymsp[0].minor.yy405.val); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 184: /* alter_table_options ::= alter_table_options alter_table_option */ -{ yylhsminor.yy80 = setTableOption(pCxt, yymsp[-1].minor.yy80, yymsp[0].minor.yy299.type, &yymsp[0].minor.yy299.val); } - yymsp[-1].minor.yy80 = yylhsminor.yy80; + case 185: /* alter_table_options ::= alter_table_options alter_table_option */ +{ yylhsminor.yy312 = setTableOption(pCxt, yymsp[-1].minor.yy312, yymsp[0].minor.yy405.type, &yymsp[0].minor.yy405.val); } + yymsp[-1].minor.yy312 = yylhsminor.yy312; break; - case 185: /* alter_table_option ::= COMMENT NK_STRING */ -{ yymsp[-1].minor.yy299.type = TABLE_OPTION_COMMENT; yymsp[-1].minor.yy299.val = yymsp[0].minor.yy0; } + case 186: /* alter_table_option ::= COMMENT NK_STRING */ +{ yymsp[-1].minor.yy405.type = TABLE_OPTION_COMMENT; yymsp[-1].minor.yy405.val = yymsp[0].minor.yy0; } break; - case 186: /* alter_table_option ::= TTL NK_INTEGER */ -{ yymsp[-1].minor.yy299.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy299.val = yymsp[0].minor.yy0; } + case 187: /* alter_table_option ::= TTL NK_INTEGER */ +{ yymsp[-1].minor.yy405.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy405.val = yymsp[0].minor.yy0; } break; - case 187: /* duration_list ::= duration_literal */ - case 344: /* expression_list ::= expression */ yytestcase(yyruleno==344); -{ yylhsminor.yy574 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy80)); } - yymsp[0].minor.yy574 = yylhsminor.yy574; + case 188: /* duration_list ::= duration_literal */ + case 345: /* expression_list ::= expression */ yytestcase(yyruleno==345); +{ yylhsminor.yy824 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy312)); } + yymsp[0].minor.yy824 = yylhsminor.yy824; break; - case 188: /* duration_list ::= duration_list NK_COMMA duration_literal */ - case 345: /* expression_list ::= expression_list NK_COMMA expression */ yytestcase(yyruleno==345); -{ yylhsminor.yy574 = addNodeToList(pCxt, yymsp[-2].minor.yy574, releaseRawExprNode(pCxt, yymsp[0].minor.yy80)); } - yymsp[-2].minor.yy574 = yylhsminor.yy574; + case 189: /* duration_list ::= duration_list NK_COMMA duration_literal */ + case 346: /* expression_list ::= expression_list NK_COMMA expression */ yytestcase(yyruleno==346); +{ yylhsminor.yy824 = addNodeToList(pCxt, yymsp[-2].minor.yy824, releaseRawExprNode(pCxt, yymsp[0].minor.yy312)); } + yymsp[-2].minor.yy824 = yylhsminor.yy824; break; - case 191: /* rollup_func_name ::= function_name */ -{ yylhsminor.yy80 = createFunctionNode(pCxt, &yymsp[0].minor.yy239, NULL); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 192: /* rollup_func_name ::= function_name */ +{ yylhsminor.yy312 = createFunctionNode(pCxt, &yymsp[0].minor.yy149, NULL); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 192: /* rollup_func_name ::= FIRST */ - case 193: /* rollup_func_name ::= LAST */ yytestcase(yyruleno==193); -{ yylhsminor.yy80 = createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 193: /* rollup_func_name ::= FIRST */ + case 194: /* rollup_func_name ::= LAST */ yytestcase(yyruleno==194); +{ yylhsminor.yy312 = createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 196: /* col_name ::= column_name */ -{ yylhsminor.yy80 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy239); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 197: /* col_name ::= column_name */ +{ yylhsminor.yy312 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy149); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 197: /* cmd ::= SHOW DNODES */ + case 198: /* cmd ::= SHOW DNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DNODES_STMT); } break; - case 198: /* cmd ::= SHOW USERS */ + case 199: /* cmd ::= SHOW USERS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_USERS_STMT); } break; - case 199: /* cmd ::= SHOW DATABASES */ + case 200: /* cmd ::= SHOW DATABASES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DATABASES_STMT); } break; - case 200: /* cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */ -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TABLES_STMT, yymsp[-2].minor.yy80, yymsp[0].minor.yy80, OP_TYPE_LIKE); } + case 201: /* cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */ +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TABLES_STMT, yymsp[-2].minor.yy312, yymsp[0].minor.yy312, OP_TYPE_LIKE); } break; - case 201: /* cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_STABLES_STMT, yymsp[-2].minor.yy80, yymsp[0].minor.yy80, OP_TYPE_LIKE); } + case 202: /* cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_STABLES_STMT, yymsp[-2].minor.yy312, yymsp[0].minor.yy312, OP_TYPE_LIKE); } break; - case 202: /* cmd ::= SHOW db_name_cond_opt VGROUPS */ -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, yymsp[-1].minor.yy80, NULL, OP_TYPE_LIKE); } + case 203: /* cmd ::= SHOW db_name_cond_opt VGROUPS */ +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, yymsp[-1].minor.yy312, NULL, OP_TYPE_LIKE); } break; - case 203: /* cmd ::= SHOW MNODES */ + case 204: /* cmd ::= SHOW MNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_MNODES_STMT); } break; - case 204: /* cmd ::= SHOW MODULES */ + case 205: /* cmd ::= SHOW MODULES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_MODULES_STMT); } break; - case 205: /* cmd ::= SHOW QNODES */ + case 206: /* cmd ::= SHOW QNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QNODES_STMT); } break; - case 206: /* cmd ::= SHOW FUNCTIONS */ + case 207: /* cmd ::= SHOW FUNCTIONS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_FUNCTIONS_STMT); } break; - case 207: /* cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, yymsp[0].minor.yy80, yymsp[-1].minor.yy80, OP_TYPE_EQUAL); } + case 208: /* cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, yymsp[0].minor.yy312, yymsp[-1].minor.yy312, OP_TYPE_EQUAL); } break; - case 208: /* cmd ::= SHOW STREAMS */ + case 209: /* cmd ::= SHOW STREAMS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_STREAMS_STMT); } break; - case 209: /* cmd ::= SHOW ACCOUNTS */ + case 210: /* cmd ::= SHOW ACCOUNTS */ { pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); } break; - case 210: /* cmd ::= SHOW APPS */ + case 211: /* cmd ::= SHOW APPS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_APPS_STMT); } break; - case 211: /* cmd ::= SHOW CONNECTIONS */ + case 212: /* cmd ::= SHOW CONNECTIONS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CONNECTIONS_STMT); } break; - case 212: /* cmd ::= SHOW LICENCES */ - case 213: /* cmd ::= SHOW GRANTS */ yytestcase(yyruleno==213); + case 213: /* cmd ::= SHOW LICENCES */ + case 214: /* cmd ::= SHOW GRANTS */ yytestcase(yyruleno==214); { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_LICENCES_STMT); } break; - case 214: /* cmd ::= SHOW CREATE DATABASE db_name */ -{ pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &yymsp[0].minor.yy239); } + case 215: /* cmd ::= SHOW CREATE DATABASE db_name */ +{ pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &yymsp[0].minor.yy149); } break; - case 215: /* cmd ::= SHOW CREATE TABLE full_table_name */ -{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, yymsp[0].minor.yy80); } + case 216: /* cmd ::= SHOW CREATE TABLE full_table_name */ +{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, yymsp[0].minor.yy312); } break; - case 216: /* cmd ::= SHOW CREATE STABLE full_table_name */ -{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, yymsp[0].minor.yy80); } + case 217: /* cmd ::= SHOW CREATE STABLE full_table_name */ +{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, yymsp[0].minor.yy312); } break; - case 217: /* cmd ::= SHOW QUERIES */ + case 218: /* cmd ::= SHOW QUERIES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QUERIES_STMT); } break; - case 218: /* cmd ::= SHOW SCORES */ + case 219: /* cmd ::= SHOW SCORES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SCORES_STMT); } break; - case 219: /* cmd ::= SHOW TOPICS */ + case 220: /* cmd ::= SHOW TOPICS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TOPICS_STMT); } break; - case 220: /* cmd ::= SHOW VARIABLES */ + case 221: /* cmd ::= SHOW VARIABLES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_VARIABLES_STMT); } break; - case 221: /* cmd ::= SHOW LOCAL VARIABLES */ + case 222: /* cmd ::= SHOW LOCAL VARIABLES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT); } break; - case 222: /* cmd ::= SHOW DNODE NK_INTEGER VARIABLES */ + case 223: /* cmd ::= SHOW DNODE NK_INTEGER VARIABLES */ { pCxt->pRootNode = createShowDnodeVariablesStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[-1].minor.yy0)); } break; - case 223: /* cmd ::= SHOW BNODES */ + case 224: /* cmd ::= SHOW BNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_BNODES_STMT); } break; - case 224: /* cmd ::= SHOW SNODES */ + case 225: /* cmd ::= SHOW SNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SNODES_STMT); } break; - case 225: /* cmd ::= SHOW CLUSTER */ + case 226: /* cmd ::= SHOW CLUSTER */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CLUSTER_STMT); } break; - case 226: /* cmd ::= SHOW TRANSACTIONS */ + case 227: /* cmd ::= SHOW TRANSACTIONS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TRANSACTIONS_STMT); } break; - case 227: /* cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ -{ pCxt->pRootNode = createShowTableDistributedStmt(pCxt, yymsp[0].minor.yy80); } + case 228: /* cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ +{ pCxt->pRootNode = createShowTableDistributedStmt(pCxt, yymsp[0].minor.yy312); } break; - case 228: /* cmd ::= SHOW CONSUMERS */ + case 229: /* cmd ::= SHOW CONSUMERS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CONSUMERS_STMT); } break; - case 229: /* cmd ::= SHOW SUBSCRIPTIONS */ + case 230: /* cmd ::= SHOW SUBSCRIPTIONS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT); } break; - case 230: /* cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, yymsp[0].minor.yy80, yymsp[-1].minor.yy80, OP_TYPE_EQUAL); } + case 231: /* cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, yymsp[0].minor.yy312, yymsp[-1].minor.yy312, OP_TYPE_EQUAL); } break; - case 231: /* cmd ::= SHOW VNODES NK_INTEGER */ + case 232: /* cmd ::= SHOW VNODES NK_INTEGER */ { pCxt->pRootNode = createShowVnodesStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0), NULL); } break; - case 232: /* cmd ::= SHOW VNODES NK_STRING */ + case 233: /* cmd ::= SHOW VNODES NK_STRING */ { pCxt->pRootNode = createShowVnodesStmt(pCxt, NULL, createValueNode(pCxt, TSDB_DATA_TYPE_VARCHAR, &yymsp[0].minor.yy0)); } break; - case 233: /* db_name_cond_opt ::= */ - case 238: /* from_db_opt ::= */ yytestcase(yyruleno==238); -{ yymsp[1].minor.yy80 = createDefaultDatabaseCondValue(pCxt); } + case 234: /* db_name_cond_opt ::= */ + case 239: /* from_db_opt ::= */ yytestcase(yyruleno==239); +{ yymsp[1].minor.yy312 = createDefaultDatabaseCondValue(pCxt); } break; - case 234: /* db_name_cond_opt ::= db_name NK_DOT */ -{ yylhsminor.yy80 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy239); } - yymsp[-1].minor.yy80 = yylhsminor.yy80; + case 235: /* db_name_cond_opt ::= db_name NK_DOT */ +{ yylhsminor.yy312 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy149); } + yymsp[-1].minor.yy312 = yylhsminor.yy312; break; - case 235: /* like_pattern_opt ::= */ - case 410: /* from_clause_opt ::= */ yytestcase(yyruleno==410); - case 439: /* where_clause_opt ::= */ yytestcase(yyruleno==439); - case 443: /* twindow_clause_opt ::= */ yytestcase(yyruleno==443); - case 448: /* sliding_opt ::= */ yytestcase(yyruleno==448); - case 450: /* fill_opt ::= */ yytestcase(yyruleno==450); - case 462: /* having_clause_opt ::= */ yytestcase(yyruleno==462); - case 464: /* range_opt ::= */ yytestcase(yyruleno==464); - case 466: /* every_opt ::= */ yytestcase(yyruleno==466); - case 476: /* slimit_clause_opt ::= */ yytestcase(yyruleno==476); - case 480: /* limit_clause_opt ::= */ yytestcase(yyruleno==480); -{ yymsp[1].minor.yy80 = NULL; } + case 236: /* like_pattern_opt ::= */ + case 411: /* from_clause_opt ::= */ yytestcase(yyruleno==411); + case 440: /* where_clause_opt ::= */ yytestcase(yyruleno==440); + case 444: /* twindow_clause_opt ::= */ yytestcase(yyruleno==444); + case 449: /* sliding_opt ::= */ yytestcase(yyruleno==449); + case 451: /* fill_opt ::= */ yytestcase(yyruleno==451); + case 463: /* having_clause_opt ::= */ yytestcase(yyruleno==463); + case 465: /* range_opt ::= */ yytestcase(yyruleno==465); + case 467: /* every_opt ::= */ yytestcase(yyruleno==467); + case 477: /* slimit_clause_opt ::= */ yytestcase(yyruleno==477); + case 481: /* limit_clause_opt ::= */ yytestcase(yyruleno==481); +{ yymsp[1].minor.yy312 = NULL; } break; - case 236: /* like_pattern_opt ::= LIKE NK_STRING */ -{ yymsp[-1].minor.yy80 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } + case 237: /* like_pattern_opt ::= LIKE NK_STRING */ +{ yymsp[-1].minor.yy312 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } break; - case 237: /* table_name_cond ::= table_name */ -{ yylhsminor.yy80 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy239); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 238: /* table_name_cond ::= table_name */ +{ yylhsminor.yy312 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy149); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 239: /* from_db_opt ::= FROM db_name */ -{ yymsp[-1].minor.yy80 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy239); } + case 240: /* from_db_opt ::= FROM db_name */ +{ yymsp[-1].minor.yy312 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy149); } break; - case 240: /* cmd ::= CREATE SMA INDEX not_exists_opt full_table_name ON full_table_name index_options */ -{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_SMA, yymsp[-4].minor.yy845, yymsp[-3].minor.yy80, yymsp[-1].minor.yy80, NULL, yymsp[0].minor.yy80); } + case 241: /* cmd ::= CREATE SMA INDEX not_exists_opt full_table_name ON full_table_name index_options */ +{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_SMA, yymsp[-4].minor.yy497, yymsp[-3].minor.yy312, yymsp[-1].minor.yy312, NULL, yymsp[0].minor.yy312); } break; - case 241: /* cmd ::= DROP INDEX exists_opt full_table_name */ -{ pCxt->pRootNode = createDropIndexStmt(pCxt, yymsp[-1].minor.yy845, yymsp[0].minor.yy80); } + case 242: /* cmd ::= DROP INDEX exists_opt full_table_name */ +{ pCxt->pRootNode = createDropIndexStmt(pCxt, yymsp[-1].minor.yy497, yymsp[0].minor.yy312); } break; - case 242: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ -{ yymsp[-9].minor.yy80 = createIndexOption(pCxt, yymsp[-7].minor.yy574, releaseRawExprNode(pCxt, yymsp[-3].minor.yy80), NULL, yymsp[-1].minor.yy80, yymsp[0].minor.yy80); } + case 243: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ +{ yymsp[-9].minor.yy312 = createIndexOption(pCxt, yymsp[-7].minor.yy824, releaseRawExprNode(pCxt, yymsp[-3].minor.yy312), NULL, yymsp[-1].minor.yy312, yymsp[0].minor.yy312); } break; - case 243: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt */ -{ yymsp[-11].minor.yy80 = createIndexOption(pCxt, yymsp[-9].minor.yy574, releaseRawExprNode(pCxt, yymsp[-5].minor.yy80), releaseRawExprNode(pCxt, yymsp[-3].minor.yy80), yymsp[-1].minor.yy80, yymsp[0].minor.yy80); } + case 244: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt */ +{ yymsp[-11].minor.yy312 = createIndexOption(pCxt, yymsp[-9].minor.yy824, releaseRawExprNode(pCxt, yymsp[-5].minor.yy312), releaseRawExprNode(pCxt, yymsp[-3].minor.yy312), yymsp[-1].minor.yy312, yymsp[0].minor.yy312); } break; - case 246: /* func ::= function_name NK_LP expression_list NK_RP */ -{ yylhsminor.yy80 = createFunctionNode(pCxt, &yymsp[-3].minor.yy239, yymsp[-1].minor.yy574); } - yymsp[-3].minor.yy80 = yylhsminor.yy80; + case 247: /* func ::= function_name NK_LP expression_list NK_RP */ +{ yylhsminor.yy312 = createFunctionNode(pCxt, &yymsp[-3].minor.yy149, yymsp[-1].minor.yy824); } + yymsp[-3].minor.yy312 = yylhsminor.yy312; break; - case 247: /* sma_stream_opt ::= */ - case 274: /* stream_options ::= */ yytestcase(yyruleno==274); -{ yymsp[1].minor.yy80 = createStreamOptions(pCxt); } + case 248: /* sma_stream_opt ::= */ + case 275: /* stream_options ::= */ yytestcase(yyruleno==275); +{ yymsp[1].minor.yy312 = createStreamOptions(pCxt); } break; - case 248: /* sma_stream_opt ::= stream_options WATERMARK duration_literal */ - case 278: /* stream_options ::= stream_options WATERMARK duration_literal */ yytestcase(yyruleno==278); -{ ((SStreamOptions*)yymsp[-2].minor.yy80)->pWatermark = releaseRawExprNode(pCxt, yymsp[0].minor.yy80); yylhsminor.yy80 = yymsp[-2].minor.yy80; } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 249: /* sma_stream_opt ::= stream_options WATERMARK duration_literal */ + case 279: /* stream_options ::= stream_options WATERMARK duration_literal */ yytestcase(yyruleno==279); +{ ((SStreamOptions*)yymsp[-2].minor.yy312)->pWatermark = releaseRawExprNode(pCxt, yymsp[0].minor.yy312); yylhsminor.yy312 = yymsp[-2].minor.yy312; } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 249: /* sma_stream_opt ::= stream_options MAX_DELAY duration_literal */ -{ ((SStreamOptions*)yymsp[-2].minor.yy80)->pDelay = releaseRawExprNode(pCxt, yymsp[0].minor.yy80); yylhsminor.yy80 = yymsp[-2].minor.yy80; } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 250: /* sma_stream_opt ::= stream_options MAX_DELAY duration_literal */ +{ ((SStreamOptions*)yymsp[-2].minor.yy312)->pDelay = releaseRawExprNode(pCxt, yymsp[0].minor.yy312); yylhsminor.yy312 = yymsp[-2].minor.yy312; } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 250: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression */ -{ pCxt->pRootNode = createCreateTopicStmtUseQuery(pCxt, yymsp[-3].minor.yy845, &yymsp[-2].minor.yy239, yymsp[0].minor.yy80); } + case 251: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression */ +{ pCxt->pRootNode = createCreateTopicStmtUseQuery(pCxt, yymsp[-3].minor.yy497, &yymsp[-2].minor.yy149, yymsp[0].minor.yy312); } break; - case 251: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name */ -{ pCxt->pRootNode = createCreateTopicStmtUseDb(pCxt, yymsp[-4].minor.yy845, &yymsp[-3].minor.yy239, &yymsp[0].minor.yy239, false); } + case 252: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name */ +{ pCxt->pRootNode = createCreateTopicStmtUseDb(pCxt, yymsp[-4].minor.yy497, &yymsp[-3].minor.yy149, &yymsp[0].minor.yy149, false); } break; - case 252: /* cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS DATABASE db_name */ -{ pCxt->pRootNode = createCreateTopicStmtUseDb(pCxt, yymsp[-6].minor.yy845, &yymsp[-5].minor.yy239, &yymsp[0].minor.yy239, true); } + case 253: /* cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS DATABASE db_name */ +{ pCxt->pRootNode = createCreateTopicStmtUseDb(pCxt, yymsp[-6].minor.yy497, &yymsp[-5].minor.yy149, &yymsp[0].minor.yy149, true); } break; - case 253: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name */ -{ pCxt->pRootNode = createCreateTopicStmtUseTable(pCxt, yymsp[-4].minor.yy845, &yymsp[-3].minor.yy239, yymsp[0].minor.yy80, false); } + case 254: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name */ +{ pCxt->pRootNode = createCreateTopicStmtUseTable(pCxt, yymsp[-4].minor.yy497, &yymsp[-3].minor.yy149, yymsp[0].minor.yy312, false); } break; - case 254: /* cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS STABLE full_table_name */ -{ pCxt->pRootNode = createCreateTopicStmtUseTable(pCxt, yymsp[-6].minor.yy845, &yymsp[-5].minor.yy239, yymsp[0].minor.yy80, true); } + case 255: /* cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS STABLE full_table_name */ +{ pCxt->pRootNode = createCreateTopicStmtUseTable(pCxt, yymsp[-6].minor.yy497, &yymsp[-5].minor.yy149, yymsp[0].minor.yy312, true); } break; - case 255: /* cmd ::= DROP TOPIC exists_opt topic_name */ -{ pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy845, &yymsp[0].minor.yy239); } + case 256: /* cmd ::= DROP TOPIC exists_opt topic_name */ +{ pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy497, &yymsp[0].minor.yy149); } break; - case 256: /* cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ -{ pCxt->pRootNode = createDropCGroupStmt(pCxt, yymsp[-3].minor.yy845, &yymsp[-2].minor.yy239, &yymsp[0].minor.yy239); } + case 257: /* cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ +{ pCxt->pRootNode = createDropCGroupStmt(pCxt, yymsp[-3].minor.yy497, &yymsp[-2].minor.yy149, &yymsp[0].minor.yy149); } break; - case 257: /* cmd ::= DESC full_table_name */ - case 258: /* cmd ::= DESCRIBE full_table_name */ yytestcase(yyruleno==258); -{ pCxt->pRootNode = createDescribeStmt(pCxt, yymsp[0].minor.yy80); } + case 258: /* cmd ::= DESC full_table_name */ + case 259: /* cmd ::= DESCRIBE full_table_name */ yytestcase(yyruleno==259); +{ pCxt->pRootNode = createDescribeStmt(pCxt, yymsp[0].minor.yy312); } break; - case 259: /* cmd ::= RESET QUERY CACHE */ + case 260: /* cmd ::= RESET QUERY CACHE */ { pCxt->pRootNode = createResetQueryCacheStmt(pCxt); } break; - case 260: /* cmd ::= EXPLAIN analyze_opt explain_options query_expression */ -{ pCxt->pRootNode = createExplainStmt(pCxt, yymsp[-2].minor.yy845, yymsp[-1].minor.yy80, yymsp[0].minor.yy80); } + case 261: /* cmd ::= EXPLAIN analyze_opt explain_options query_expression */ +{ pCxt->pRootNode = createExplainStmt(pCxt, yymsp[-2].minor.yy497, yymsp[-1].minor.yy312, yymsp[0].minor.yy312); } break; - case 262: /* analyze_opt ::= ANALYZE */ - case 269: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==269); - case 430: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==430); -{ yymsp[0].minor.yy845 = true; } + case 263: /* analyze_opt ::= ANALYZE */ + case 270: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==270); + case 431: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==431); +{ yymsp[0].minor.yy497 = true; } break; - case 263: /* explain_options ::= */ -{ yymsp[1].minor.yy80 = createDefaultExplainOptions(pCxt); } + case 264: /* explain_options ::= */ +{ yymsp[1].minor.yy312 = createDefaultExplainOptions(pCxt); } break; - case 264: /* explain_options ::= explain_options VERBOSE NK_BOOL */ -{ yylhsminor.yy80 = setExplainVerbose(pCxt, yymsp[-2].minor.yy80, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 265: /* explain_options ::= explain_options VERBOSE NK_BOOL */ +{ yylhsminor.yy312 = setExplainVerbose(pCxt, yymsp[-2].minor.yy312, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 265: /* explain_options ::= explain_options RATIO NK_FLOAT */ -{ yylhsminor.yy80 = setExplainRatio(pCxt, yymsp[-2].minor.yy80, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 266: /* explain_options ::= explain_options RATIO NK_FLOAT */ +{ yylhsminor.yy312 = setExplainRatio(pCxt, yymsp[-2].minor.yy312, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 266: /* 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.yy845, yymsp[-8].minor.yy845, &yymsp[-5].minor.yy239, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy136, yymsp[0].minor.yy46); } + case 267: /* 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.yy497, yymsp[-8].minor.yy497, &yymsp[-5].minor.yy149, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy84, yymsp[0].minor.yy160); } break; - case 267: /* cmd ::= DROP FUNCTION exists_opt function_name */ -{ pCxt->pRootNode = createDropFunctionStmt(pCxt, yymsp[-1].minor.yy845, &yymsp[0].minor.yy239); } + case 268: /* cmd ::= DROP FUNCTION exists_opt function_name */ +{ pCxt->pRootNode = createDropFunctionStmt(pCxt, yymsp[-1].minor.yy497, &yymsp[0].minor.yy149); } break; - case 270: /* bufsize_opt ::= */ -{ yymsp[1].minor.yy46 = 0; } + case 271: /* bufsize_opt ::= */ +{ yymsp[1].minor.yy160 = 0; } break; - case 271: /* bufsize_opt ::= BUFSIZE NK_INTEGER */ -{ yymsp[-1].minor.yy46 = taosStr2Int32(yymsp[0].minor.yy0.z, NULL, 10); } + case 272: /* bufsize_opt ::= BUFSIZE NK_INTEGER */ +{ yymsp[-1].minor.yy160 = taosStr2Int32(yymsp[0].minor.yy0.z, NULL, 10); } break; - case 272: /* cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name AS query_expression */ -{ pCxt->pRootNode = createCreateStreamStmt(pCxt, yymsp[-6].minor.yy845, &yymsp[-5].minor.yy239, yymsp[-2].minor.yy80, yymsp[-4].minor.yy80, yymsp[0].minor.yy80); } + case 273: /* cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name AS query_expression */ +{ pCxt->pRootNode = createCreateStreamStmt(pCxt, yymsp[-6].minor.yy497, &yymsp[-5].minor.yy149, yymsp[-2].minor.yy312, yymsp[-4].minor.yy312, yymsp[0].minor.yy312); } break; - case 273: /* cmd ::= DROP STREAM exists_opt stream_name */ -{ pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy845, &yymsp[0].minor.yy239); } + case 274: /* cmd ::= DROP STREAM exists_opt stream_name */ +{ pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy497, &yymsp[0].minor.yy149); } break; - case 275: /* stream_options ::= stream_options TRIGGER AT_ONCE */ -{ ((SStreamOptions*)yymsp[-2].minor.yy80)->triggerType = STREAM_TRIGGER_AT_ONCE; yylhsminor.yy80 = yymsp[-2].minor.yy80; } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 276: /* stream_options ::= stream_options TRIGGER AT_ONCE */ +{ ((SStreamOptions*)yymsp[-2].minor.yy312)->triggerType = STREAM_TRIGGER_AT_ONCE; yylhsminor.yy312 = yymsp[-2].minor.yy312; } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 276: /* stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ -{ ((SStreamOptions*)yymsp[-2].minor.yy80)->triggerType = STREAM_TRIGGER_WINDOW_CLOSE; yylhsminor.yy80 = yymsp[-2].minor.yy80; } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 277: /* stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ +{ ((SStreamOptions*)yymsp[-2].minor.yy312)->triggerType = STREAM_TRIGGER_WINDOW_CLOSE; yylhsminor.yy312 = yymsp[-2].minor.yy312; } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 277: /* stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ -{ ((SStreamOptions*)yymsp[-3].minor.yy80)->triggerType = STREAM_TRIGGER_MAX_DELAY; ((SStreamOptions*)yymsp[-3].minor.yy80)->pDelay = releaseRawExprNode(pCxt, yymsp[0].minor.yy80); yylhsminor.yy80 = yymsp[-3].minor.yy80; } - yymsp[-3].minor.yy80 = yylhsminor.yy80; + case 278: /* stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ +{ ((SStreamOptions*)yymsp[-3].minor.yy312)->triggerType = STREAM_TRIGGER_MAX_DELAY; ((SStreamOptions*)yymsp[-3].minor.yy312)->pDelay = releaseRawExprNode(pCxt, yymsp[0].minor.yy312); yylhsminor.yy312 = yymsp[-3].minor.yy312; } + yymsp[-3].minor.yy312 = yylhsminor.yy312; break; - case 279: /* stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ -{ ((SStreamOptions*)yymsp[-3].minor.yy80)->ignoreExpired = taosStr2Int8(yymsp[0].minor.yy0.z, NULL, 10); yylhsminor.yy80 = yymsp[-3].minor.yy80; } - yymsp[-3].minor.yy80 = yylhsminor.yy80; + case 280: /* stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ +{ ((SStreamOptions*)yymsp[-3].minor.yy312)->ignoreExpired = taosStr2Int8(yymsp[0].minor.yy0.z, NULL, 10); yylhsminor.yy312 = yymsp[-3].minor.yy312; } + yymsp[-3].minor.yy312 = yylhsminor.yy312; break; - case 280: /* cmd ::= KILL CONNECTION NK_INTEGER */ + case 281: /* cmd ::= KILL CONNECTION NK_INTEGER */ { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_CONNECTION_STMT, &yymsp[0].minor.yy0); } break; - case 281: /* cmd ::= KILL QUERY NK_STRING */ + case 282: /* cmd ::= KILL QUERY NK_STRING */ { pCxt->pRootNode = createKillQueryStmt(pCxt, &yymsp[0].minor.yy0); } break; - case 282: /* cmd ::= KILL TRANSACTION NK_INTEGER */ + case 283: /* cmd ::= KILL TRANSACTION NK_INTEGER */ { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_TRANSACTION_STMT, &yymsp[0].minor.yy0); } break; - case 283: /* cmd ::= BALANCE VGROUP */ + case 284: /* cmd ::= BALANCE VGROUP */ { pCxt->pRootNode = createBalanceVgroupStmt(pCxt); } break; - case 284: /* cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ + case 285: /* cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ { pCxt->pRootNode = createMergeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } break; - case 285: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ -{ pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy574); } + case 286: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ +{ pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy824); } break; - case 286: /* cmd ::= SPLIT VGROUP NK_INTEGER */ + case 287: /* cmd ::= SPLIT VGROUP NK_INTEGER */ { pCxt->pRootNode = createSplitVgroupStmt(pCxt, &yymsp[0].minor.yy0); } break; - case 287: /* dnode_list ::= DNODE NK_INTEGER */ -{ yymsp[-1].minor.yy574 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } + case 288: /* dnode_list ::= DNODE NK_INTEGER */ +{ yymsp[-1].minor.yy824 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } break; - case 289: /* cmd ::= DELETE FROM full_table_name where_clause_opt */ -{ pCxt->pRootNode = createDeleteStmt(pCxt, yymsp[-1].minor.yy80, yymsp[0].minor.yy80); } + case 290: /* cmd ::= DELETE FROM full_table_name where_clause_opt */ +{ pCxt->pRootNode = createDeleteStmt(pCxt, yymsp[-1].minor.yy312, yymsp[0].minor.yy312); } break; - case 291: /* cmd ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_expression */ -{ pCxt->pRootNode = createInsertStmt(pCxt, yymsp[-4].minor.yy80, yymsp[-2].minor.yy574, yymsp[0].minor.yy80); } + case 292: /* cmd ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_expression */ +{ pCxt->pRootNode = createInsertStmt(pCxt, yymsp[-4].minor.yy312, yymsp[-2].minor.yy824, yymsp[0].minor.yy312); } break; - case 292: /* cmd ::= INSERT INTO full_table_name query_expression */ -{ pCxt->pRootNode = createInsertStmt(pCxt, yymsp[-1].minor.yy80, NULL, yymsp[0].minor.yy80); } + case 293: /* cmd ::= INSERT INTO full_table_name query_expression */ +{ pCxt->pRootNode = createInsertStmt(pCxt, yymsp[-1].minor.yy312, NULL, yymsp[0].minor.yy312); } break; - case 293: /* literal ::= NK_INTEGER */ -{ yylhsminor.yy80 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 294: /* literal ::= NK_INTEGER */ +{ yylhsminor.yy312 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 294: /* literal ::= NK_FLOAT */ -{ yylhsminor.yy80 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 295: /* literal ::= NK_FLOAT */ +{ yylhsminor.yy312 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 295: /* literal ::= NK_STRING */ -{ yylhsminor.yy80 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 296: /* literal ::= NK_STRING */ +{ yylhsminor.yy312 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 296: /* literal ::= NK_BOOL */ -{ yylhsminor.yy80 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 297: /* literal ::= NK_BOOL */ +{ yylhsminor.yy312 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 297: /* literal ::= TIMESTAMP NK_STRING */ -{ yylhsminor.yy80 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); } - yymsp[-1].minor.yy80 = yylhsminor.yy80; + case 298: /* literal ::= TIMESTAMP NK_STRING */ +{ yylhsminor.yy312 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); } + yymsp[-1].minor.yy312 = yylhsminor.yy312; break; - case 298: /* literal ::= duration_literal */ - case 308: /* signed_literal ::= signed */ yytestcase(yyruleno==308); - case 328: /* expression ::= literal */ yytestcase(yyruleno==328); - case 329: /* expression ::= pseudo_column */ yytestcase(yyruleno==329); - case 330: /* expression ::= column_reference */ yytestcase(yyruleno==330); - case 331: /* expression ::= function_expression */ yytestcase(yyruleno==331); - case 332: /* expression ::= subquery */ yytestcase(yyruleno==332); - case 360: /* function_expression ::= literal_func */ yytestcase(yyruleno==360); - case 402: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==402); - case 406: /* boolean_primary ::= predicate */ yytestcase(yyruleno==406); - case 408: /* common_expression ::= expression */ yytestcase(yyruleno==408); - case 409: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==409); - case 412: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==412); - case 414: /* table_reference ::= table_primary */ yytestcase(yyruleno==414); - case 415: /* table_reference ::= joined_table */ yytestcase(yyruleno==415); - case 419: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==419); - case 469: /* query_expression_body ::= query_primary */ yytestcase(yyruleno==469); - case 472: /* query_primary ::= query_specification */ yytestcase(yyruleno==472); -{ yylhsminor.yy80 = yymsp[0].minor.yy80; } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 299: /* literal ::= duration_literal */ + case 309: /* signed_literal ::= signed */ yytestcase(yyruleno==309); + case 329: /* expression ::= literal */ yytestcase(yyruleno==329); + case 330: /* expression ::= pseudo_column */ yytestcase(yyruleno==330); + case 331: /* expression ::= column_reference */ yytestcase(yyruleno==331); + case 332: /* expression ::= function_expression */ yytestcase(yyruleno==332); + case 333: /* expression ::= subquery */ yytestcase(yyruleno==333); + case 361: /* function_expression ::= literal_func */ yytestcase(yyruleno==361); + case 403: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==403); + case 407: /* boolean_primary ::= predicate */ yytestcase(yyruleno==407); + case 409: /* common_expression ::= expression */ yytestcase(yyruleno==409); + case 410: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==410); + case 413: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==413); + case 415: /* table_reference ::= table_primary */ yytestcase(yyruleno==415); + case 416: /* table_reference ::= joined_table */ yytestcase(yyruleno==416); + case 420: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==420); + case 470: /* query_expression_body ::= query_primary */ yytestcase(yyruleno==470); + case 473: /* query_primary ::= query_specification */ yytestcase(yyruleno==473); +{ yylhsminor.yy312 = yymsp[0].minor.yy312; } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 299: /* literal ::= NULL */ -{ yylhsminor.yy80 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 300: /* literal ::= NULL */ +{ yylhsminor.yy312 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 300: /* literal ::= NK_QUESTION */ -{ yylhsminor.yy80 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 301: /* literal ::= NK_QUESTION */ +{ yylhsminor.yy312 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 301: /* duration_literal ::= NK_VARIABLE */ -{ yylhsminor.yy80 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 302: /* duration_literal ::= NK_VARIABLE */ +{ yylhsminor.yy312 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 302: /* signed ::= NK_INTEGER */ -{ yylhsminor.yy80 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 303: /* signed ::= NK_INTEGER */ +{ yylhsminor.yy312 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 303: /* signed ::= NK_PLUS NK_INTEGER */ -{ yymsp[-1].minor.yy80 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } + case 304: /* signed ::= NK_PLUS NK_INTEGER */ +{ yymsp[-1].minor.yy312 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } break; - case 304: /* signed ::= NK_MINUS NK_INTEGER */ + case 305: /* 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.yy80 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &t); + yylhsminor.yy312 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &t); } - yymsp[-1].minor.yy80 = yylhsminor.yy80; + yymsp[-1].minor.yy312 = yylhsminor.yy312; break; - case 305: /* signed ::= NK_FLOAT */ -{ yylhsminor.yy80 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 306: /* signed ::= NK_FLOAT */ +{ yylhsminor.yy312 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 306: /* signed ::= NK_PLUS NK_FLOAT */ -{ yymsp[-1].minor.yy80 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } + case 307: /* signed ::= NK_PLUS NK_FLOAT */ +{ yymsp[-1].minor.yy312 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } break; - case 307: /* signed ::= NK_MINUS NK_FLOAT */ + case 308: /* 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.yy80 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t); + yylhsminor.yy312 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t); } - yymsp[-1].minor.yy80 = yylhsminor.yy80; + yymsp[-1].minor.yy312 = yylhsminor.yy312; break; - case 309: /* signed_literal ::= NK_STRING */ -{ yylhsminor.yy80 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 310: /* signed_literal ::= NK_STRING */ +{ yylhsminor.yy312 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 310: /* signed_literal ::= NK_BOOL */ -{ yylhsminor.yy80 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 311: /* signed_literal ::= NK_BOOL */ +{ yylhsminor.yy312 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 311: /* signed_literal ::= TIMESTAMP NK_STRING */ -{ yymsp[-1].minor.yy80 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } + case 312: /* signed_literal ::= TIMESTAMP NK_STRING */ +{ yymsp[-1].minor.yy312 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } break; - case 312: /* signed_literal ::= duration_literal */ - case 314: /* signed_literal ::= literal_func */ yytestcase(yyruleno==314); - case 380: /* star_func_para ::= expression */ yytestcase(yyruleno==380); - case 435: /* select_item ::= common_expression */ yytestcase(yyruleno==435); - case 485: /* search_condition ::= common_expression */ yytestcase(yyruleno==485); -{ yylhsminor.yy80 = releaseRawExprNode(pCxt, yymsp[0].minor.yy80); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 313: /* signed_literal ::= duration_literal */ + case 315: /* signed_literal ::= literal_func */ yytestcase(yyruleno==315); + case 381: /* star_func_para ::= expression */ yytestcase(yyruleno==381); + case 436: /* select_item ::= common_expression */ yytestcase(yyruleno==436); + case 486: /* search_condition ::= common_expression */ yytestcase(yyruleno==486); +{ yylhsminor.yy312 = releaseRawExprNode(pCxt, yymsp[0].minor.yy312); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 313: /* signed_literal ::= NULL */ -{ yylhsminor.yy80 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 314: /* signed_literal ::= NULL */ +{ yylhsminor.yy312 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 315: /* signed_literal ::= NK_QUESTION */ -{ yylhsminor.yy80 = createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 316: /* signed_literal ::= NK_QUESTION */ +{ yylhsminor.yy312 = createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 333: /* expression ::= NK_LP expression NK_RP */ - case 407: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==407); -{ yylhsminor.yy80 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy80)); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 334: /* expression ::= NK_LP expression NK_RP */ + case 408: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==408); +{ yylhsminor.yy312 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy312)); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 334: /* expression ::= NK_PLUS expression */ + case 335: /* expression ::= NK_PLUS expression */ { - SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy80); - yylhsminor.yy80 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy80)); + SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy312); + yylhsminor.yy312 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy312)); } - yymsp[-1].minor.yy80 = yylhsminor.yy80; + yymsp[-1].minor.yy312 = yylhsminor.yy312; break; - case 335: /* expression ::= NK_MINUS expression */ + case 336: /* expression ::= NK_MINUS expression */ { - SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy80); - yylhsminor.yy80 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy80), NULL)); + SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy312); + yylhsminor.yy312 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy312), NULL)); } - yymsp[-1].minor.yy80 = yylhsminor.yy80; + yymsp[-1].minor.yy312 = yylhsminor.yy312; break; - case 336: /* expression ::= expression NK_PLUS expression */ + case 337: /* expression ::= expression NK_PLUS expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy80); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy80); - yylhsminor.yy80 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_ADD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy80), releaseRawExprNode(pCxt, yymsp[0].minor.yy80))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy312); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy312); + yylhsminor.yy312 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_ADD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy312), releaseRawExprNode(pCxt, yymsp[0].minor.yy312))); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 337: /* expression ::= expression NK_MINUS expression */ + case 338: /* expression ::= expression NK_MINUS expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy80); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy80); - yylhsminor.yy80 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_SUB, releaseRawExprNode(pCxt, yymsp[-2].minor.yy80), releaseRawExprNode(pCxt, yymsp[0].minor.yy80))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy312); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy312); + yylhsminor.yy312 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_SUB, releaseRawExprNode(pCxt, yymsp[-2].minor.yy312), releaseRawExprNode(pCxt, yymsp[0].minor.yy312))); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 338: /* expression ::= expression NK_STAR expression */ + case 339: /* expression ::= expression NK_STAR expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy80); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy80); - yylhsminor.yy80 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MULTI, releaseRawExprNode(pCxt, yymsp[-2].minor.yy80), releaseRawExprNode(pCxt, yymsp[0].minor.yy80))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy312); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy312); + yylhsminor.yy312 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MULTI, releaseRawExprNode(pCxt, yymsp[-2].minor.yy312), releaseRawExprNode(pCxt, yymsp[0].minor.yy312))); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 339: /* expression ::= expression NK_SLASH expression */ + case 340: /* expression ::= expression NK_SLASH expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy80); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy80); - yylhsminor.yy80 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_DIV, releaseRawExprNode(pCxt, yymsp[-2].minor.yy80), releaseRawExprNode(pCxt, yymsp[0].minor.yy80))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy312); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy312); + yylhsminor.yy312 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_DIV, releaseRawExprNode(pCxt, yymsp[-2].minor.yy312), releaseRawExprNode(pCxt, yymsp[0].minor.yy312))); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 340: /* expression ::= expression NK_REM expression */ + case 341: /* expression ::= expression NK_REM expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy80); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy80); - yylhsminor.yy80 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_REM, releaseRawExprNode(pCxt, yymsp[-2].minor.yy80), releaseRawExprNode(pCxt, yymsp[0].minor.yy80))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy312); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy312); + yylhsminor.yy312 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_REM, releaseRawExprNode(pCxt, yymsp[-2].minor.yy312), releaseRawExprNode(pCxt, yymsp[0].minor.yy312))); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 341: /* expression ::= column_reference NK_ARROW NK_STRING */ + case 342: /* expression ::= column_reference NK_ARROW NK_STRING */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy80); - yylhsminor.yy80 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy80), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy312); + yylhsminor.yy312 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy312), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0))); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 342: /* expression ::= expression NK_BITAND expression */ + case 343: /* expression ::= expression NK_BITAND expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy80); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy80); - yylhsminor.yy80 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy80), releaseRawExprNode(pCxt, yymsp[0].minor.yy80))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy312); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy312); + yylhsminor.yy312 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy312), releaseRawExprNode(pCxt, yymsp[0].minor.yy312))); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 343: /* expression ::= expression NK_BITOR expression */ + case 344: /* expression ::= expression NK_BITOR expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy80); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy80); - yylhsminor.yy80 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy80), releaseRawExprNode(pCxt, yymsp[0].minor.yy80))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy312); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy312); + yylhsminor.yy312 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy312), releaseRawExprNode(pCxt, yymsp[0].minor.yy312))); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 346: /* column_reference ::= column_name */ -{ yylhsminor.yy80 = createRawExprNode(pCxt, &yymsp[0].minor.yy239, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy239)); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 347: /* column_reference ::= column_name */ +{ yylhsminor.yy312 = createRawExprNode(pCxt, &yymsp[0].minor.yy149, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy149)); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 347: /* column_reference ::= table_name NK_DOT column_name */ -{ yylhsminor.yy80 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy239, &yymsp[0].minor.yy239, createColumnNode(pCxt, &yymsp[-2].minor.yy239, &yymsp[0].minor.yy239)); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 348: /* column_reference ::= table_name NK_DOT column_name */ +{ yylhsminor.yy312 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy149, &yymsp[0].minor.yy149, createColumnNode(pCxt, &yymsp[-2].minor.yy149, &yymsp[0].minor.yy149)); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 348: /* pseudo_column ::= ROWTS */ - case 349: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==349); - case 351: /* pseudo_column ::= QSTART */ yytestcase(yyruleno==351); - case 352: /* pseudo_column ::= QEND */ yytestcase(yyruleno==352); - case 353: /* pseudo_column ::= QDURATION */ yytestcase(yyruleno==353); - case 354: /* pseudo_column ::= WSTART */ yytestcase(yyruleno==354); - case 355: /* pseudo_column ::= WEND */ yytestcase(yyruleno==355); - case 356: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==356); - case 362: /* literal_func ::= NOW */ yytestcase(yyruleno==362); -{ yylhsminor.yy80 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 349: /* pseudo_column ::= ROWTS */ + case 350: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==350); + case 352: /* pseudo_column ::= QSTART */ yytestcase(yyruleno==352); + case 353: /* pseudo_column ::= QEND */ yytestcase(yyruleno==353); + case 354: /* pseudo_column ::= QDURATION */ yytestcase(yyruleno==354); + case 355: /* pseudo_column ::= WSTART */ yytestcase(yyruleno==355); + case 356: /* pseudo_column ::= WEND */ yytestcase(yyruleno==356); + case 357: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==357); + case 363: /* literal_func ::= NOW */ yytestcase(yyruleno==363); +{ yylhsminor.yy312 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 350: /* pseudo_column ::= table_name NK_DOT TBNAME */ -{ yylhsminor.yy80 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy239, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy239)))); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 351: /* pseudo_column ::= table_name NK_DOT TBNAME */ +{ yylhsminor.yy312 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy149, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy149)))); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 357: /* function_expression ::= function_name NK_LP expression_list NK_RP */ - case 358: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==358); -{ yylhsminor.yy80 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy239, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy239, yymsp[-1].minor.yy574)); } - yymsp[-3].minor.yy80 = yylhsminor.yy80; + case 358: /* function_expression ::= function_name NK_LP expression_list NK_RP */ + case 359: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==359); +{ yylhsminor.yy312 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy149, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy149, yymsp[-1].minor.yy824)); } + yymsp[-3].minor.yy312 = yylhsminor.yy312; break; - case 359: /* function_expression ::= CAST NK_LP expression AS type_name NK_RP */ -{ yylhsminor.yy80 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy80), yymsp[-1].minor.yy136)); } - yymsp[-5].minor.yy80 = yylhsminor.yy80; + case 360: /* function_expression ::= CAST NK_LP expression AS type_name NK_RP */ +{ yylhsminor.yy312 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy312), yymsp[-1].minor.yy84)); } + yymsp[-5].minor.yy312 = yylhsminor.yy312; break; - case 361: /* literal_func ::= noarg_func NK_LP NK_RP */ -{ yylhsminor.yy80 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy239, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy239, NULL)); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 362: /* literal_func ::= noarg_func NK_LP NK_RP */ +{ yylhsminor.yy312 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy149, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy149, NULL)); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 376: /* star_func_para_list ::= NK_STAR */ -{ yylhsminor.yy574 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } - yymsp[0].minor.yy574 = yylhsminor.yy574; + case 377: /* star_func_para_list ::= NK_STAR */ +{ yylhsminor.yy824 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy824 = yylhsminor.yy824; break; - case 381: /* star_func_para ::= table_name NK_DOT NK_STAR */ - case 438: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==438); -{ yylhsminor.yy80 = createColumnNode(pCxt, &yymsp[-2].minor.yy239, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 382: /* star_func_para ::= table_name NK_DOT NK_STAR */ + case 439: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==439); +{ yylhsminor.yy312 = createColumnNode(pCxt, &yymsp[-2].minor.yy149, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 382: /* predicate ::= expression compare_op expression */ - case 387: /* predicate ::= expression in_op in_predicate_value */ yytestcase(yyruleno==387); + case 383: /* predicate ::= expression compare_op expression */ + case 388: /* predicate ::= expression in_op in_predicate_value */ yytestcase(yyruleno==388); { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy80); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy80); - yylhsminor.yy80 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, yymsp[-1].minor.yy194, releaseRawExprNode(pCxt, yymsp[-2].minor.yy80), releaseRawExprNode(pCxt, yymsp[0].minor.yy80))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy312); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy312); + yylhsminor.yy312 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, yymsp[-1].minor.yy320, releaseRawExprNode(pCxt, yymsp[-2].minor.yy312), releaseRawExprNode(pCxt, yymsp[0].minor.yy312))); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 383: /* predicate ::= expression BETWEEN expression AND expression */ + case 384: /* predicate ::= expression BETWEEN expression AND expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy80); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy80); - yylhsminor.yy80 = createRawExprNodeExt(pCxt, &s, &e, createBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-4].minor.yy80), releaseRawExprNode(pCxt, yymsp[-2].minor.yy80), releaseRawExprNode(pCxt, yymsp[0].minor.yy80))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy312); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy312); + yylhsminor.yy312 = createRawExprNodeExt(pCxt, &s, &e, createBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-4].minor.yy312), releaseRawExprNode(pCxt, yymsp[-2].minor.yy312), releaseRawExprNode(pCxt, yymsp[0].minor.yy312))); } - yymsp[-4].minor.yy80 = yylhsminor.yy80; + yymsp[-4].minor.yy312 = yylhsminor.yy312; break; - case 384: /* predicate ::= expression NOT BETWEEN expression AND expression */ + case 385: /* predicate ::= expression NOT BETWEEN expression AND expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy80); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy80); - yylhsminor.yy80 = createRawExprNodeExt(pCxt, &s, &e, createNotBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy80), releaseRawExprNode(pCxt, yymsp[-2].minor.yy80), releaseRawExprNode(pCxt, yymsp[0].minor.yy80))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy312); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy312); + yylhsminor.yy312 = createRawExprNodeExt(pCxt, &s, &e, createNotBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy312), releaseRawExprNode(pCxt, yymsp[-2].minor.yy312), releaseRawExprNode(pCxt, yymsp[0].minor.yy312))); } - yymsp[-5].minor.yy80 = yylhsminor.yy80; + yymsp[-5].minor.yy312 = yylhsminor.yy312; break; - case 385: /* predicate ::= expression IS NULL */ + case 386: /* predicate ::= expression IS NULL */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy80); - yylhsminor.yy80 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy80), NULL)); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy312); + yylhsminor.yy312 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy312), NULL)); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 386: /* predicate ::= expression IS NOT NULL */ + case 387: /* predicate ::= expression IS NOT NULL */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy80); - yylhsminor.yy80 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy80), NULL)); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy312); + yylhsminor.yy312 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy312), NULL)); } - yymsp[-3].minor.yy80 = yylhsminor.yy80; + yymsp[-3].minor.yy312 = yylhsminor.yy312; break; - case 388: /* compare_op ::= NK_LT */ -{ yymsp[0].minor.yy194 = OP_TYPE_LOWER_THAN; } + case 389: /* compare_op ::= NK_LT */ +{ yymsp[0].minor.yy320 = OP_TYPE_LOWER_THAN; } break; - case 389: /* compare_op ::= NK_GT */ -{ yymsp[0].minor.yy194 = OP_TYPE_GREATER_THAN; } + case 390: /* compare_op ::= NK_GT */ +{ yymsp[0].minor.yy320 = OP_TYPE_GREATER_THAN; } break; - case 390: /* compare_op ::= NK_LE */ -{ yymsp[0].minor.yy194 = OP_TYPE_LOWER_EQUAL; } + case 391: /* compare_op ::= NK_LE */ +{ yymsp[0].minor.yy320 = OP_TYPE_LOWER_EQUAL; } break; - case 391: /* compare_op ::= NK_GE */ -{ yymsp[0].minor.yy194 = OP_TYPE_GREATER_EQUAL; } + case 392: /* compare_op ::= NK_GE */ +{ yymsp[0].minor.yy320 = OP_TYPE_GREATER_EQUAL; } break; - case 392: /* compare_op ::= NK_NE */ -{ yymsp[0].minor.yy194 = OP_TYPE_NOT_EQUAL; } + case 393: /* compare_op ::= NK_NE */ +{ yymsp[0].minor.yy320 = OP_TYPE_NOT_EQUAL; } break; - case 393: /* compare_op ::= NK_EQ */ -{ yymsp[0].minor.yy194 = OP_TYPE_EQUAL; } + case 394: /* compare_op ::= NK_EQ */ +{ yymsp[0].minor.yy320 = OP_TYPE_EQUAL; } break; - case 394: /* compare_op ::= LIKE */ -{ yymsp[0].minor.yy194 = OP_TYPE_LIKE; } + case 395: /* compare_op ::= LIKE */ +{ yymsp[0].minor.yy320 = OP_TYPE_LIKE; } break; - case 395: /* compare_op ::= NOT LIKE */ -{ yymsp[-1].minor.yy194 = OP_TYPE_NOT_LIKE; } + case 396: /* compare_op ::= NOT LIKE */ +{ yymsp[-1].minor.yy320 = OP_TYPE_NOT_LIKE; } break; - case 396: /* compare_op ::= MATCH */ -{ yymsp[0].minor.yy194 = OP_TYPE_MATCH; } + case 397: /* compare_op ::= MATCH */ +{ yymsp[0].minor.yy320 = OP_TYPE_MATCH; } break; - case 397: /* compare_op ::= NMATCH */ -{ yymsp[0].minor.yy194 = OP_TYPE_NMATCH; } + case 398: /* compare_op ::= NMATCH */ +{ yymsp[0].minor.yy320 = OP_TYPE_NMATCH; } break; - case 398: /* compare_op ::= CONTAINS */ -{ yymsp[0].minor.yy194 = OP_TYPE_JSON_CONTAINS; } + case 399: /* compare_op ::= CONTAINS */ +{ yymsp[0].minor.yy320 = OP_TYPE_JSON_CONTAINS; } break; - case 399: /* in_op ::= IN */ -{ yymsp[0].minor.yy194 = OP_TYPE_IN; } + case 400: /* in_op ::= IN */ +{ yymsp[0].minor.yy320 = OP_TYPE_IN; } break; - case 400: /* in_op ::= NOT IN */ -{ yymsp[-1].minor.yy194 = OP_TYPE_NOT_IN; } + case 401: /* in_op ::= NOT IN */ +{ yymsp[-1].minor.yy320 = OP_TYPE_NOT_IN; } break; - case 401: /* in_predicate_value ::= NK_LP literal_list NK_RP */ -{ yylhsminor.yy80 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy574)); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 402: /* in_predicate_value ::= NK_LP literal_list NK_RP */ +{ yylhsminor.yy312 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy824)); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 403: /* boolean_value_expression ::= NOT boolean_primary */ + case 404: /* boolean_value_expression ::= NOT boolean_primary */ { - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy80); - yylhsminor.yy80 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy80), NULL)); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy312); + yylhsminor.yy312 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy312), NULL)); } - yymsp[-1].minor.yy80 = yylhsminor.yy80; + yymsp[-1].minor.yy312 = yylhsminor.yy312; break; - case 404: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ + case 405: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy80); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy80); - yylhsminor.yy80 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy80), releaseRawExprNode(pCxt, yymsp[0].minor.yy80))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy312); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy312); + yylhsminor.yy312 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy312), releaseRawExprNode(pCxt, yymsp[0].minor.yy312))); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 405: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ + case 406: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy80); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy80); - yylhsminor.yy80 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy80), releaseRawExprNode(pCxt, yymsp[0].minor.yy80))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy312); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy312); + yylhsminor.yy312 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy312), releaseRawExprNode(pCxt, yymsp[0].minor.yy312))); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 411: /* from_clause_opt ::= FROM table_reference_list */ - case 440: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==440); - case 463: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==463); -{ yymsp[-1].minor.yy80 = yymsp[0].minor.yy80; } + case 412: /* from_clause_opt ::= FROM table_reference_list */ + case 441: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==441); + case 464: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==464); +{ yymsp[-1].minor.yy312 = yymsp[0].minor.yy312; } break; - case 413: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */ -{ yylhsminor.yy80 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy80, yymsp[0].minor.yy80, NULL); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 414: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */ +{ yylhsminor.yy312 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy312, yymsp[0].minor.yy312, NULL); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 416: /* table_primary ::= table_name alias_opt */ -{ yylhsminor.yy80 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy239, &yymsp[0].minor.yy239); } - yymsp[-1].minor.yy80 = yylhsminor.yy80; + case 417: /* table_primary ::= table_name alias_opt */ +{ yylhsminor.yy312 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy149, &yymsp[0].minor.yy149); } + yymsp[-1].minor.yy312 = yylhsminor.yy312; break; - case 417: /* table_primary ::= db_name NK_DOT table_name alias_opt */ -{ yylhsminor.yy80 = createRealTableNode(pCxt, &yymsp[-3].minor.yy239, &yymsp[-1].minor.yy239, &yymsp[0].minor.yy239); } - yymsp[-3].minor.yy80 = yylhsminor.yy80; + case 418: /* table_primary ::= db_name NK_DOT table_name alias_opt */ +{ yylhsminor.yy312 = createRealTableNode(pCxt, &yymsp[-3].minor.yy149, &yymsp[-1].minor.yy149, &yymsp[0].minor.yy149); } + yymsp[-3].minor.yy312 = yylhsminor.yy312; break; - case 418: /* table_primary ::= subquery alias_opt */ -{ yylhsminor.yy80 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy80), &yymsp[0].minor.yy239); } - yymsp[-1].minor.yy80 = yylhsminor.yy80; + case 419: /* table_primary ::= subquery alias_opt */ +{ yylhsminor.yy312 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy312), &yymsp[0].minor.yy149); } + yymsp[-1].minor.yy312 = yylhsminor.yy312; break; - case 420: /* alias_opt ::= */ -{ yymsp[1].minor.yy239 = nil_token; } + case 421: /* alias_opt ::= */ +{ yymsp[1].minor.yy149 = nil_token; } break; - case 421: /* alias_opt ::= table_alias */ -{ yylhsminor.yy239 = yymsp[0].minor.yy239; } - yymsp[0].minor.yy239 = yylhsminor.yy239; + case 422: /* alias_opt ::= table_alias */ +{ yylhsminor.yy149 = yymsp[0].minor.yy149; } + yymsp[0].minor.yy149 = yylhsminor.yy149; break; - case 422: /* alias_opt ::= AS table_alias */ -{ yymsp[-1].minor.yy239 = yymsp[0].minor.yy239; } + case 423: /* alias_opt ::= AS table_alias */ +{ yymsp[-1].minor.yy149 = yymsp[0].minor.yy149; } break; - case 423: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - case 424: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==424); -{ yymsp[-2].minor.yy80 = yymsp[-1].minor.yy80; } + case 424: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */ + case 425: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==425); +{ yymsp[-2].minor.yy312 = yymsp[-1].minor.yy312; } break; - case 425: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ -{ yylhsminor.yy80 = createJoinTableNode(pCxt, yymsp[-4].minor.yy750, yymsp[-5].minor.yy80, yymsp[-2].minor.yy80, yymsp[0].minor.yy80); } - yymsp[-5].minor.yy80 = yylhsminor.yy80; + case 426: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ +{ yylhsminor.yy312 = createJoinTableNode(pCxt, yymsp[-4].minor.yy832, yymsp[-5].minor.yy312, yymsp[-2].minor.yy312, yymsp[0].minor.yy312); } + yymsp[-5].minor.yy312 = yylhsminor.yy312; break; - case 426: /* join_type ::= */ -{ yymsp[1].minor.yy750 = JOIN_TYPE_INNER; } + case 427: /* join_type ::= */ +{ yymsp[1].minor.yy832 = JOIN_TYPE_INNER; } break; - case 427: /* join_type ::= INNER */ -{ yymsp[0].minor.yy750 = JOIN_TYPE_INNER; } + case 428: /* join_type ::= INNER */ +{ yymsp[0].minor.yy832 = JOIN_TYPE_INNER; } break; - case 428: /* query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ + case 429: /* query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ { - yymsp[-11].minor.yy80 = createSelectStmt(pCxt, yymsp[-10].minor.yy845, yymsp[-9].minor.yy574, yymsp[-8].minor.yy80); - yymsp[-11].minor.yy80 = addWhereClause(pCxt, yymsp[-11].minor.yy80, yymsp[-7].minor.yy80); - yymsp[-11].minor.yy80 = addPartitionByClause(pCxt, yymsp[-11].minor.yy80, yymsp[-6].minor.yy574); - yymsp[-11].minor.yy80 = addWindowClauseClause(pCxt, yymsp[-11].minor.yy80, yymsp[-2].minor.yy80); - yymsp[-11].minor.yy80 = addGroupByClause(pCxt, yymsp[-11].minor.yy80, yymsp[-1].minor.yy574); - yymsp[-11].minor.yy80 = addHavingClause(pCxt, yymsp[-11].minor.yy80, yymsp[0].minor.yy80); - yymsp[-11].minor.yy80 = addRangeClause(pCxt, yymsp[-11].minor.yy80, yymsp[-5].minor.yy80); - yymsp[-11].minor.yy80 = addEveryClause(pCxt, yymsp[-11].minor.yy80, yymsp[-4].minor.yy80); - yymsp[-11].minor.yy80 = addFillClause(pCxt, yymsp[-11].minor.yy80, yymsp[-3].minor.yy80); + yymsp[-11].minor.yy312 = createSelectStmt(pCxt, yymsp[-10].minor.yy497, yymsp[-9].minor.yy824, yymsp[-8].minor.yy312); + yymsp[-11].minor.yy312 = addWhereClause(pCxt, yymsp[-11].minor.yy312, yymsp[-7].minor.yy312); + yymsp[-11].minor.yy312 = addPartitionByClause(pCxt, yymsp[-11].minor.yy312, yymsp[-6].minor.yy824); + yymsp[-11].minor.yy312 = addWindowClauseClause(pCxt, yymsp[-11].minor.yy312, yymsp[-2].minor.yy312); + yymsp[-11].minor.yy312 = addGroupByClause(pCxt, yymsp[-11].minor.yy312, yymsp[-1].minor.yy824); + yymsp[-11].minor.yy312 = addHavingClause(pCxt, yymsp[-11].minor.yy312, yymsp[0].minor.yy312); + yymsp[-11].minor.yy312 = addRangeClause(pCxt, yymsp[-11].minor.yy312, yymsp[-5].minor.yy312); + yymsp[-11].minor.yy312 = addEveryClause(pCxt, yymsp[-11].minor.yy312, yymsp[-4].minor.yy312); + yymsp[-11].minor.yy312 = addFillClause(pCxt, yymsp[-11].minor.yy312, yymsp[-3].minor.yy312); } break; - case 431: /* set_quantifier_opt ::= ALL */ -{ yymsp[0].minor.yy845 = false; } + case 432: /* set_quantifier_opt ::= ALL */ +{ yymsp[0].minor.yy497 = false; } break; - case 434: /* select_item ::= NK_STAR */ -{ yylhsminor.yy80 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy80 = yylhsminor.yy80; + case 435: /* select_item ::= NK_STAR */ +{ yylhsminor.yy312 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy312 = yylhsminor.yy312; break; - case 436: /* select_item ::= common_expression column_alias */ -{ yylhsminor.yy80 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy80), &yymsp[0].minor.yy239); } - yymsp[-1].minor.yy80 = yylhsminor.yy80; + case 437: /* select_item ::= common_expression column_alias */ +{ yylhsminor.yy312 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy312), &yymsp[0].minor.yy149); } + yymsp[-1].minor.yy312 = yylhsminor.yy312; break; - case 437: /* select_item ::= common_expression AS column_alias */ -{ yylhsminor.yy80 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy80), &yymsp[0].minor.yy239); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 438: /* select_item ::= common_expression AS column_alias */ +{ yylhsminor.yy312 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy312), &yymsp[0].minor.yy149); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 442: /* partition_by_clause_opt ::= PARTITION BY expression_list */ - case 459: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==459); - case 475: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==475); -{ yymsp[-2].minor.yy574 = yymsp[0].minor.yy574; } + case 443: /* partition_by_clause_opt ::= PARTITION BY expression_list */ + case 460: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==460); + case 476: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==476); +{ yymsp[-2].minor.yy824 = yymsp[0].minor.yy824; } break; - case 444: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ -{ yymsp[-5].minor.yy80 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy80), releaseRawExprNode(pCxt, yymsp[-1].minor.yy80)); } + case 445: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ +{ yymsp[-5].minor.yy312 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy312), releaseRawExprNode(pCxt, yymsp[-1].minor.yy312)); } break; - case 445: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */ -{ yymsp[-3].minor.yy80 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy80)); } + case 446: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */ +{ yymsp[-3].minor.yy312 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy312)); } break; - case 446: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ -{ yymsp[-5].minor.yy80 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy80), NULL, yymsp[-1].minor.yy80, yymsp[0].minor.yy80); } + case 447: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ +{ yymsp[-5].minor.yy312 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy312), NULL, yymsp[-1].minor.yy312, yymsp[0].minor.yy312); } break; - case 447: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ -{ yymsp[-7].minor.yy80 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy80), releaseRawExprNode(pCxt, yymsp[-3].minor.yy80), yymsp[-1].minor.yy80, yymsp[0].minor.yy80); } + case 448: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ +{ yymsp[-7].minor.yy312 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy312), releaseRawExprNode(pCxt, yymsp[-3].minor.yy312), yymsp[-1].minor.yy312, yymsp[0].minor.yy312); } break; - case 449: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ - case 467: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==467); -{ yymsp[-3].minor.yy80 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy80); } + case 450: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ + case 468: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==468); +{ yymsp[-3].minor.yy312 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy312); } break; - case 451: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ -{ yymsp[-3].minor.yy80 = createFillNode(pCxt, yymsp[-1].minor.yy426, NULL); } + case 452: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ +{ yymsp[-3].minor.yy312 = createFillNode(pCxt, yymsp[-1].minor.yy134, NULL); } break; - case 452: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ -{ yymsp[-5].minor.yy80 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy574)); } + case 453: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ +{ yymsp[-5].minor.yy312 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy824)); } break; - case 453: /* fill_mode ::= NONE */ -{ yymsp[0].minor.yy426 = FILL_MODE_NONE; } + case 454: /* fill_mode ::= NONE */ +{ yymsp[0].minor.yy134 = FILL_MODE_NONE; } break; - case 454: /* fill_mode ::= PREV */ -{ yymsp[0].minor.yy426 = FILL_MODE_PREV; } + case 455: /* fill_mode ::= PREV */ +{ yymsp[0].minor.yy134 = FILL_MODE_PREV; } break; - case 455: /* fill_mode ::= NULL */ -{ yymsp[0].minor.yy426 = FILL_MODE_NULL; } + case 456: /* fill_mode ::= NULL */ +{ yymsp[0].minor.yy134 = FILL_MODE_NULL; } break; - case 456: /* fill_mode ::= LINEAR */ -{ yymsp[0].minor.yy426 = FILL_MODE_LINEAR; } + case 457: /* fill_mode ::= LINEAR */ +{ yymsp[0].minor.yy134 = FILL_MODE_LINEAR; } break; - case 457: /* fill_mode ::= NEXT */ -{ yymsp[0].minor.yy426 = FILL_MODE_NEXT; } + case 458: /* fill_mode ::= NEXT */ +{ yymsp[0].minor.yy134 = FILL_MODE_NEXT; } break; - case 460: /* group_by_list ::= expression */ -{ yylhsminor.yy574 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy80))); } - yymsp[0].minor.yy574 = yylhsminor.yy574; + case 461: /* group_by_list ::= expression */ +{ yylhsminor.yy824 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy312))); } + yymsp[0].minor.yy824 = yylhsminor.yy824; break; - case 461: /* group_by_list ::= group_by_list NK_COMMA expression */ -{ yylhsminor.yy574 = addNodeToList(pCxt, yymsp[-2].minor.yy574, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy80))); } - yymsp[-2].minor.yy574 = yylhsminor.yy574; + case 462: /* group_by_list ::= group_by_list NK_COMMA expression */ +{ yylhsminor.yy824 = addNodeToList(pCxt, yymsp[-2].minor.yy824, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy312))); } + yymsp[-2].minor.yy824 = yylhsminor.yy824; break; - case 465: /* range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP */ -{ yymsp[-5].minor.yy80 = createInterpTimeRange(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy80), releaseRawExprNode(pCxt, yymsp[-1].minor.yy80)); } + case 466: /* range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP */ +{ yymsp[-5].minor.yy312 = createInterpTimeRange(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy312), releaseRawExprNode(pCxt, yymsp[-1].minor.yy312)); } break; - case 468: /* query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ + case 469: /* query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ { - yylhsminor.yy80 = addOrderByClause(pCxt, yymsp[-3].minor.yy80, yymsp[-2].minor.yy574); - yylhsminor.yy80 = addSlimitClause(pCxt, yylhsminor.yy80, yymsp[-1].minor.yy80); - yylhsminor.yy80 = addLimitClause(pCxt, yylhsminor.yy80, yymsp[0].minor.yy80); + yylhsminor.yy312 = addOrderByClause(pCxt, yymsp[-3].minor.yy312, yymsp[-2].minor.yy824); + yylhsminor.yy312 = addSlimitClause(pCxt, yylhsminor.yy312, yymsp[-1].minor.yy312); + yylhsminor.yy312 = addLimitClause(pCxt, yylhsminor.yy312, yymsp[0].minor.yy312); } - yymsp[-3].minor.yy80 = yylhsminor.yy80; + yymsp[-3].minor.yy312 = yylhsminor.yy312; break; - case 470: /* query_expression_body ::= query_expression_body UNION ALL query_expression_body */ -{ yylhsminor.yy80 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy80, yymsp[0].minor.yy80); } - yymsp[-3].minor.yy80 = yylhsminor.yy80; + case 471: /* query_expression_body ::= query_expression_body UNION ALL query_expression_body */ +{ yylhsminor.yy312 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy312, yymsp[0].minor.yy312); } + yymsp[-3].minor.yy312 = yylhsminor.yy312; break; - case 471: /* query_expression_body ::= query_expression_body UNION query_expression_body */ -{ yylhsminor.yy80 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy80, yymsp[0].minor.yy80); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 472: /* query_expression_body ::= query_expression_body UNION query_expression_body */ +{ yylhsminor.yy312 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy312, yymsp[0].minor.yy312); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 473: /* query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */ + case 474: /* query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */ { - yymsp[-5].minor.yy80 = addOrderByClause(pCxt, yymsp[-4].minor.yy80, yymsp[-3].minor.yy574); - yymsp[-5].minor.yy80 = addSlimitClause(pCxt, yymsp[-5].minor.yy80, yymsp[-2].minor.yy80); - yymsp[-5].minor.yy80 = addLimitClause(pCxt, yymsp[-5].minor.yy80, yymsp[-1].minor.yy80); + yymsp[-5].minor.yy312 = addOrderByClause(pCxt, yymsp[-4].minor.yy312, yymsp[-3].minor.yy824); + yymsp[-5].minor.yy312 = addSlimitClause(pCxt, yymsp[-5].minor.yy312, yymsp[-2].minor.yy312); + yymsp[-5].minor.yy312 = addLimitClause(pCxt, yymsp[-5].minor.yy312, yymsp[-1].minor.yy312); } break; - case 477: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ - case 481: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==481); -{ yymsp[-1].minor.yy80 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); } + case 478: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ + case 482: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==482); +{ yymsp[-1].minor.yy312 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); } break; - case 478: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - case 482: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==482); -{ yymsp[-3].minor.yy80 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } + case 479: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + case 483: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==483); +{ yymsp[-3].minor.yy312 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } break; - case 479: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - case 483: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==483); -{ yymsp[-3].minor.yy80 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); } + case 480: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + case 484: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==484); +{ yymsp[-3].minor.yy312 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); } break; - case 484: /* subquery ::= NK_LP query_expression NK_RP */ -{ yylhsminor.yy80 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy80); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 485: /* subquery ::= NK_LP query_expression NK_RP */ +{ yylhsminor.yy312 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy312); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 488: /* sort_specification ::= expression ordering_specification_opt null_ordering_opt */ -{ yylhsminor.yy80 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy80), yymsp[-1].minor.yy422, yymsp[0].minor.yy763); } - yymsp[-2].minor.yy80 = yylhsminor.yy80; + case 489: /* sort_specification ::= expression ordering_specification_opt null_ordering_opt */ +{ yylhsminor.yy312 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy312), yymsp[-1].minor.yy158, yymsp[0].minor.yy417); } + yymsp[-2].minor.yy312 = yylhsminor.yy312; break; - case 489: /* ordering_specification_opt ::= */ -{ yymsp[1].minor.yy422 = ORDER_ASC; } + case 490: /* ordering_specification_opt ::= */ +{ yymsp[1].minor.yy158 = ORDER_ASC; } break; - case 490: /* ordering_specification_opt ::= ASC */ -{ yymsp[0].minor.yy422 = ORDER_ASC; } + case 491: /* ordering_specification_opt ::= ASC */ +{ yymsp[0].minor.yy158 = ORDER_ASC; } break; - case 491: /* ordering_specification_opt ::= DESC */ -{ yymsp[0].minor.yy422 = ORDER_DESC; } + case 492: /* ordering_specification_opt ::= DESC */ +{ yymsp[0].minor.yy158 = ORDER_DESC; } break; - case 492: /* null_ordering_opt ::= */ -{ yymsp[1].minor.yy763 = NULL_ORDER_DEFAULT; } + case 493: /* null_ordering_opt ::= */ +{ yymsp[1].minor.yy417 = NULL_ORDER_DEFAULT; } break; - case 493: /* null_ordering_opt ::= NULLS FIRST */ -{ yymsp[-1].minor.yy763 = NULL_ORDER_FIRST; } + case 494: /* null_ordering_opt ::= NULLS FIRST */ +{ yymsp[-1].minor.yy417 = NULL_ORDER_FIRST; } break; - case 494: /* null_ordering_opt ::= NULLS LAST */ -{ yymsp[-1].minor.yy763 = NULL_ORDER_LAST; } + case 495: /* null_ordering_opt ::= NULLS LAST */ +{ yymsp[-1].minor.yy417 = NULL_ORDER_LAST; } break; default: break; diff --git a/source/libs/parser/test/parAlterToBalanceTest.cpp b/source/libs/parser/test/parAlterToBalanceTest.cpp index 871f28b9db..3a08ef9756 100644 --- a/source/libs/parser/test/parAlterToBalanceTest.cpp +++ b/source/libs/parser/test/parAlterToBalanceTest.cpp @@ -162,7 +162,7 @@ TEST_F(ParserInitialATest, alterDatabase) { setAlterDbWal(1); setAlterDbCacheModel(TSDB_CACHE_MODEL_LAST_ROW); setAlterDbSstTrigger(16); - run("ALTER DATABASE test CACHEMODEL 'last_row' CACHESIZE 32 WAL_FSYNC_PERIOD 200 KEEP 10 WAL_LEVEL 1 SST_TRIGGER 16"); + run("ALTER DATABASE test CACHEMODEL 'last_row' CACHESIZE 32 WAL_FSYNC_PERIOD 200 KEEP 10 WAL_LEVEL 1 STT_TRIGGER 16"); clearAlterDbReq(); initAlterDb("test"); @@ -236,8 +236,8 @@ TEST_F(ParserInitialATest, alterDatabaseSemanticCheck) { run("ALTER DATABASE test KEEP 1w", TSDB_CODE_PAR_INVALID_DB_OPTION); run("ALTER DATABASE test WAL_LEVEL 0", TSDB_CODE_PAR_INVALID_DB_OPTION); run("ALTER DATABASE test WAL_LEVEL 3", TSDB_CODE_PAR_INVALID_DB_OPTION); - run("ALTER DATABASE test SST_TRIGGER 0", TSDB_CODE_PAR_INVALID_DB_OPTION); - run("ALTER DATABASE test SST_TRIGGER 17", TSDB_CODE_PAR_INVALID_DB_OPTION); + run("ALTER DATABASE test STT_TRIGGER 0", TSDB_CODE_PAR_INVALID_DB_OPTION); + run("ALTER DATABASE test STT_TRIGGER 17", TSDB_CODE_PAR_INVALID_DB_OPTION); // Regardless of the specific sentence run("ALTER DATABASE db WAL_LEVEL 0 # td-14436", TSDB_CODE_PAR_SYNTAX_ERROR, PARSER_STAGE_PARSE); } diff --git a/source/libs/parser/test/parInitialCTest.cpp b/source/libs/parser/test/parInitialCTest.cpp index 28bcae53ef..a159d797fa 100644 --- a/source/libs/parser/test/parInitialCTest.cpp +++ b/source/libs/parser/test/parInitialCTest.cpp @@ -118,6 +118,7 @@ TEST_F(ParserInitialCTest, createDatabase) { expect.sstTrigger = TSDB_DEFAULT_SST_TRIGGER; expect.hashPrefix = TSDB_DEFAULT_HASH_PREFIX; expect.hashSuffix = TSDB_DEFAULT_HASH_SUFFIX; + expect.tsdbPageSize = TSDB_DEFAULT_TSDB_PAGESIZE; }; auto setDbBufferFunc = [&](int32_t buffer) { expect.buffer = buffer; }; @@ -161,6 +162,7 @@ TEST_F(ParserInitialCTest, createDatabase) { auto setDbSstTrigger = [&](int32_t sstTrigger) { expect.sstTrigger = sstTrigger; }; auto setDbHashPrefix = [&](int32_t hashPrefix) { expect.hashPrefix = hashPrefix; }; auto setDbHashSuffix = [&](int32_t hashSuffix) { expect.hashSuffix = hashSuffix; }; + auto setDbTsdbPageSize = [&](int32_t tsdbPageSize) { expect.tsdbPageSize = tsdbPageSize; }; setCheckDdlFunc([&](const SQuery* pQuery, ParserStage stage) { ASSERT_EQ(nodeType(pQuery->pRoot), QUERY_NODE_CREATE_DATABASE_STMT); @@ -194,6 +196,7 @@ TEST_F(ParserInitialCTest, createDatabase) { ASSERT_EQ(req.sstTrigger, expect.sstTrigger); ASSERT_EQ(req.hashPrefix, expect.hashPrefix); ASSERT_EQ(req.hashSuffix, expect.hashSuffix); + ASSERT_EQ(req.tsdbPageSize, expect.tsdbPageSize); ASSERT_EQ(req.ignoreExist, expect.ignoreExist); ASSERT_EQ(req.numOfRetensions, expect.numOfRetensions); if (expect.numOfRetensions > 0) { @@ -244,6 +247,7 @@ TEST_F(ParserInitialCTest, createDatabase) { setDbSstTrigger(16); setDbHashPrefix(3); setDbHashSuffix(4); + setDbTsdbPageSize(32); run("CREATE DATABASE IF NOT EXISTS wxy_db " "BUFFER 64 " "CACHEMODEL 'last_value' " @@ -268,9 +272,10 @@ TEST_F(ParserInitialCTest, createDatabase) { "WAL_RETENTION_SIZE -1 " "WAL_ROLL_PERIOD 10 " "WAL_SEGMENT_SIZE 20 " - "SST_TRIGGER 16 " - "TABLE_PREFIX 3" - "TABLE_SUFFIX 4"); + "STT_TRIGGER 16 " + "TABLE_PREFIX 3 " + "TABLE_SUFFIX 4 " + "TSDB_PAGESIZE 32"); clearCreateDbReq(); setCreateDbReqFunc("wxy_db", 1); From ce9fb842212cd74f1cb54b6c523ed3ffaa197d3b Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Tue, 13 Sep 2022 14:21:43 +0800 Subject: [PATCH 017/138] refact --- include/common/tdataformat.h | 43 ++++- source/common/src/tdataformat.c | 175 +++++++++++++++++- source/dnode/vnode/src/inc/tsdb.h | 26 --- source/dnode/vnode/src/tsdb/tsdbUtil.c | 244 +------------------------ 4 files changed, 210 insertions(+), 278 deletions(-) diff --git a/include/common/tdataformat.h b/include/common/tdataformat.h index df16f4f0ab..2edecc6199 100644 --- a/include/common/tdataformat.h +++ b/include/common/tdataformat.h @@ -36,8 +36,13 @@ typedef struct STSRow2 STSRow2; typedef struct STSRowBuilder STSRowBuilder; typedef struct STagVal STagVal; typedef struct STag STag; +typedef struct SColData SColData; -// bitmap +#define HAS_NONE ((int8_t)0x1) +#define HAS_NULL ((int8_t)0x2) +#define HAS_VALUE ((int8_t)0x4) + +// bitmap ================================ const static uint8_t BIT2_MAP[4][4] = {{0b00000000, 0b00000001, 0b00000010, 0}, {0b00000000, 0b00000100, 0b00001000, 2}, {0b00000000, 0b00010000, 0b00100000, 4}, @@ -51,21 +56,21 @@ const static uint8_t BIT2_MAP[4][4] = {{0b00000000, 0b00000001, 0b00000010, 0}, #define SET_BIT2(p, i, v) ((p)[(i) >> 2] = (p)[(i) >> 2] & N1(BIT2_MAP[(i)&3][3]) | BIT2_MAP[(i)&3][(v)]) #define GET_BIT2(p, i) (((p)[(i) >> 2] >> BIT2_MAP[(i)&3][3]) & ((uint8_t)3)) -// STSchema +// STSchema ================================ int32_t tTSchemaCreate(int32_t sver, SSchema *pSchema, int32_t nCols, STSchema **ppTSchema); void tTSchemaDestroy(STSchema *pTSchema); -// SValue +// SValue ================================ int32_t tPutValue(uint8_t *p, SValue *pValue, int8_t type); int32_t tGetValue(uint8_t *p, SValue *pValue, int8_t type); int tValueCmprFn(const SValue *pValue1, const SValue *pValue2, int8_t type); -// SColVal +// SColVal ================================ #define COL_VAL_NONE(CID, TYPE) ((SColVal){.cid = (CID), .type = (TYPE), .isNone = 1}) #define COL_VAL_NULL(CID, TYPE) ((SColVal){.cid = (CID), .type = (TYPE), .isNull = 1}) #define COL_VAL_VALUE(CID, TYPE, V) ((SColVal){.cid = (CID), .type = (TYPE), .value = (V)}) -// STSRow2 +// STSRow2 ================================ #define TSROW_LEN(PROW, V) tGetI32v((uint8_t *)(PROW)->data, (V) ? &(V) : NULL) #define TSROW_SVER(PROW, V) tGetI32v((PROW)->data + TSROW_LEN(PROW, NULL), (V) ? &(V) : NULL) @@ -77,7 +82,7 @@ int32_t tTSRowToArray(STSRow2 *pRow, STSchema *pTSchema, SArray **ppArray); int32_t tPutTSRow(uint8_t *p, STSRow2 *pRow); int32_t tGetTSRow(uint8_t *p, STSRow2 **ppRow); -// STSRowBuilder +// STSRowBuilder ================================ #define tsRowBuilderInit() ((STSRowBuilder){0}) #define tsRowBuilderClear(B) \ do { \ @@ -86,7 +91,7 @@ int32_t tGetTSRow(uint8_t *p, STSRow2 **ppRow); } \ } while (0) -// STag +// STag ================================ int32_t tTagNew(SArray *pArray, int32_t version, int8_t isJson, STag **ppTag); void tTagFree(STag *pTag); bool tTagIsJson(const void *pTag); @@ -100,7 +105,17 @@ void tTagSetCid(const STag *pTag, int16_t iTag, int16_t cid); void debugPrintSTag(STag *pTag, const char *tag, int32_t ln); // TODO: remove int32_t parseJsontoTagData(const char *json, SArray *pTagVals, STag **ppTag, void *pMsgBuf); -// STRUCT ================= +// SColData ================================ +void tColDataInit(SColData *pColData, int16_t cid, int8_t type, int8_t smaOn); +void tColDataReset(SColData *pColData); +void tColDataClear(void *ph); +int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal); +int32_t tColDataGetValue(SColData *pColData, int32_t iRow, SColVal *pColVal); +int32_t tColDataCopy(SColData *pColDataSrc, SColData *pColDataDest); +int32_t tPutColData(uint8_t *p, SColData *pColData); +int32_t tGetColData(uint8_t *p, SColData *pColData); + +// STRUCT ================================ struct STColumn { col_id_t colId; int8_t type; @@ -166,6 +181,18 @@ struct SColVal { SValue value; }; +struct SColData { + int16_t cid; + int8_t type; + int8_t smaOn; + int32_t nVal; + uint8_t flag; + uint8_t *pBitMap; + int32_t *aOffset; + int32_t nData; + uint8_t *pData; +}; + #pragma pack(push, 1) struct STagVal { // char colName[TSDB_COL_NAME_LEN]; // only used for tmq_get_meta diff --git a/source/common/src/tdataformat.c b/source/common/src/tdataformat.c index b40f449a05..48fb0bb5f4 100644 --- a/source/common/src/tdataformat.c +++ b/source/common/src/tdataformat.c @@ -15,6 +15,7 @@ #define _DEFAULT_SOURCE #include "tdataformat.h" +#include "tRealloc.h" #include "tcoding.h" #include "tdatablock.h" #include "tlog.h" @@ -1172,4 +1173,176 @@ STSchema *tdGetSchemaFromBuilder(STSchemaBuilder *pBuilder) { return pSchema; } -#endif \ No newline at end of file +#endif + +// SColData ======================================== +void tColDataInit(SColData *pColData, int16_t cid, int8_t type, int8_t smaOn) { + pColData->cid = cid; + pColData->type = type; + pColData->smaOn = smaOn; + tColDataReset(pColData); +} + +void tColDataReset(SColData *pColData) { + pColData->nVal = 0; + pColData->flag = 0; + pColData->nData = 0; +} + +void tColDataClear(void *ph) { + SColData *pColData = (SColData *)ph; + + tFree(pColData->pBitMap); + tFree((uint8_t *)pColData->aOffset); + tFree(pColData->pData); +} + +int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal) { + int32_t code = 0; + int64_t size; + SValue value = {0}; + SValue *pValue = &value; + + ASSERT(pColVal->cid == pColData->cid); + ASSERT(pColVal->type == pColData->type); + + // realloc bitmap + size = BIT2_SIZE(pColData->nVal + 1); + code = tRealloc(&pColData->pBitMap, size); + if (code) goto _exit; + if ((pColData->nVal & 3) == 0) { + pColData->pBitMap[pColData->nVal >> 2] = 0; + } + + // put value + if (pColVal->isNone) { + pColData->flag |= HAS_NONE; + SET_BIT2(pColData->pBitMap, pColData->nVal, 0); + } else if (pColVal->isNull) { + pColData->flag |= HAS_NULL; + SET_BIT2(pColData->pBitMap, pColData->nVal, 1); + } else { + pColData->flag |= HAS_VALUE; + SET_BIT2(pColData->pBitMap, pColData->nVal, 2); + pValue = &pColVal->value; + } + + if (IS_VAR_DATA_TYPE(pColData->type)) { + // offset + code = tRealloc((uint8_t **)&pColData->aOffset, sizeof(int32_t) * (pColData->nVal + 1)); + if (code) goto _exit; + pColData->aOffset[pColData->nVal] = pColData->nData; + + // value + if ((!pColVal->isNone) && (!pColVal->isNull)) { + code = tRealloc(&pColData->pData, pColData->nData + pColVal->value.nData); + if (code) goto _exit; + memcpy(pColData->pData + pColData->nData, pColVal->value.pData, pColVal->value.nData); + pColData->nData += pColVal->value.nData; + } + } else { + code = tRealloc(&pColData->pData, pColData->nData + tPutValue(NULL, pValue, pColVal->type)); + if (code) goto _exit; + pColData->nData += tPutValue(pColData->pData + pColData->nData, pValue, pColVal->type); + } + + pColData->nVal++; + +_exit: + return code; +} + +int32_t tColDataCopy(SColData *pColDataSrc, SColData *pColDataDest) { + int32_t code = 0; + int32_t size; + + ASSERT(pColDataSrc->nVal > 0); + ASSERT(pColDataDest->cid = pColDataSrc->cid); + ASSERT(pColDataDest->type = pColDataSrc->type); + + pColDataDest->smaOn = pColDataSrc->smaOn; + pColDataDest->nVal = pColDataSrc->nVal; + pColDataDest->flag = pColDataSrc->flag; + + // bitmap + if (pColDataSrc->flag != HAS_NONE && pColDataSrc->flag != HAS_NULL && pColDataSrc->flag != HAS_VALUE) { + size = BIT2_SIZE(pColDataSrc->nVal); + code = tRealloc(&pColDataDest->pBitMap, size); + if (code) goto _exit; + memcpy(pColDataDest->pBitMap, pColDataSrc->pBitMap, size); + } + + // offset + if (IS_VAR_DATA_TYPE(pColDataDest->type)) { + size = sizeof(int32_t) * pColDataSrc->nVal; + + code = tRealloc((uint8_t **)&pColDataDest->aOffset, size); + if (code) goto _exit; + + memcpy(pColDataDest->aOffset, pColDataSrc->aOffset, size); + } + + // value + pColDataDest->nData = pColDataSrc->nData; + code = tRealloc(&pColDataDest->pData, pColDataSrc->nData); + if (code) goto _exit; + memcpy(pColDataDest->pData, pColDataSrc->pData, pColDataDest->nData); + +_exit: + return code; +} + +int32_t tColDataGetValue(SColData *pColData, int32_t iVal, SColVal *pColVal) { + int32_t code = 0; + + ASSERT(iVal < pColData->nVal); + ASSERT(pColData->flag); + + if (pColData->flag == HAS_NONE) { + *pColVal = COL_VAL_NONE(pColData->cid, pColData->type); + goto _exit; + } else if (pColData->flag == HAS_NULL) { + *pColVal = COL_VAL_NULL(pColData->cid, pColData->type); + goto _exit; + } else if (pColData->flag != HAS_VALUE) { + uint8_t v = GET_BIT2(pColData->pBitMap, iVal); + if (v == 0) { + *pColVal = COL_VAL_NONE(pColData->cid, pColData->type); + goto _exit; + } else if (v == 1) { + *pColVal = COL_VAL_NULL(pColData->cid, pColData->type); + goto _exit; + } + } + + // get value + SValue value; + if (IS_VAR_DATA_TYPE(pColData->type)) { + if (iVal + 1 < pColData->nVal) { + value.nData = pColData->aOffset[iVal + 1] - pColData->aOffset[iVal]; + } else { + value.nData = pColData->nData - pColData->aOffset[iVal]; + } + + value.pData = pColData->pData + pColData->aOffset[iVal]; + } else { + tGetValue(pColData->pData + tDataTypes[pColData->type].bytes * iVal, &value, pColData->type); + } + *pColVal = COL_VAL_VALUE(pColData->cid, pColData->type, value); + +_exit: + return code; +} + +static FORCE_INLINE int32_t tColDataCmprFn(const void *p1, const void *p2) { + SColData *pColData1 = (SColData *)p1; + SColData *pColData2 = (SColData *)p2; + + if (pColData1->cid < pColData2->cid) { + return -1; + } else if (pColData1->cid > pColData2->cid) { + return 1; + } + + return 0; +} diff --git a/source/dnode/vnode/src/inc/tsdb.h b/source/dnode/vnode/src/inc/tsdb.h index a836fa2bc5..063b33f3a9 100644 --- a/source/dnode/vnode/src/inc/tsdb.h +++ b/source/dnode/vnode/src/inc/tsdb.h @@ -44,7 +44,6 @@ typedef struct SMapData SMapData; typedef struct SBlockIdx SBlockIdx; typedef struct SDataBlk SDataBlk; typedef struct SSttBlk SSttBlk; -typedef struct SColData SColData; typedef struct SDiskDataHdr SDiskDataHdr; typedef struct SBlockData SBlockData; typedef struct SDelFile SDelFile; @@ -71,10 +70,6 @@ typedef struct SLDataIter SLDataIter; #define TSDB_MAX_SUBBLOCKS 8 #define TSDB_FHDR_SIZE 512 -#define HAS_NONE ((int8_t)0x1) -#define HAS_NULL ((int8_t)0x2) -#define HAS_VALUE ((int8_t)0x4) - #define VERSION_MIN 0 #define VERSION_MAX INT64_MAX @@ -148,15 +143,6 @@ int32_t tPutBlockIdx(uint8_t *p, void *ph); int32_t tGetBlockIdx(uint8_t *p, void *ph); int32_t tCmprBlockIdx(void const *lhs, void const *rhs); int32_t tCmprBlockL(void const *lhs, void const *rhs); -// SColdata -void tColDataInit(SColData *pColData, int16_t cid, int8_t type, int8_t smaOn); -void tColDataReset(SColData *pColData); -void tColDataClear(void *ph); -int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal); -int32_t tColDataGetValue(SColData *pColData, int32_t iRow, SColVal *pColVal); -int32_t tColDataCopy(SColData *pColDataSrc, SColData *pColDataDest); -int32_t tPutColData(uint8_t *p, SColData *pColData); -int32_t tGetColData(uint8_t *p, SColData *pColData); // SBlockData #define tBlockDataFirstRow(PBLOCKDATA) tsdbRowFromBlockData(PBLOCKDATA, 0) #define tBlockDataLastRow(PBLOCKDATA) tsdbRowFromBlockData(PBLOCKDATA, (PBLOCKDATA)->nRow - 1) @@ -470,18 +456,6 @@ struct SSttBlk { SBlockInfo bInfo; }; -struct SColData { - int16_t cid; - int8_t type; - int8_t smaOn; - int32_t nVal; - uint8_t flag; - uint8_t *pBitMap; - int32_t *aOffset; - int32_t nData; - uint8_t *pData; -}; - // (SBlockData){.suid = 0, .uid = 0}: block data not initialized // (SBlockData){.suid = suid, .uid = uid}: block data for ONE child table int .data file // (SBlockData){.suid = suid, .uid = 0}: block data for N child tables int .last file diff --git a/source/dnode/vnode/src/tsdb/tsdbUtil.c b/source/dnode/vnode/src/tsdb/tsdbUtil.c index caeca45e01..1a109b2cf6 100644 --- a/source/dnode/vnode/src/tsdb/tsdbUtil.c +++ b/source/dnode/vnode/src/tsdb/tsdbUtil.c @@ -909,248 +909,6 @@ int32_t tsdbBuildDeleteSkyline(SArray *aDelData, int32_t sidx, int32_t eidx, SAr return code; } -// SColData ======================================== -void tColDataInit(SColData *pColData, int16_t cid, int8_t type, int8_t smaOn) { - pColData->cid = cid; - pColData->type = type; - pColData->smaOn = smaOn; - tColDataReset(pColData); -} - -void tColDataReset(SColData *pColData) { - pColData->nVal = 0; - pColData->flag = 0; - pColData->nData = 0; -} - -void tColDataClear(void *ph) { - SColData *pColData = (SColData *)ph; - - tFree(pColData->pBitMap); - tFree((uint8_t *)pColData->aOffset); - tFree(pColData->pData); -} - -int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal) { - int32_t code = 0; - int64_t size; - SValue value = {0}; - SValue *pValue = &value; - - ASSERT(pColVal->cid == pColData->cid); - ASSERT(pColVal->type == pColData->type); - - // realloc bitmap - size = BIT2_SIZE(pColData->nVal + 1); - code = tRealloc(&pColData->pBitMap, size); - if (code) goto _exit; - if ((pColData->nVal & 3) == 0) { - pColData->pBitMap[pColData->nVal >> 2] = 0; - } - - // put value - if (pColVal->isNone) { - pColData->flag |= HAS_NONE; - SET_BIT2(pColData->pBitMap, pColData->nVal, 0); - } else if (pColVal->isNull) { - pColData->flag |= HAS_NULL; - SET_BIT2(pColData->pBitMap, pColData->nVal, 1); - } else { - pColData->flag |= HAS_VALUE; - SET_BIT2(pColData->pBitMap, pColData->nVal, 2); - pValue = &pColVal->value; - } - - if (IS_VAR_DATA_TYPE(pColData->type)) { - // offset - code = tRealloc((uint8_t **)&pColData->aOffset, sizeof(int32_t) * (pColData->nVal + 1)); - if (code) goto _exit; - pColData->aOffset[pColData->nVal] = pColData->nData; - - // value - if ((!pColVal->isNone) && (!pColVal->isNull)) { - code = tRealloc(&pColData->pData, pColData->nData + pColVal->value.nData); - if (code) goto _exit; - memcpy(pColData->pData + pColData->nData, pColVal->value.pData, pColVal->value.nData); - pColData->nData += pColVal->value.nData; - } - } else { - code = tRealloc(&pColData->pData, pColData->nData + tPutValue(NULL, pValue, pColVal->type)); - if (code) goto _exit; - pColData->nData += tPutValue(pColData->pData + pColData->nData, pValue, pColVal->type); - } - - pColData->nVal++; - -_exit: - return code; -} - -int32_t tColDataCopy(SColData *pColDataSrc, SColData *pColDataDest) { - int32_t code = 0; - int32_t size; - - ASSERT(pColDataSrc->nVal > 0); - ASSERT(pColDataDest->cid = pColDataSrc->cid); - ASSERT(pColDataDest->type = pColDataSrc->type); - - pColDataDest->smaOn = pColDataSrc->smaOn; - pColDataDest->nVal = pColDataSrc->nVal; - pColDataDest->flag = pColDataSrc->flag; - - // bitmap - if (pColDataSrc->flag != HAS_NONE && pColDataSrc->flag != HAS_NULL && pColDataSrc->flag != HAS_VALUE) { - size = BIT2_SIZE(pColDataSrc->nVal); - code = tRealloc(&pColDataDest->pBitMap, size); - if (code) goto _exit; - memcpy(pColDataDest->pBitMap, pColDataSrc->pBitMap, size); - } - - // offset - if (IS_VAR_DATA_TYPE(pColDataDest->type)) { - size = sizeof(int32_t) * pColDataSrc->nVal; - - code = tRealloc((uint8_t **)&pColDataDest->aOffset, size); - if (code) goto _exit; - - memcpy(pColDataDest->aOffset, pColDataSrc->aOffset, size); - } - - // value - pColDataDest->nData = pColDataSrc->nData; - code = tRealloc(&pColDataDest->pData, pColDataSrc->nData); - if (code) goto _exit; - memcpy(pColDataDest->pData, pColDataSrc->pData, pColDataDest->nData); - -_exit: - return code; -} - -int32_t tColDataGetValue(SColData *pColData, int32_t iVal, SColVal *pColVal) { - int32_t code = 0; - - ASSERT(iVal < pColData->nVal); - ASSERT(pColData->flag); - - if (pColData->flag == HAS_NONE) { - *pColVal = COL_VAL_NONE(pColData->cid, pColData->type); - goto _exit; - } else if (pColData->flag == HAS_NULL) { - *pColVal = COL_VAL_NULL(pColData->cid, pColData->type); - goto _exit; - } else if (pColData->flag != HAS_VALUE) { - uint8_t v = GET_BIT2(pColData->pBitMap, iVal); - if (v == 0) { - *pColVal = COL_VAL_NONE(pColData->cid, pColData->type); - goto _exit; - } else if (v == 1) { - *pColVal = COL_VAL_NULL(pColData->cid, pColData->type); - goto _exit; - } - } - - // get value - SValue value; - if (IS_VAR_DATA_TYPE(pColData->type)) { - if (iVal + 1 < pColData->nVal) { - value.nData = pColData->aOffset[iVal + 1] - pColData->aOffset[iVal]; - } else { - value.nData = pColData->nData - pColData->aOffset[iVal]; - } - - value.pData = pColData->pData + pColData->aOffset[iVal]; - } else { - tGetValue(pColData->pData + tDataTypes[pColData->type].bytes * iVal, &value, pColData->type); - } - *pColVal = COL_VAL_VALUE(pColData->cid, pColData->type, value); - -_exit: - return code; -} - -int32_t tPutColData(uint8_t *p, SColData *pColData) { - int32_t n = 0; - - n += tPutI16v(p ? p + n : p, pColData->cid); - n += tPutI8(p ? p + n : p, pColData->type); - n += tPutI8(p ? p + n : p, pColData->smaOn); - n += tPutI32v(p ? p + n : p, pColData->nVal); - n += tPutU8(p ? p + n : p, pColData->flag); - - if (pColData->flag == HAS_NONE || pColData->flag == HAS_NULL) goto _exit; - if (pColData->flag != HAS_VALUE) { - // bitmap - - int32_t size = BIT2_SIZE(pColData->nVal); - if (p) { - memcpy(p + n, pColData->pBitMap, size); - } - n += size; - } - if (IS_VAR_DATA_TYPE(pColData->type)) { - // offset - - int32_t size = sizeof(int32_t) * pColData->nVal; - if (p) { - memcpy(p + n, pColData->aOffset, size); - } - n += size; - } - n += tPutI32v(p ? p + n : p, pColData->nData); - if (p) { - memcpy(p + n, pColData->pData, pColData->nData); - } - n += pColData->nData; - -_exit: - return n; -} - -int32_t tGetColData(uint8_t *p, SColData *pColData) { - int32_t n = 0; - - n += tGetI16v(p + n, &pColData->cid); - n += tGetI8(p + n, &pColData->type); - n += tGetI8(p + n, &pColData->smaOn); - n += tGetI32v(p + n, &pColData->nVal); - n += tGetU8(p + n, &pColData->flag); - - if (pColData->flag == HAS_NONE || pColData->flag == HAS_NULL) goto _exit; - if (pColData->flag != HAS_VALUE) { - // bitmap - - int32_t size = BIT2_SIZE(pColData->nVal); - pColData->pBitMap = p + n; - n += size; - } - if (IS_VAR_DATA_TYPE(pColData->type)) { - // offset - - int32_t size = sizeof(int32_t) * pColData->nVal; - pColData->aOffset = (int32_t *)(p + n); - n += size; - } - n += tGetI32v(p + n, &pColData->nData); - pColData->pData = p + n; - n += pColData->nData; - -_exit: - return n; -} - -static FORCE_INLINE int32_t tColDataCmprFn(const void *p1, const void *p2) { - SColData *pColData1 = (SColData *)p1; - SColData *pColData2 = (SColData *)p2; - - if (pColData1->cid < pColData2->cid) { - return -1; - } else if (pColData1->cid > pColData2->cid) { - return 1; - } - - return 0; -} - // SBlockData ====================================================== int32_t tBlockDataCreate(SBlockData *pBlockData) { int32_t code = 0; @@ -1501,7 +1259,7 @@ void tBlockDataGetColData(SBlockData *pBlockData, int16_t cid, SColData **ppColD while (lidx <= ridx) { int32_t midx = (lidx + ridx) / 2; SColData *pColData = tBlockDataGetColDataByIdx(pBlockData, midx); - int32_t c = tColDataCmprFn(pColData, &(SColData){.cid = cid}); + int32_t c = (pColData->cid == cid) ? 0 : ((pColData->cid > cid) ? 1 : -1); if (c == 0) { *ppColData = pColData; From e979129669abfc697fad9f1f92e75033b6808bfb Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Tue, 13 Sep 2022 14:30:51 +0800 Subject: [PATCH 018/138] enh: add err msg --- source/libs/catalog/src/ctgCache.c | 1 - 1 file changed, 1 deletion(-) diff --git a/source/libs/catalog/src/ctgCache.c b/source/libs/catalog/src/ctgCache.c index aa7db9c43e..ff672c0339 100644 --- a/source/libs/catalog/src/ctgCache.c +++ b/source/libs/catalog/src/ctgCache.c @@ -2001,7 +2001,6 @@ void ctgCleanupCacheQueue(void) { ctgDebug("process [%s] operation", gCtgCacheOperation[op->opId].name); (*gCtgCacheOperation[op->opId].func)(op); stopQueue = true; - taosMemoryFree(op->data); CTG_RT_STAT_INC(numOfOpDequeue, 1); } else { taosMemoryFree(op->data); From ff93a4c3a443396a366607bbb785820b34639120 Mon Sep 17 00:00:00 2001 From: wangmm0220 Date: Tue, 13 Sep 2022 14:36:56 +0800 Subject: [PATCH 019/138] feat: support ttl in create table automatic --- source/libs/parser/src/parInsert.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/source/libs/parser/src/parInsert.c b/source/libs/parser/src/parInsert.c index 162161b67a..74bc68f89e 100644 --- a/source/libs/parser/src/parInsert.c +++ b/source/libs/parser/src/parInsert.c @@ -1134,6 +1134,9 @@ static int32_t parseTableOptions(SInsertParseContext* pCxt) { return buildSyntaxErrMsg(&pCxt->msg, "Invalid option ttl", sToken.z); } pCxt->createTblReq.ttl = taosStr2Int32(sToken.z, NULL, 10); + if (pCxt->createTblReq.ttl < 0) { + return buildSyntaxErrMsg(&pCxt->msg, "Invalid option ttl", sToken.z); + } } else if (TK_COMMENT == sToken.type) { pCxt->pSql += index; NEXT_TOKEN(pCxt->pSql, sToken); From d9ce8e3fcdf6e260671268b0e059ed28cc45f1b9 Mon Sep 17 00:00:00 2001 From: Minglei Jin Date: Tue, 13 Sep 2022 14:42:51 +0800 Subject: [PATCH 020/138] fix: c is uninitialized for empty btree --- source/dnode/vnode/src/meta/metaTable.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/dnode/vnode/src/meta/metaTable.c b/source/dnode/vnode/src/meta/metaTable.c index 92cf90d328..2d516c18e5 100644 --- a/source/dnode/vnode/src/meta/metaTable.c +++ b/source/dnode/vnode/src/meta/metaTable.c @@ -309,7 +309,7 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { int64_t oversion; SDecoder dc = {0}; int32_t ret; - int32_t c; + int32_t c = -2; tdbTbcOpen(pMeta->pUidIdx, &pUidIdxc, &pMeta->txn); ret = tdbTbcMoveTo(pUidIdxc, &pReq->suid, sizeof(tb_uid_t), &c); From 0fc81c7d84f4f7bc96d477bc84b4f1811a2d9b52 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Tue, 13 Sep 2022 14:52:31 +0800 Subject: [PATCH 021/138] refact code --- include/common/tdataformat.h | 2 +- source/common/src/tdataformat.c | 22 ++++++++++------------ source/dnode/vnode/src/tsdb/tsdbUtil.c | 2 +- 3 files changed, 12 insertions(+), 14 deletions(-) diff --git a/include/common/tdataformat.h b/include/common/tdataformat.h index 2edecc6199..4e5ecd90dc 100644 --- a/include/common/tdataformat.h +++ b/include/common/tdataformat.h @@ -108,7 +108,7 @@ int32_t parseJsontoTagData(const char *json, SArray *pTagVals, STag **ppTag, voi // SColData ================================ void tColDataInit(SColData *pColData, int16_t cid, int8_t type, int8_t smaOn); void tColDataReset(SColData *pColData); -void tColDataClear(void *ph); +void tColDataDestroy(void *ph); int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal); int32_t tColDataGetValue(SColData *pColData, int32_t iRow, SColVal *pColVal); int32_t tColDataCopy(SColData *pColDataSrc, SColData *pColDataDest); diff --git a/source/common/src/tdataformat.c b/source/common/src/tdataformat.c index 48fb0bb5f4..88f0777f57 100644 --- a/source/common/src/tdataformat.c +++ b/source/common/src/tdataformat.c @@ -681,7 +681,7 @@ int32_t tGetTSRow(uint8_t *p, STSRow2 **ppRow) { return n; } -// STSchema +// STSchema ======================================== int32_t tTSchemaCreate(int32_t sver, SSchema *pSchema, int32_t ncols, STSchema **ppTSchema) { *ppTSchema = (STSchema *)taosMemoryMalloc(sizeof(STSchema) + sizeof(STColumn) * ncols); if (*ppTSchema == NULL) { @@ -721,9 +721,7 @@ void tTSchemaDestroy(STSchema *pTSchema) { if (pTSchema) taosMemoryFree(pTSchema); } -// STSRowBuilder - -// STag +// STag ======================================== static int tTagValCmprFn(const void *p1, const void *p2) { if (((STagVal *)p1)->cid < ((STagVal *)p2)->cid) { return -1; @@ -1176,6 +1174,14 @@ STSchema *tdGetSchemaFromBuilder(STSchemaBuilder *pBuilder) { #endif // SColData ======================================== +void tColDataDestroy(void *ph) { + SColData *pColData = (SColData *)ph; + + tFree(pColData->pBitMap); + tFree((uint8_t *)pColData->aOffset); + tFree(pColData->pData); +} + void tColDataInit(SColData *pColData, int16_t cid, int8_t type, int8_t smaOn) { pColData->cid = cid; pColData->type = type; @@ -1189,14 +1195,6 @@ void tColDataReset(SColData *pColData) { pColData->nData = 0; } -void tColDataClear(void *ph) { - SColData *pColData = (SColData *)ph; - - tFree(pColData->pBitMap); - tFree((uint8_t *)pColData->aOffset); - tFree(pColData->pData); -} - int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal) { int32_t code = 0; int64_t size; diff --git a/source/dnode/vnode/src/tsdb/tsdbUtil.c b/source/dnode/vnode/src/tsdb/tsdbUtil.c index 1a109b2cf6..0a78085db2 100644 --- a/source/dnode/vnode/src/tsdb/tsdbUtil.c +++ b/source/dnode/vnode/src/tsdb/tsdbUtil.c @@ -940,7 +940,7 @@ void tBlockDataDestroy(SBlockData *pBlockData, int8_t deepClear) { tFree((uint8_t *)pBlockData->aVersion); tFree((uint8_t *)pBlockData->aTSKEY); taosArrayDestroy(pBlockData->aIdx); - taosArrayDestroyEx(pBlockData->aColData, deepClear ? tColDataClear : NULL); + taosArrayDestroyEx(pBlockData->aColData, deepClear ? tColDataDestroy : NULL); pBlockData->aUid = NULL; pBlockData->aVersion = NULL; pBlockData->aTSKEY = NULL; From 4fa07fef33e8bea392101dcaef52305999aaf6d9 Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Tue, 13 Sep 2022 15:01:55 +0800 Subject: [PATCH 022/138] fix: ctg mem leak --- source/libs/catalog/src/ctgCache.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/libs/catalog/src/ctgCache.c b/source/libs/catalog/src/ctgCache.c index ff672c0339..3a774afdcc 100644 --- a/source/libs/catalog/src/ctgCache.c +++ b/source/libs/catalog/src/ctgCache.c @@ -1710,13 +1710,13 @@ int32_t ctgOpDropStbMeta(SCtgCacheOperation *operation) { SCtgDBCache *dbCache = NULL; ctgGetDBCache(pCtg, msg->dbFName, &dbCache); if (NULL == dbCache) { - return TSDB_CODE_SUCCESS; + goto _return; } if (msg->dbId && (dbCache->dbId != msg->dbId)) { ctgDebug("dbId already modified, dbFName:%s, current:0x%" PRIx64 ", dbId:0x%" PRIx64 ", stb:%s, suid:0x%" PRIx64, msg->dbFName, dbCache->dbId, msg->dbId, msg->stbName, msg->suid); - return TSDB_CODE_SUCCESS; + goto _return; } if (taosHashRemove(dbCache->stbCache, &msg->suid, sizeof(msg->suid))) { From f40d838fe7c52a4cf86abf6389515679b044f509 Mon Sep 17 00:00:00 2001 From: Xiaoyu Wang Date: Tue, 13 Sep 2022 15:07:31 +0800 Subject: [PATCH 023/138] enh: add binary serialization method to node structure --- source/libs/nodes/src/nodesMsgFuncs.c | 13 ++++++++++--- source/libs/planner/test/planTestUtil.cpp | 6 +++++- 2 files changed, 15 insertions(+), 4 deletions(-) diff --git a/source/libs/nodes/src/nodesMsgFuncs.c b/source/libs/nodes/src/nodesMsgFuncs.c index af32913f47..7e2aa76404 100644 --- a/source/libs/nodes/src/nodesMsgFuncs.c +++ b/source/libs/nodes/src/nodesMsgFuncs.c @@ -24,7 +24,7 @@ typedef struct STlv { int16_t type; - int16_t len; + int32_t len; char value[0]; } STlv; @@ -70,7 +70,7 @@ static void endTlvEncode(STlvEncoder* pEncoder, char** pMsg, int32_t* pLen) { // nodesWarn("encode tlv count = %d, tl size = %d", pEncoder->tlvCount, sizeof(STlv) * pEncoder->tlvCount); } -static int32_t tlvEncodeImpl(STlvEncoder* pEncoder, int16_t type, const void* pValue, int16_t len) { +static int32_t tlvEncodeImpl(STlvEncoder* pEncoder, int16_t type, const void* pValue, int32_t len) { int32_t tlvLen = sizeof(STlv) + len; if (pEncoder->offset + tlvLen > pEncoder->allocSize) { void* pNewBuf = taosMemoryRealloc(pEncoder->pBuf, pEncoder->allocSize * 2); @@ -187,7 +187,7 @@ static int32_t tlvGetNextTlv(STlvDecoder* pDecoder, STlv** pTlv) { static bool tlvDecodeEnd(STlvDecoder* pDecoder) { return pDecoder->offset == pDecoder->bufSize; } -static int32_t tlvDecodeImpl(STlv* pTlv, void* pValue, int16_t len) { +static int32_t tlvDecodeImpl(STlv* pTlv, void* pValue, int32_t len) { if (pTlv->len != len) { return TSDB_CODE_FAILED; } @@ -710,6 +710,7 @@ static int32_t msgToLogicConditionNode(STlvDecoder* pDecoder, void* pObj) { enum { FUNCTION_CODE_EXPR_BASE = 1, + FUNCTION_CODE_FUNCTION_NAME, FUNCTION_CODE_FUNCTION_ID, FUNCTION_CODE_FUNCTION_TYPE, FUNCTION_CODE_PARAMETERS, @@ -720,6 +721,9 @@ static int32_t functionNodeToMsg(const void* pObj, STlvEncoder* pEncoder) { const SFunctionNode* pNode = (const SFunctionNode*)pObj; int32_t code = tlvEncodeObj(pEncoder, FUNCTION_CODE_EXPR_BASE, exprNodeToMsg, pNode); + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeCStr(pEncoder, FUNCTION_CODE_FUNCTION_NAME, pNode->functionName); + } if (TSDB_CODE_SUCCESS == code) { code = tlvEncodeI32(pEncoder, FUNCTION_CODE_FUNCTION_ID, pNode->funcId); } @@ -746,6 +750,9 @@ static int32_t msgToFunctionNode(STlvDecoder* pDecoder, void* pObj) { case FUNCTION_CODE_EXPR_BASE: code = tlvDecodeObjFromTlv(pTlv, msgToExprNode, &pNode->node); break; + case FUNCTION_CODE_FUNCTION_NAME: + code = tlvDecodeCStr(pTlv, pNode->functionName); + break; case FUNCTION_CODE_FUNCTION_ID: code = tlvDecodeI32(pTlv, &pNode->funcId); break; diff --git a/source/libs/planner/test/planTestUtil.cpp b/source/libs/planner/test/planTestUtil.cpp index b280b32a94..47fa8a68dd 100644 --- a/source/libs/planner/test/planTestUtil.cpp +++ b/source/libs/planner/test/planTestUtil.cpp @@ -480,8 +480,12 @@ class PlannerTestBaseImpl { DO_WITH_THROW(nodesNodeToMsg, pNode, &pNewStr, &newlen) if (newlen != len || 0 != memcmp(pStr, pNewStr, len)) { cout << "nodesNodeToMsg error!!!!!!!!!!!!!! len = " << len << ", newlen = " << newlen << endl; + taosMemoryFreeClear(pNewStr); + DO_WITH_THROW(nodesNodeToString, pRoot, false, &pNewStr, &newlen) + cout << "orac node: " << pNewStr << endl; + taosMemoryFreeClear(pNewStr); DO_WITH_THROW(nodesNodeToString, pNode, false, &pNewStr, &newlen) - cout << "nodesNodeToString " << pNewStr << endl; + cout << "new node: " << pNewStr << endl; } taosMemoryFreeClear(pNewStr); From b8a7c8b2aa4784a1a677c91a14574306c0b948d2 Mon Sep 17 00:00:00 2001 From: Liu Jicong Date: Tue, 13 Sep 2022 14:10:06 +0800 Subject: [PATCH 024/138] feat(stream): support hash suffix and prefix --- source/libs/executor/src/executorimpl.c | 16 ++++++++++------ source/libs/executor/src/timewindowoperator.c | 2 +- source/libs/stream/src/streamDispatch.c | 7 +++++-- 3 files changed, 16 insertions(+), 9 deletions(-) diff --git a/source/libs/executor/src/executorimpl.c b/source/libs/executor/src/executorimpl.c index 815d6a71ef..17954178b1 100644 --- a/source/libs/executor/src/executorimpl.c +++ b/source/libs/executor/src/executorimpl.c @@ -3445,8 +3445,7 @@ static bool isWstartColumnExist(SFillOperatorInfo* pInfo) { } for (int32_t i = 0; i < pInfo->numOfNotFillExpr; ++i) { SExprInfo* exprInfo = pInfo->pNotFillExprInfo + i; - if (exprInfo->pExpr->nodeType == QUERY_NODE_COLUMN && - exprInfo->base.numOfParams == 1 && + if (exprInfo->pExpr->nodeType == QUERY_NODE_COLUMN && exprInfo->base.numOfParams == 1 && exprInfo->base.pParam[0].pCol->colType == COLUMN_TYPE_WINDOW_START) { return true; } @@ -3462,7 +3461,8 @@ static int32_t createWStartTsAsNotFillExpr(SFillOperatorInfo* pInfo, SFillPhysiN return TSDB_CODE_QRY_SYS_ERROR; } - SExprInfo* notFillExprs = taosMemoryRealloc(pInfo->pNotFillExprInfo, (pInfo->numOfNotFillExpr + 1) * sizeof(SExprInfo)); + SExprInfo* notFillExprs = + taosMemoryRealloc(pInfo->pNotFillExprInfo, (pInfo->numOfNotFillExpr + 1) * sizeof(SExprInfo)); if (notFillExprs == NULL) { return TSDB_CODE_OUT_OF_MEMORY; } @@ -3473,7 +3473,7 @@ static int32_t createWStartTsAsNotFillExpr(SFillOperatorInfo* pInfo, SFillPhysiN pInfo->pNotFillExprInfo = notFillExprs; return TSDB_CODE_SUCCESS; } - + return TSDB_CODE_SUCCESS; } @@ -3513,8 +3513,8 @@ SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* &numOfOutputCols, COL_MATCH_FROM_SLOT_ID); code = initFillInfo(pInfo, pExprInfo, pInfo->numOfExpr, pInfo->pNotFillExprInfo, pInfo->numOfNotFillExpr, - (SNodeListNode*)pPhyFillNode->pValues, pPhyFillNode->timeRange, pResultInfo->capacity, - pTaskInfo->id.str, pInterval, type, order); + (SNodeListNode*)pPhyFillNode->pValues, pPhyFillNode->timeRange, pResultInfo->capacity, + pTaskInfo->id.str, pInterval, type, order); if (code != TSDB_CODE_SUCCESS) { goto _error; } @@ -4461,6 +4461,9 @@ int32_t setOutputBuf(STimeWindow* win, SResultRow** pResult, int64_t tableGroupI }; char* value = NULL; int32_t size = pAggSup->resultRowSize; + /*if (streamStateGet(pTaskInfo->streamInfo.pState, &key, (void**)&value, &size) < 0) {*/ + /*value = taosMemoryCalloc(1, size);*/ + /*}*/ if (streamStateAddIfNotExist(pTaskInfo->streamInfo.pState, &key, (void**)&value, &size) < 0) { return TSDB_CODE_QRY_OUT_OF_MEMORY; } @@ -4474,6 +4477,7 @@ int32_t setOutputBuf(STimeWindow* win, SResultRow** pResult, int64_t tableGroupI int32_t releaseOutputBuf(SExecTaskInfo* pTaskInfo, SWinKey* pKey, SResultRow* pResult) { streamStateReleaseBuf(pTaskInfo->streamInfo.pState, pKey, pResult); + /*taosMemoryFree((*(void**)pResult));*/ return TSDB_CODE_SUCCESS; } diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c index b3a85807ae..a19b6f8179 100644 --- a/source/libs/executor/src/timewindowoperator.c +++ b/source/libs/executor/src/timewindowoperator.c @@ -5704,7 +5704,7 @@ static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) { maxTs = TMAX(maxTs, pBlock->info.window.ekey); doStreamIntervalAggImpl(pOperator, &pInfo->binfo.resultRowInfo, pBlock, MAIN_SCAN, pUpdatedMap); // new disc buf - // doStreamIntervalAggImpl2(pOperator, pBlock, pBlock->info.groupId, pUpdatedMap); + /*doStreamIntervalAggImpl2(pOperator, pBlock, pBlock->info.groupId, pUpdatedMap);*/ } pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, maxTs); diff --git a/source/libs/stream/src/streamDispatch.c b/source/libs/stream/src/streamDispatch.c index a2a45938e4..7cdb7c0db9 100644 --- a/source/libs/stream/src/streamDispatch.c +++ b/source/libs/stream/src/streamDispatch.c @@ -248,9 +248,12 @@ int32_t streamSearchAndAddBlock(SStreamTask* pTask, SStreamDispatchReq* pReqs, S char* ctbName = buildCtbNameByGroupId(pTask->shuffleDispatcher.stbFullName, groupId); SArray* vgInfo = pTask->shuffleDispatcher.dbInfo.pVgroupInfos; - // TODO: get hash function by hashMethod - uint32_t hashValue = MurmurHash3_32(ctbName, strlen(ctbName)); + /*uint32_t hashValue = MurmurHash3_32(ctbName, strlen(ctbName));*/ + SUseDbRsp* pDbInfo = &pTask->shuffleDispatcher.dbInfo; + uint32_t hashValue = + taosGetTbHashVal(ctbName, strlen(ctbName), pDbInfo->hashMethod, pDbInfo->hashPrefix, pDbInfo->hashSuffix); taosMemoryFree(ctbName); + bool found = false; // TODO: optimize search int32_t j; From 9e5e8d9969940c1846975426804845ed5b6f465f Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Tue, 13 Sep 2022 15:23:45 +0800 Subject: [PATCH 025/138] more code --- source/common/src/tdataformat.c | 120 ++++++++++++++++++++++++++++++++ 1 file changed, 120 insertions(+) diff --git a/source/common/src/tdataformat.c b/source/common/src/tdataformat.c index 88f0777f57..ec20baa024 100644 --- a/source/common/src/tdataformat.c +++ b/source/common/src/tdataformat.c @@ -1174,6 +1174,126 @@ STSchema *tdGetSchemaFromBuilder(STSchemaBuilder *pBuilder) { #endif // SColData ======================================== +static FORCE_INLINE int32_t tColDataPutValue(SColData *pColData, SColVal *pColVal) { + int32_t code = 0; + + if (IS_VAR_DATA_TYPE(pColData->type)) { + code = tRealloc((uint8_t **)(&pColData->aOffset), sizeof(int32_t) * (pColData->nVal + 1)); + if (code) goto _exit; + pColData->aOffset[pColData->nVal] = pColData->nData; + + // value + if ((!pColVal->isNone) && (!pColVal->isNull)) { + code = tRealloc(&pColData->pData, pColData->nData + pColVal->value.nData); + if (code) goto _exit; + memcpy(pColData->pData + pColData->nData, pColVal->value.pData, pColVal->value.nData); + pColData->nData += pColVal->value.nData; + } + } else { + code = tRealloc(&pColData->pData, pColData->nData + tDataTypes[pColData->type].bytes); + if (code) goto _exit; + pColData->nData += tPutValue(pColData->pData + pColData->nData, &pColVal->value, pColVal->type); + } + +_exit: + return code; +} +static FORCE_INLINE int32_t tColDataAppendValue0(SColData *pColData, SColVal *pColVal) { + int32_t code = 0; + + if (pColVal->isNone) { + pColData->flag = HAS_NONE; + } else if (pColVal->isNull) { + pColData->flag = HAS_NULL; + } else { + pColData->flag = HAS_VALUE; + code = tColDataPutValue(pColData, pColVal); + if (code) goto _exit; + } + pColData->nVal++; + +_exit: + return code; +} +static FORCE_INLINE int32_t tColDataAppendValue1(SColData *pColData, SColVal *pColVal) { // HAS_NONE + int32_t code = 0; + + if (pColVal->isNone) { + } else if (pColVal->isNull) { + } else { + } + pColData->nVal++; + + return code; +} +static FORCE_INLINE int32_t tColDataAppendValue2(SColData *pColData, SColVal *pColVal) { // HAS_NULL + int32_t code = 0; + + if (pColVal->isNone) { + } else if (pColVal->isNull) { + } else { + } + pColData->nVal++; + + return code; +} +static FORCE_INLINE int32_t tColDataAppendValue3(SColData *pColData, SColVal *pColVal) { // HAS_NONE | HAS_NULL + int32_t code = 0; + + if (pColVal->isNone) { + } else if (pColVal->isNull) { + } else { + } + pColData->nVal++; + + return code; +} +static FORCE_INLINE int32_t tColDataAppendValue4(SColData *pColData, SColVal *pColVal) { // HAS_VALUE + int32_t code = 0; + + if (pColVal->isNone) { + } else if (pColVal->isNull) { + } else { + } + pColData->nVal++; + + return code; +} +static FORCE_INLINE int32_t tColDataAppendValue5(SColData *pColData, SColVal *pColVal) { // HAS_VALUE | HAS_NONE + int32_t code = 0; + + if (pColVal->isNone) { + } else if (pColVal->isNull) { + } else { + } + pColData->nVal++; + + return code; +} +static FORCE_INLINE int32_t tColDataAppendValue6(SColData *pColData, SColVal *pColVal) { // HAS_VALUE | HAS_NULL + int32_t code = 0; + + if (pColVal->isNone) { + } else if (pColVal->isNull) { + } else { + } + pColData->nVal++; + + return code; +} +static FORCE_INLINE int32_t tColDataAppendValue7(SColData *pColData, + SColVal *pColVal) { // HAS_VALUE | HAS_NULL | HAS_NONE + int32_t code = 0; + + if (pColVal->isNone) { + } else if (pColVal->isNull) { + } else { + } + pColData->nVal++; + + return code; +} + void tColDataDestroy(void *ph) { SColData *pColData = (SColData *)ph; From 82fcd22107f4ae589a45cfe30fb0e8815494c3b6 Mon Sep 17 00:00:00 2001 From: Xiaoyu Wang Date: Tue, 13 Sep 2022 15:57:17 +0800 Subject: [PATCH 026/138] enh: add binary serialization method to node structure --- source/libs/nodes/src/nodesMsgFuncs.c | 13 ++++++++++++- source/libs/planner/test/planTestUtil.cpp | 1 + 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/source/libs/nodes/src/nodesMsgFuncs.c b/source/libs/nodes/src/nodesMsgFuncs.c index 7e2aa76404..b72cb694d2 100644 --- a/source/libs/nodes/src/nodesMsgFuncs.c +++ b/source/libs/nodes/src/nodesMsgFuncs.c @@ -237,6 +237,11 @@ static int32_t tlvDecodeCStr(STlv* pTlv, char* pValue) { return TSDB_CODE_SUCCESS; } +static int32_t tlvDecodeCStrP(STlv* pTlv, char** pValue) { + *pValue = strndup(pTlv->value, pTlv->len); + return NULL == *pValue ? TSDB_CODE_OUT_OF_MEMORY : TSDB_CODE_SUCCESS; +} + static int32_t tlvDecodeDynBinary(STlv* pTlv, void** pValue) { *pValue = taosMemoryMalloc(pTlv->len); if (NULL == *pValue) { @@ -461,7 +466,7 @@ static int32_t msgToColumnNode(STlvDecoder* pDecoder, void* pObj) { return code; } -enum { VALUE_CODE_EXPR_BASE = 1, VALUE_CODE_IS_NULL, VALUE_CODE_DATUM }; +enum { VALUE_CODE_EXPR_BASE = 1, VALUE_CODE_LITERAL, VALUE_CODE_IS_NULL, VALUE_CODE_DATUM }; static int32_t datumToMsg(const void* pObj, STlvEncoder* pEncoder) { const SValueNode* pNode = (const SValueNode*)pObj; @@ -512,6 +517,9 @@ static int32_t valueNodeToMsg(const void* pObj, STlvEncoder* pEncoder) { const SValueNode* pNode = (const SValueNode*)pObj; int32_t code = tlvEncodeObj(pEncoder, VALUE_CODE_EXPR_BASE, exprNodeToMsg, pNode); + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeCStr(pEncoder, VALUE_CODE_LITERAL, pNode->literal); + } if (TSDB_CODE_SUCCESS == code) { code = tlvEncodeBool(pEncoder, VALUE_CODE_IS_NULL, pNode->isNull); } @@ -608,6 +616,9 @@ static int32_t msgToValueNode(STlvDecoder* pDecoder, void* pObj) { case VALUE_CODE_EXPR_BASE: code = tlvDecodeObjFromTlv(pTlv, msgToExprNode, &pNode->node); break; + case VALUE_CODE_LITERAL: + code = tlvDecodeCStrP(pTlv, &pNode->literal); + break; case VALUE_CODE_IS_NULL: code = tlvDecodeBool(pTlv, &pNode->isNull); break; diff --git a/source/libs/planner/test/planTestUtil.cpp b/source/libs/planner/test/planTestUtil.cpp index 47fa8a68dd..bf19c7a222 100644 --- a/source/libs/planner/test/planTestUtil.cpp +++ b/source/libs/planner/test/planTestUtil.cpp @@ -487,6 +487,7 @@ class PlannerTestBaseImpl { DO_WITH_THROW(nodesNodeToString, pNode, false, &pNewStr, &newlen) cout << "new node: " << pNewStr << endl; } + nodesDestroyNode(pNode); taosMemoryFreeClear(pNewStr); string str(pStr, len); From 10749dc607e00e3d1919f5abdc104d32038140b5 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Tue, 13 Sep 2022 16:11:24 +0800 Subject: [PATCH 027/138] refact code --- source/common/src/tdataformat.c | 125 +++++++++++--------------------- 1 file changed, 44 insertions(+), 81 deletions(-) diff --git a/source/common/src/tdataformat.c b/source/common/src/tdataformat.c index ec20baa024..fb18fb9e0f 100644 --- a/source/common/src/tdataformat.c +++ b/source/common/src/tdataformat.c @@ -1174,6 +1174,27 @@ STSchema *tdGetSchemaFromBuilder(STSchemaBuilder *pBuilder) { #endif // SColData ======================================== +void tColDataDestroy(void *ph) { + SColData *pColData = (SColData *)ph; + + tFree(pColData->pBitMap); + tFree((uint8_t *)pColData->aOffset); + tFree(pColData->pData); +} + +void tColDataInit(SColData *pColData, int16_t cid, int8_t type, int8_t smaOn) { + pColData->cid = cid; + pColData->type = type; + pColData->smaOn = smaOn; + tColDataReset(pColData); +} + +void tColDataReset(SColData *pColData) { + pColData->nVal = 0; + pColData->flag = 0; + pColData->nData = 0; +} + static FORCE_INLINE int32_t tColDataPutValue(SColData *pColData, SColVal *pColVal) { int32_t code = 0; @@ -1198,7 +1219,7 @@ static FORCE_INLINE int32_t tColDataPutValue(SColData *pColData, SColVal *pColVa _exit: return code; } -static FORCE_INLINE int32_t tColDataAppendValue0(SColData *pColData, SColVal *pColVal) { +static FORCE_INLINE int32_t tColDataAppendValue0(SColData *pColData, SColVal *pColVal) { // 0 int32_t code = 0; if (pColVal->isNone) { @@ -1220,7 +1241,11 @@ static FORCE_INLINE int32_t tColDataAppendValue1(SColData *pColData, SColVal *pC if (pColVal->isNone) { } else if (pColVal->isNull) { + pColData->flag |= HAS_NULL; + // TODO } else { + pColData->flag |= HAS_VALUE; + // TODO } pColData->nVal++; @@ -1230,8 +1255,12 @@ static FORCE_INLINE int32_t tColDataAppendValue2(SColData *pColData, SColVal *pC int32_t code = 0; if (pColVal->isNone) { + pColData->flag |= HAS_NONE; + // TODO } else if (pColVal->isNull) { } else { + pColData->flag |= HAS_VALUE; + // TODO } pColData->nVal++; @@ -1293,78 +1322,25 @@ static FORCE_INLINE int32_t tColDataAppendValue7(SColData *pColData, return code; } - -void tColDataDestroy(void *ph) { - SColData *pColData = (SColData *)ph; - - tFree(pColData->pBitMap); - tFree((uint8_t *)pColData->aOffset); - tFree(pColData->pData); -} - -void tColDataInit(SColData *pColData, int16_t cid, int8_t type, int8_t smaOn) { - pColData->cid = cid; - pColData->type = type; - pColData->smaOn = smaOn; - tColDataReset(pColData); -} - -void tColDataReset(SColData *pColData) { - pColData->nVal = 0; - pColData->flag = 0; - pColData->nData = 0; -} +static int32_t (*tColDataAppendValueImpl[])(SColData *pColData, SColVal *pColVal) = { + tColDataAppendValue0, // 0 + tColDataAppendValue1, // HAS_NONE + tColDataAppendValue2, // HAS_NULL + tColDataAppendValue3, // HAS_NULL | HAS_NONE + tColDataAppendValue4, // HAS_VALUE + tColDataAppendValue5, // HAS_VALUE | HAS_NONE + tColDataAppendValue6, // HAS_VALUE | HAS_NULL + tColDataAppendValue7 // HAS_VALUE | HAS_NULL | HAS_NONE +}; int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal) { int32_t code = 0; - int64_t size; - SValue value = {0}; - SValue *pValue = &value; - ASSERT(pColVal->cid == pColData->cid); - ASSERT(pColVal->type == pColData->type); + ASSERT(pColData->cid == pColVal->cid); + ASSERT(pColData->type == pColVal->type); - // realloc bitmap - size = BIT2_SIZE(pColData->nVal + 1); - code = tRealloc(&pColData->pBitMap, size); + code = tColDataAppendValueImpl[pColData->flag](pColData, pColVal); if (code) goto _exit; - if ((pColData->nVal & 3) == 0) { - pColData->pBitMap[pColData->nVal >> 2] = 0; - } - - // put value - if (pColVal->isNone) { - pColData->flag |= HAS_NONE; - SET_BIT2(pColData->pBitMap, pColData->nVal, 0); - } else if (pColVal->isNull) { - pColData->flag |= HAS_NULL; - SET_BIT2(pColData->pBitMap, pColData->nVal, 1); - } else { - pColData->flag |= HAS_VALUE; - SET_BIT2(pColData->pBitMap, pColData->nVal, 2); - pValue = &pColVal->value; - } - - if (IS_VAR_DATA_TYPE(pColData->type)) { - // offset - code = tRealloc((uint8_t **)&pColData->aOffset, sizeof(int32_t) * (pColData->nVal + 1)); - if (code) goto _exit; - pColData->aOffset[pColData->nVal] = pColData->nData; - - // value - if ((!pColVal->isNone) && (!pColVal->isNull)) { - code = tRealloc(&pColData->pData, pColData->nData + pColVal->value.nData); - if (code) goto _exit; - memcpy(pColData->pData + pColData->nData, pColVal->value.pData, pColVal->value.nData); - pColData->nData += pColVal->value.nData; - } - } else { - code = tRealloc(&pColData->pData, pColData->nData + tPutValue(NULL, pValue, pColVal->type)); - if (code) goto _exit; - pColData->nData += tPutValue(pColData->pData + pColData->nData, pValue, pColVal->type); - } - - pColData->nVal++; _exit: return code; @@ -1450,17 +1426,4 @@ int32_t tColDataGetValue(SColData *pColData, int32_t iVal, SColVal *pColVal) { _exit: return code; -} - -static FORCE_INLINE int32_t tColDataCmprFn(const void *p1, const void *p2) { - SColData *pColData1 = (SColData *)p1; - SColData *pColData2 = (SColData *)p2; - - if (pColData1->cid < pColData2->cid) { - return -1; - } else if (pColData1->cid > pColData2->cid) { - return 1; - } - - return 0; -} +} \ No newline at end of file From 0107e92e64e6d6dcd9f19b16b897ea05c1ed805f Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Tue, 13 Sep 2022 16:15:07 +0800 Subject: [PATCH 028/138] fix: delete file restart corrupt error --- source/dnode/vnode/src/tsdb/tsdbFS.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/dnode/vnode/src/tsdb/tsdbFS.c b/source/dnode/vnode/src/tsdb/tsdbFS.c index 6b4134f416..31bdb784dd 100644 --- a/source/dnode/vnode/src/tsdb/tsdbFS.c +++ b/source/dnode/vnode/src/tsdb/tsdbFS.c @@ -279,7 +279,7 @@ static int32_t tsdbScanAndTryFixFS(STsdb *pTsdb) { goto _err; } - if (size != pTsdb->fs.pDelFile->size) { + if (size != tsdbLogicToFileSize(pTsdb->fs.pDelFile->size, pTsdb->pVnode->config.tsdbPageSize)) { code = TSDB_CODE_FILE_CORRUPTED; goto _err; } From 30627ce1886559a359e1432289063413b6fe1a88 Mon Sep 17 00:00:00 2001 From: Liu Jicong Date: Tue, 13 Sep 2022 16:20:55 +0800 Subject: [PATCH 029/138] fix(sma): split stream task for specified vgroup --- source/dnode/mnode/impl/src/mndScheduler.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/dnode/mnode/impl/src/mndScheduler.c b/source/dnode/mnode/impl/src/mndScheduler.c index 3bfd7eb596..511a84290d 100644 --- a/source/dnode/mnode/impl/src/mndScheduler.c +++ b/source/dnode/mnode/impl/src/mndScheduler.c @@ -319,7 +319,7 @@ int32_t mndScheduleStream(SMnode* pMnode, SStreamObj* pStream) { bool multiTarget = pDbObj->cfg.numOfVgroups > 1; - if (planTotLevel == 2 || externalTargetDB || multiTarget) { + if (planTotLevel == 2 || externalTargetDB || multiTarget || pStream->fixedSinkVgId) { /*if (true) {*/ SArray* taskOneLevel = taosArrayInit(0, sizeof(void*)); taosArrayPush(pStream->tasks, &taskOneLevel); From a6a38058dd290aaf34d400221d91d4f6bd22142d Mon Sep 17 00:00:00 2001 From: wangmm0220 Date: Tue, 13 Sep 2022 16:39:27 +0800 Subject: [PATCH 030/138] fix: support ttl in create table automatic --- source/libs/parser/src/parInsert.c | 4 ++-- tests/system-test/2-query/ttl_comment.py | 8 +++++++- 2 files changed, 9 insertions(+), 3 deletions(-) diff --git a/source/libs/parser/src/parInsert.c b/source/libs/parser/src/parInsert.c index 74bc68f89e..06e19b98cd 100644 --- a/source/libs/parser/src/parInsert.c +++ b/source/libs/parser/src/parInsert.c @@ -1129,7 +1129,7 @@ static int32_t parseTableOptions(SInsertParseContext* pCxt) { NEXT_TOKEN_KEEP_SQL(pCxt->pSql, sToken, index); if (TK_TTL == sToken.type) { pCxt->pSql += index; - NEXT_TOKEN(pCxt->pSql, sToken); + NEXT_TOKEN_WITH_PREV(pCxt->pSql, sToken); if (TK_NK_INTEGER != sToken.type) { return buildSyntaxErrMsg(&pCxt->msg, "Invalid option ttl", sToken.z); } @@ -1745,7 +1745,7 @@ static int32_t skipTableOptions(SInsertParseSyntaxCxt* pCxt) { NEXT_TOKEN_KEEP_SQL(pCxt->pSql, sToken, index); if (TK_TTL == sToken.type || TK_COMMENT == sToken.type) { pCxt->pSql += index; - NEXT_TOKEN(pCxt->pSql, sToken); + NEXT_TOKEN_WITH_PREV(pCxt->pSql, sToken); } else { break; } diff --git a/tests/system-test/2-query/ttl_comment.py b/tests/system-test/2-query/ttl_comment.py index c26393158c..187df2e2d3 100644 --- a/tests/system-test/2-query/ttl_comment.py +++ b/tests/system-test/2-query/ttl_comment.py @@ -137,7 +137,8 @@ class TDTestCase: tdSql.execute(f"create table {dbname}.child_table2 using {dbname}.super_table1 tags(1) comment ''") tdSql.execute(f"create table {dbname}.child_table3 using {dbname}.super_table1 tags(1) comment 'child'") tdSql.execute(f"insert into {dbname}.child_table4 using {dbname}.super_table1 tags(1) values(now, 1)") - + tdSql.execute(f"insert into {dbname}.child_table5 using {dbname}.super_table1 tags(1) ttl 23 comment '' values(now, 1)") + tdSql.error(f"insert into {dbname}.child_table6 using {dbname}.super_table1 tags(1) ttl -23 comment '' values(now, 1)") tdSql.query("select * from information_schema.ins_tables where table_name like 'child_table1'") tdSql.checkData(0, 0, 'child_table1') @@ -160,6 +161,11 @@ class TDTestCase: tdSql.checkData(0, 7, 0) tdSql.checkData(0, 8, None) + tdSql.query("select * from information_schema.ins_tables where table_name like 'child_table5'") + tdSql.checkData(0, 0, 'child_table5') + tdSql.checkData(0, 7, 23) + tdSql.checkData(0, 8, '') + tdSql.execute(f"alter table {dbname}.child_table1 comment 'nihao'") tdSql.query("select * from information_schema.ins_tables where table_name like 'child_table1'") From 24ac8d6ba0ba2f97344b79ae2b7084bfbcbf2e64 Mon Sep 17 00:00:00 2001 From: kynowoo Date: Tue, 13 Sep 2022 16:44:07 +0800 Subject: [PATCH 031/138] 1. add VALUE keyword 2. merge TTL keyword to en doc. --- docs/en/12-taos-sql/20-keywords.md | 2 ++ docs/zh/12-taos-sql/20-keywords.md | 1 + 2 files changed, 3 insertions(+) diff --git a/docs/en/12-taos-sql/20-keywords.md b/docs/en/12-taos-sql/20-keywords.md index 6f166c8034..d7b9c73c4f 100644 --- a/docs/en/12-taos-sql/20-keywords.md +++ b/docs/en/12-taos-sql/20-keywords.md @@ -238,6 +238,7 @@ There are about 200 keywords reserved by TDengine, they can't be used as the nam - TOPICS - TRIGGER - TSERIES +- TTL ### U @@ -253,6 +254,7 @@ There are about 200 keywords reserved by TDengine, they can't be used as the nam ### V +- VALUE - VALUES - VARIABLE - VARIABLES diff --git a/docs/zh/12-taos-sql/20-keywords.md b/docs/zh/12-taos-sql/20-keywords.md index 09fea45b7a..ee36dc44f0 100644 --- a/docs/zh/12-taos-sql/20-keywords.md +++ b/docs/zh/12-taos-sql/20-keywords.md @@ -256,6 +256,7 @@ description: TDengine 保留关键字的详细列表 ### V +- VALUE - VALUES - VARIABLE - VARIABLES From 0d7e1eb4e03a02d1e9995285a28a9b4106ecd412 Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Tue, 13 Sep 2022 16:45:40 +0800 Subject: [PATCH 032/138] fix(query): twa function output NULL if input has overlap timestamps TD-18224 --- source/libs/function/src/builtinsimpl.c | 54 ++++++++++++++++++++++++- 1 file changed, 52 insertions(+), 2 deletions(-) diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c index 0d7fd1a6da..35e3e07839 100644 --- a/source/libs/function/src/builtinsimpl.c +++ b/source/libs/function/src/builtinsimpl.c @@ -5398,8 +5398,8 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { int32_t i = pInput->startRowIndex; if (pCtx->start.key != INT64_MIN) { - ASSERT((pCtx->start.key < tsList[i] && pCtx->order == TSDB_ORDER_ASC) || - (pCtx->start.key > tsList[i] && pCtx->order == TSDB_ORDER_DESC)); + //ASSERT((pCtx->start.key < tsList[i] && pCtx->order == TSDB_ORDER_ASC) || + // (pCtx->start.key > tsList[i] && pCtx->order == TSDB_ORDER_DESC)); ASSERT(last->key == INT64_MIN); for (; i < pInput->numOfRows + pInput->startRowIndex; ++i) { @@ -5446,6 +5446,11 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { } numOfElems++; + if (pInfo->p.key == st.key) { + numOfElems = 0; + goto _twa_over; + } + INIT_INTP_POINT(st, tsList[i], val[i]); pInfo->dOutput += twa_get_area(pInfo->p, st); pInfo->p = st; @@ -5461,6 +5466,11 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { } numOfElems++; + if (pInfo->p.key == st.key) { + numOfElems = 0; + goto _twa_over; + } + INIT_INTP_POINT(st, tsList[i], val[i]); pInfo->dOutput += twa_get_area(pInfo->p, st); pInfo->p = st; @@ -5475,6 +5485,11 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { } numOfElems++; + if (pInfo->p.key == st.key) { + numOfElems = 0; + goto _twa_over; + } + INIT_INTP_POINT(st, tsList[i], val[i]); pInfo->dOutput += twa_get_area(pInfo->p, st); pInfo->p = st; @@ -5489,6 +5504,11 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { } numOfElems++; + if (pInfo->p.key == st.key) { + numOfElems = 0; + goto _twa_over; + } + INIT_INTP_POINT(st, tsList[i], val[i]); pInfo->dOutput += twa_get_area(pInfo->p, st); pInfo->p = st; @@ -5503,6 +5523,11 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { } numOfElems++; + if (pInfo->p.key == st.key) { + numOfElems = 0; + goto _twa_over; + } + INIT_INTP_POINT(st, tsList[i], val[i]); pInfo->dOutput += twa_get_area(pInfo->p, st); pInfo->p = st; @@ -5517,6 +5542,11 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { } numOfElems++; + if (pInfo->p.key == st.key) { + numOfElems = 0; + goto _twa_over; + } + INIT_INTP_POINT(st, tsList[i], val[i]); pInfo->dOutput += twa_get_area(pInfo->p, st); pInfo->p = st; @@ -5531,6 +5561,11 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { } numOfElems++; + if (pInfo->p.key == st.key) { + numOfElems = 0; + goto _twa_over; + } + INIT_INTP_POINT(st, tsList[i], val[i]); pInfo->dOutput += twa_get_area(pInfo->p, st); pInfo->p = st; @@ -5545,6 +5580,11 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { } numOfElems++; + if (pInfo->p.key == st.key) { + numOfElems = 0; + goto _twa_over; + } + INIT_INTP_POINT(st, tsList[i], val[i]); pInfo->dOutput += twa_get_area(pInfo->p, st); pInfo->p = st; @@ -5559,6 +5599,11 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { } numOfElems++; + if (pInfo->p.key == st.key) { + numOfElems = 0; + goto _twa_over; + } + INIT_INTP_POINT(st, tsList[i], val[i]); pInfo->dOutput += twa_get_area(pInfo->p, st); pInfo->p = st; @@ -5573,6 +5618,11 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { } numOfElems++; + if (pInfo->p.key == st.key) { + numOfElems = 0; + goto _twa_over; + } + INIT_INTP_POINT(st, tsList[i], val[i]); pInfo->dOutput += twa_get_area(pInfo->p, st); pInfo->p = st; From d4d4d2c086a5dc635e780d729c144097cd587c89 Mon Sep 17 00:00:00 2001 From: 54liuyao <54liuyao@163.com> Date: Tue, 13 Sep 2022 16:50:27 +0800 Subject: [PATCH 033/138] feat(stream):optimize delete window --- source/libs/executor/inc/executorimpl.h | 3 +- source/libs/executor/src/timewindowoperator.c | 43 +++++++---- source/libs/executor/src/tsimplehash.c | 6 +- tests/script/tsim/stream/deleteInterval.sim | 76 +++++++++++++++++++ 4 files changed, 112 insertions(+), 16 deletions(-) diff --git a/source/libs/executor/inc/executorimpl.h b/source/libs/executor/inc/executorimpl.h index fc8f942015..6516d76830 100644 --- a/source/libs/executor/inc/executorimpl.h +++ b/source/libs/executor/inc/executorimpl.h @@ -459,10 +459,11 @@ typedef struct SPartitionDataInfo { SArray* rowIds; } SPartitionDataInfo; -typedef struct STimeWindowSupp { +typedef struct STimeWindowAggSupp { int8_t calTrigger; int64_t waterMark; TSKEY maxTs; + TSKEY minTs; SColumnInfoData timeWindowData; // query time window info for scalar function execution. } STimeWindowAggSupp; diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c index b3a85807ae..b02a6fe28b 100644 --- a/source/libs/executor/src/timewindowoperator.c +++ b/source/libs/executor/src/timewindowoperator.c @@ -1355,7 +1355,7 @@ static void setInverFunction(SqlFunctionCtx* pCtx, int32_t num, EStreamType type } } -void doClearWindowImpl(SResultRowPosition* p1, SDiskbasedBuf* pResultBuf, SExprSupp* pSup, int32_t numOfOutput) { +static void doClearWindowImpl(SResultRowPosition* p1, SDiskbasedBuf* pResultBuf, SExprSupp* pSup, int32_t numOfOutput) { SResultRow* pResult = getResultRowByPos(pResultBuf, p1, false); SqlFunctionCtx* pCtx = pSup->pCtx; for (int32_t i = 0; i < numOfOutput; ++i) { @@ -1374,8 +1374,8 @@ void doClearWindowImpl(SResultRowPosition* p1, SDiskbasedBuf* pResultBuf, SExprS releaseBufPage(pResultBuf, bufPage); } -bool doClearWindow(SAggSupporter* pAggSup, SExprSupp* pSup, char* pData, int16_t bytes, uint64_t groupId, - int32_t numOfOutput) { +static bool doClearWindow(SAggSupporter* pAggSup, SExprSupp* pSup, char* pData, int16_t bytes, uint64_t groupId, + int32_t numOfOutput) { SET_RES_WINDOW_KEY(pAggSup->keyBuf, pData, bytes, groupId); SResultRowPosition* p1 = (SResultRowPosition*)tSimpleHashGet(pAggSup->pResultRowHashTable, pAggSup->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes)); @@ -1402,18 +1402,21 @@ bool doDeleteIntervalWindow(SAggSupporter* pAggSup, TSKEY ts, uint64_t groupId) return true; } -void doDeleteSpecifyIntervalWindow(SAggSupporter* pAggSup, SSDataBlock* pBlock, SArray* pDelWins, SInterval* pInterval, - SHashObj* pUpdatedMap) { +static void doDeleteSpecifyIntervalWindow(SAggSupporter* pAggSup, STimeWindowAggSupp* pTwSup, SSDataBlock* pBlock, + SArray* pDelWins, SInterval* pInterval, SHashObj* pUpdatedMap) { SColumnInfoData* pStartCol = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX); TSKEY* tsStarts = (TSKEY*)pStartCol->pData; SColumnInfoData* pEndCol = taosArrayGet(pBlock->pDataBlock, END_TS_COLUMN_INDEX); TSKEY* tsEnds = (TSKEY*)pEndCol->pData; SColumnInfoData* pGroupCol = taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX); uint64_t* groupIds = (uint64_t*)pGroupCol->pData; + int64_t numOfWin = tSimpleHashGetSize(pAggSup->pResultRowHashTable); for (int32_t i = 0; i < pBlock->info.rows; i++) { + TSKEY startTs = TMAX(tsStarts[i], pTwSup->minTs); + TSKEY endTs = TMIN(tsEnds[i], pTwSup->maxTs); SResultRowInfo dumyInfo; dumyInfo.cur.pageId = -1; - STimeWindow win = getActiveTimeWindow(NULL, &dumyInfo, tsStarts[i], pInterval, TSDB_ORDER_ASC); + STimeWindow win = getActiveTimeWindow(NULL, &dumyInfo, startTs, pInterval, TSDB_ORDER_ASC); do { doDeleteIntervalWindow(pAggSup, win.skey, groupIds[i]); SWinKey winRes = {.ts = win.skey, .groupId = groupIds[i]}; @@ -1424,7 +1427,7 @@ void doDeleteSpecifyIntervalWindow(SAggSupporter* pAggSup, SSDataBlock* pBlock, taosHashRemove(pUpdatedMap, &winRes, sizeof(SWinKey)); } getNextTimeWindow(pInterval, pInterval->precision, TSDB_ORDER_ASC, &win); - } while (win.skey <= tsEnds[i]); + } while (win.skey <= endTs); } } @@ -3030,6 +3033,7 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) { _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY); SHashObj* pUpdatedMap = taosHashInit(1024, hashFn, false, HASH_NO_LOCK); TSKEY maxTs = INT64_MIN; + TSKEY minTs = INT64_MAX; SExprSupp* pSup = &pOperator->exprSupp; @@ -3101,8 +3105,6 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) { break; } printDataBlock(pBlock, IS_FINAL_OP(pInfo) ? "interval final recv" : "interval semi recv"); - maxTs = TMAX(maxTs, pBlock->info.window.ekey); - maxTs = TMAX(maxTs, pBlock->info.watermark); ASSERT(pBlock->info.type != STREAM_INVERT); if (pBlock->info.type == STREAM_NORMAL || pBlock->info.type == STREAM_PULL_DATA) { @@ -3129,13 +3131,13 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) { break; } else if (pBlock->info.type == STREAM_DELETE_DATA || pBlock->info.type == STREAM_DELETE_RESULT) { SArray* delWins = taosArrayInit(8, sizeof(SWinKey)); - doDeleteSpecifyIntervalWindow(&pInfo->aggSup, pBlock, delWins, &pInfo->interval, pUpdatedMap); + doDeleteSpecifyIntervalWindow(&pInfo->aggSup, &pInfo->twAggSup, pBlock, delWins, &pInfo->interval, pUpdatedMap); if (IS_FINAL_OP(pInfo)) { int32_t childIndex = getChildIndex(pBlock); SOperatorInfo* pChildOp = taosArrayGetP(pInfo->pChildren, childIndex); SStreamFinalIntervalOperatorInfo* pChildInfo = pChildOp->info; SExprSupp* pChildSup = &pChildOp->exprSupp; - doDeleteSpecifyIntervalWindow(&pChildInfo->aggSup, pBlock, NULL, &pChildInfo->interval, NULL); + doDeleteSpecifyIntervalWindow(&pChildInfo->aggSup, &pInfo->twAggSup, pBlock, NULL, &pChildInfo->interval, NULL); rebuildIntervalWindow(pInfo, pSup, delWins, pInfo->binfo.pRes->info.groupId, pOperator->exprSupp.numOfExprs, pOperator->pTaskInfo, pUpdatedMap); addRetriveWindow(delWins, pInfo); @@ -3189,9 +3191,13 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) { setInputDataBlock(pChildOp, pChildOp->exprSupp.pCtx, pBlock, pChInfo->order, MAIN_SCAN, true); doHashIntervalAgg(pChildOp, pBlock, pBlock->info.groupId, NULL); } + maxTs = TMAX(maxTs, pBlock->info.window.ekey); + maxTs = TMAX(maxTs, pBlock->info.watermark); + minTs = TMIN(minTs, pBlock->info.window.skey); } pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, maxTs); + pInfo->twAggSup.minTs = TMIN(pInfo->twAggSup.minTs, minTs); if (IS_FINAL_OP(pInfo)) { closeIntervalWindow(pInfo->aggSup.pResultRowHashTable, &pInfo->twAggSup, &pInfo->interval, pInfo->pPullDataMap, pUpdatedMap, pInfo->pRecycledPages, pInfo->aggSup.pResultBuf); @@ -3264,6 +3270,7 @@ SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream, .waterMark = pIntervalPhyNode->window.watermark, .calTrigger = pIntervalPhyNode->window.triggerType, .maxTs = INT64_MIN, + .minTs = INT64_MAX, }; ASSERT(pInfo->twAggSup.calTrigger != STREAM_TRIGGER_MAX_DELAY); pInfo->primaryTsIndex = ((SColumnNode*)pIntervalPhyNode->window.pTspk)->slotId; @@ -3507,7 +3514,11 @@ SOperatorInfo* createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPh initDummyFunction(pInfo->pDummyCtx, pSup->pCtx, numOfCols); pInfo->twAggSup = (STimeWindowAggSupp){ - .waterMark = pSessionNode->window.watermark, .calTrigger = pSessionNode->window.triggerType, .maxTs = INT64_MIN}; + .waterMark = pSessionNode->window.watermark, + .calTrigger = pSessionNode->window.triggerType, + .maxTs = INT64_MIN, + .minTs = INT64_MAX, + }; initResultRowInfo(&pInfo->binfo.resultRowInfo); initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); @@ -4832,6 +4843,7 @@ SOperatorInfo* createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhys .waterMark = pStateNode->window.watermark, .calTrigger = pStateNode->window.triggerType, .maxTs = INT64_MIN, + .minTs = INT64_MAX, }; initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); @@ -5632,6 +5644,7 @@ static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) { SStreamIntervalOperatorInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; int64_t maxTs = INT64_MIN; + int64_t minTs = INT64_MAX; SExprSupp* pSup = &pOperator->exprSupp; if (pOperator->status == OP_EXEC_DONE) { @@ -5676,7 +5689,8 @@ static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) { qDebug("%s clear existed time window results for updates checked", GET_TASKID(pTaskInfo)); continue; } else if (pBlock->info.type == STREAM_DELETE_DATA || pBlock->info.type == STREAM_DELETE_RESULT) { - doDeleteSpecifyIntervalWindow(&pInfo->aggSup, pBlock, pInfo->pDelWins, &pInfo->interval, pUpdatedMap); + doDeleteSpecifyIntervalWindow(&pInfo->aggSup, &pInfo->twAggSup, pBlock, pInfo->pDelWins, &pInfo->interval, + pUpdatedMap); continue; } else if (pBlock->info.type == STREAM_GET_ALL) { getAllIntervalWindow(pInfo->aggSup.pResultRowHashTable, pUpdatedMap); @@ -5702,11 +5716,13 @@ static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) { } maxTs = TMAX(maxTs, pBlock->info.window.ekey); + minTs = TMIN(minTs, pBlock->info.window.skey); doStreamIntervalAggImpl(pOperator, &pInfo->binfo.resultRowInfo, pBlock, MAIN_SCAN, pUpdatedMap); // new disc buf // doStreamIntervalAggImpl2(pOperator, pBlock, pBlock->info.groupId, pUpdatedMap); } pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, maxTs); + pInfo->twAggSup.minTs = TMIN(pInfo->twAggSup.minTs, minTs); #if 0 if (pState) { @@ -5805,6 +5821,7 @@ SOperatorInfo* createStreamIntervalOperatorInfo(SOperatorInfo* downstream, SPhys .waterMark = pIntervalPhyNode->window.watermark, .calTrigger = pIntervalPhyNode->window.triggerType, .maxTs = INT64_MIN, + .minTs = INT64_MAX, }; ASSERT(twAggSupp.calTrigger != STREAM_TRIGGER_MAX_DELAY); pOperator->pTaskInfo = pTaskInfo; diff --git a/source/libs/executor/src/tsimplehash.c b/source/libs/executor/src/tsimplehash.c index 84b615af7a..16fd11f97d 100644 --- a/source/libs/executor/src/tsimplehash.c +++ b/source/libs/executor/src/tsimplehash.c @@ -247,8 +247,9 @@ void *tSimpleHashGet(SSHashObj *pHashObj, const void *key, size_t keyLen) { } int32_t tSimpleHashRemove(SSHashObj *pHashObj, const void *key, size_t keyLen) { + int32_t code = TSDB_CODE_FAILED; if (!pHashObj || !key) { - return TSDB_CODE_FAILED; + return code; } uint32_t hashVal = (*pHashObj->hashFp)(key, (uint32_t)keyLen); @@ -266,13 +267,14 @@ int32_t tSimpleHashRemove(SSHashObj *pHashObj, const void *key, size_t keyLen) { } FREE_HASH_NODE(pNode); atomic_sub_fetch_64(&pHashObj->size, 1); + code = TSDB_CODE_SUCCESS; break; } pPrev = pNode; pNode = pNode->next; } - return TSDB_CODE_SUCCESS; + return code; } int32_t tSimpleHashIterateRemove(SSHashObj *pHashObj, const void *key, size_t keyLen, void **pIter, int32_t *iter) { diff --git a/tests/script/tsim/stream/deleteInterval.sim b/tests/script/tsim/stream/deleteInterval.sim index dfd0ddc9d3..00d10afad9 100644 --- a/tests/script/tsim/stream/deleteInterval.sim +++ b/tests/script/tsim/stream/deleteInterval.sim @@ -186,7 +186,9 @@ endi sql drop stream if exists streams2; sql drop database if exists test2; +sql drop database if exists test; sql create database test2 vgroups 4; +sql create database test vgroups 1; sql use test2; sql create stable st(ts timestamp, a int, b int, c int, d double) tags(ta int,tb int,tc int); sql create table t1 using st tags(1,1,1); @@ -411,6 +413,80 @@ if $data12 != 3 then goto loop14 endi +return 1 + +sql drop stream if exists streams3; +sql drop database if exists test3; +sql drop database if exists test; +sql create database test3 vgroups 4; +sql create database test vgroups 1; +sql use test3; +sql create stable st(ts timestamp, a int, b int, c int, d double) tags(ta int,tb int,tc int); +sql create table t1 using st tags(1,1,1); +sql create table t2 using st tags(2,2,2); +sql create stream streams3 trigger at_once into test.streamt3 as select _wstart c1, count(*) c2, max(a) c3 from st interval(10s); + +sql insert into t1 values(1648791213000,NULL,NULL,NULL,NULL); +sql insert into t2 values(1648791213000,NULL,NULL,NULL,NULL); + +$loop_count = 0 + +sql delete from t1; + +loop15: +sleep 200 +sql select * from test.streamt2 order by c1, c2, c3; + +$loop_count = $loop_count + 1 +if $loop_count == 10 then + return -1 +endi + +if $rows != 1 then + print =====rows=$rows + goto loop15 +endi + +$loop_count = 0 + +sql delete from t1 where ts > 100; + +loop16: +sleep 200 +sql select * from test.streamt2 order by c1, c2, c3; + +$loop_count = $loop_count + 1 +if $loop_count == 10 then + return -1 +endi + +if $rows != 1 then + print =====rows=$rows + goto loop16 +endi + +$loop_count = 0 + +sql delete from st; + +loop17: +sleep 200 +sql select * from test.streamt2 order by c1, c2, c3; + +$loop_count = $loop_count + 1 +if $loop_count == 10 then + return -1 +endi + +if $rows != 0 then + print =====rows=$rows + goto loop17 +endi + + + + + $loop_all = $loop_all + 1 print ============loop_all=$loop_all From 26a1bb437ce99d4358ba43f6ee18e138de7794d6 Mon Sep 17 00:00:00 2001 From: Xiaoyu Wang Date: Tue, 13 Sep 2022 16:53:26 +0800 Subject: [PATCH 034/138] enh: add binary serialization method to node structure --- source/libs/nodes/src/nodesMsgFuncs.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/source/libs/nodes/src/nodesMsgFuncs.c b/source/libs/nodes/src/nodesMsgFuncs.c index b72cb694d2..9a093fca99 100644 --- a/source/libs/nodes/src/nodesMsgFuncs.c +++ b/source/libs/nodes/src/nodesMsgFuncs.c @@ -130,6 +130,9 @@ static int32_t tlvEncodeBool(STlvEncoder* pEncoder, int16_t type, bool value) { } static int32_t tlvEncodeCStr(STlvEncoder* pEncoder, int16_t type, const char* pValue) { + if (NULL == pValue) { + return TSDB_CODE_SUCCESS; + } return tlvEncodeImpl(pEncoder, type, pValue, strlen(pValue)); } From 7dbd8c3f2acc18bf373c1532a84149f68b930e97 Mon Sep 17 00:00:00 2001 From: jiacy-jcy <714897623@qq.com> Date: Tue, 13 Sep 2022 16:59:44 +0800 Subject: [PATCH 035/138] update test case for delete data --- tests/system-test/1-insert/delete_data.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tests/system-test/1-insert/delete_data.py b/tests/system-test/1-insert/delete_data.py index 068d212ac4..f2122bfb9e 100644 --- a/tests/system-test/1-insert/delete_data.py +++ b/tests/system-test/1-insert/delete_data.py @@ -81,6 +81,7 @@ class TDTestCase: 'binary':self.binary_val, 'nchar':self.nchar_val } + self.run_time = 2 def insert_base_data(self,col_type,tbname,rows,base_data): for i in range(rows): if col_type.lower() == 'tinyint': @@ -290,6 +291,9 @@ class TDTestCase: self.delete_data_ntb() self.delete_data_ctb() self.delete_data_stb() + tdDnodes.stoptaosd(1) + tdDnodes.starttaosd(1) + self.delete_data_ntb() def stop(self): tdSql.close() tdLog.success("%s successfully executed" % __file__) From 39e65ca2684b6ab6d24033d47d4177022322905c Mon Sep 17 00:00:00 2001 From: Jason-Jia <714897623@qq.com> Date: Tue, 13 Sep 2022 17:03:57 +0800 Subject: [PATCH 036/138] Update delete_data.py --- tests/system-test/1-insert/delete_data.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/system-test/1-insert/delete_data.py b/tests/system-test/1-insert/delete_data.py index f2122bfb9e..f620a4b18a 100644 --- a/tests/system-test/1-insert/delete_data.py +++ b/tests/system-test/1-insert/delete_data.py @@ -81,7 +81,7 @@ class TDTestCase: 'binary':self.binary_val, 'nchar':self.nchar_val } - self.run_time = 2 + def insert_base_data(self,col_type,tbname,rows,base_data): for i in range(rows): if col_type.lower() == 'tinyint': From c5b17d192c1ded440e8e0181974f976fd17f5435 Mon Sep 17 00:00:00 2001 From: Shuduo Sang Date: Tue, 13 Sep 2022 17:09:56 +0800 Subject: [PATCH 037/138] docs: update csharp connector status (#16787) * docs: update csharp connector status * docs: fix csharp ws bulk pulling --- docs/en/14-reference/03-connector/index.mdx | 35 ++++++++++----------- docs/zh/08-connector/index.md | 35 ++++++++++----------- 2 files changed, 34 insertions(+), 36 deletions(-) diff --git a/docs/en/14-reference/03-connector/index.mdx b/docs/en/14-reference/03-connector/index.mdx index 49e2dceec5..5dc54f0934 100644 --- a/docs/en/14-reference/03-connector/index.mdx +++ b/docs/en/14-reference/03-connector/index.mdx @@ -39,14 +39,14 @@ Comparing the connector support for TDengine functional features as follows. ### Using the native interface (taosc) -| **Functional Features** | **Java** | **Python** | **Go** | **C#** | **Node.js** | **Rust** | -| -------------- | -------- | ---------- | ------ | ------ | ----------- | -------- | -| **Connection Management** | Support | Support | Support | Support | Support | Support | -| **Regular Query** | Support | Support | Support | Support | Support | Support | -| **Parameter Binding** | Support | Support | Support | Support | Support | Support | -| ** TMQ ** | Support | Support | Support | Support | Support | Support | -| **Schemaless** | Support | Support | Support | Support | Support | Support | -| **DataFrame** | Not Supported | Support | Not Supported | Not Supported | Not Supported | Not Supported | +| **Functional Features** | **Java** | **Python** | **Go** | **C#** | **Node.js** | **Rust** | +| ----------------------------- | ------------- | ---------- | ------------- | ------------- | ------------- | ------------- | +| **Connection Management** | Support | Support | Support | Support | Support | Support | +| **Regular Query** | Support | Support | Support | Support | Support | Support | +| **Parameter Binding** | Support | Support | Support | Support | Support | Support | +| **Subscription (TMQ)** | Support | Support | Support | Support | Support | Support | +| **Schemaless** | Support | Support | Support | Support | Support | Support | +| **DataFrame** | Not Supported | Support | Not Supported | Not Supported | Not Supported | Not Supported | :::info The different database framework specifications for various programming languages do not mean that all C/C++ interfaces need a wrapper. @@ -54,16 +54,15 @@ The different database framework specifications for various programming language ### Use HTTP Interfaces (REST or WebSocket) -| **Functional Features** | **Java** | **Python** | **Go** | **C# (not supported yet)** | **Node.js** | **Rust** | -| ------------------------------ | -------- | ---------- | -------- | ------------------ | ----------- | -------- | -| **Connection Management** | Support | Support | Support | N/A | Support | Support | -| **Regular Query** | Support | Support | Support | N/A | Support | Support | -| **Continous Query ** | Support | Support | Support | N/A | Support | Support | -| **Parameter Binding** | Not supported | Not supported | Not supported | N/A | Not supported | Support | -| ** TMQ ** | Not supported | Not supported | Not supported | N/A | Not supported | Support | -| **Schemaless** | Not supported | Not supported | Not supported | N/A | Not supported | Not supported | -| **Bulk Pulling (based on WebSocket) **| Support | Support | Not Supported | N/A | Not Supported | Supported | -| **DataFrame** | Not supported | Support | Not supported | N/A | Not supported | Not supported | +| **Functional Features** | **Java** | **Python** | **Go** | **C#** | **Node.js** | **Rust** | +| -------------------------------------- | ------------- | --------------- | ------------- | ------------- | ------------- | ------------- | +| **Connection Management** | Support | Support | Support | Support | Support | Support | +| **Regular Query** | Support | Support | Support | Support | Support | Support | +| **Parameter Binding** | Not supported | Not supported | Not supported | Support | Not supported | Support | +| **Subscription (TMQ) ** | Not supported | Not supported | Not supported | Not supported | Not supported | Support | +| **Schemaless** | Not supported | Not supported | Not supported | Not supported | Not supported | Not supported | +| **Bulk Pulling (based on WebSocket) ** | Support | Support | Not Supported | support | Not Supported | Supported | +| **DataFrame** | Not supported | Support | Not supported | Not supported | Not supported | Not supported | :::warning diff --git a/docs/zh/08-connector/index.md b/docs/zh/08-connector/index.md index 17de8e926c..f54470f742 100644 --- a/docs/zh/08-connector/index.md +++ b/docs/zh/08-connector/index.md @@ -41,14 +41,14 @@ TDengine 版本更新往往会增加新的功能特性，列表中的连接器 ### 使用原生接口（taosc） -| **功能特性** | **Java** | **Python** | **Go** | **C#** | **Node.js** | **Rust** | -| -------------- | -------- | ---------- | ------ | ------ | ----------- | -------- | -| **连接管理** | 支持 | 支持 | 支持 | 支持 | 支持 | 支持 | -| **普通查询** | 支持 | 支持 | 支持 | 支持 | 支持 | 支持 | -| **参数绑定** | 支持 | 支持 | 支持 | 支持 | 支持 | 支持 | -| ** TMQ ** | 支持 | 支持 | 支持 | 支持 | 支持 | 支持 | -| **Schemaless** | 支持 | 支持 | 支持 | 支持 | 支持 | 支持 | -| **DataFrame** | 不支持 | 支持 | 不支持 | 不支持 | 不支持 | 不支持 | +| **功能特性** | **Java** | **Python** | **Go** | **C#** | **Node.js** | **Rust** | +| ------------------- | -------- | ---------- | ------ | ------ | ----------- | -------- | +| **连接管理** | 支持 | 支持 | 支持 | 支持 | 支持 | 支持 | +| **普通查询** | 支持 | 支持 | 支持 | 支持 | 支持 | 支持 | +| **参数绑定** | 支持 | 支持 | 支持 | 支持 | 支持 | 支持 | +| **数据订阅（TMQ）** | 支持 | 支持 | 支持 | 支持 | 支持 | 支持 | +| **Schemaless** | 支持 | 支持 | 支持 | 支持 | 支持 | 支持 | +| **DataFrame** | 不支持 | 支持 | 不支持 | 不支持 | 不支持 | 不支持 | :::info 由于不同编程语言数据库框架规范不同，并不意味着所有 C/C++ 接口都需要对应封装支持。 @@ -56,16 +56,15 @@ TDengine 版本更新往往会增加新的功能特性，列表中的连接器 ### 使用 http (REST 或 WebSocket) 接口 -| **功能特性** | **Java** | **Python** | **Go** | **C#（暂不支持）** | **Node.js** | **Rust** | -| ------------------------------ | -------- | ---------- | -------- | ------------------ | ----------- | -------- | -| **连接管理** | 支持 | 支持 | 支持 | N/A | 支持 | 支持 | -| **普通查询** | 支持 | 支持 | 支持 | N/A | 支持 | 支持 | -| **连续查询** | 支持 | 支持 | 支持 | N/A | 支持 | 支持 | -| **参数绑定** | 不支持 | 暂不支持 | 暂不支持 | N/A | 不支持 | 支持 | -| ** TMQ ** | 不支持 | 暂不支持 | 暂不支持 | N/A | 不支持 | 支持 | -| **Schemaless** | 暂不支持 | 暂不支持 | 暂不支持 | N/A | 不支持 | 暂不支持 | -| **批量拉取（基于 WebSocket）** | 支持 | 支持 | 暂不支持 | N/A | 不支持 | 支持 | -| **DataFrame** | 不支持 | 支持 | 不支持 | N/A | 不支持 | 不支持 | +| **功能特性** | **Java** | **Python** | **Go** | **C# ** | **Node.js** | **Rust** | +| ------------------------------ | -------- | ---------- | -------- | -------- | ----------- | -------- | +| **连接管理** | 支持 | 支持 | 支持 | 支持 | 支持 | 支持 | +| **普通查询** | 支持 | 支持 | 支持 | 支持 | 支持 | 支持 | +| **参数绑定** | 暂不支持 | 暂不支持 | 暂不支持 | 支持 | 暂不支持 | 支持 | +| **数据订阅（TMQ）** | 暂不支持 | 暂不支持 | 暂不支持 | 暂不支持 | 暂不支持 | 支持 | +| **Schemaless** | 暂不支持 | 暂不支持 | 暂不支持 | 暂不支持 | 暂不支持 | 暂不支持 | +| **批量拉取（基于 WebSocket）** | 支持 | 支持 | 暂不支持 | 支持 | 暂不支持 | 支持 | +| **DataFrame** | 不支持 | 支持 | 不支持 | 不支持 | 不支持 | 不支持 | :::warning From cd69248905e3884e12565661b62bec4508c7e65d Mon Sep 17 00:00:00 2001 From: Shuduo Sang Date: Tue, 13 Sep 2022 17:25:31 +0800 Subject: [PATCH 038/138] feat: update taos-tools 404d8da for 3.0 --- cmake/taostools_CMakeLists.txt.in | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/taostools_CMakeLists.txt.in b/cmake/taostools_CMakeLists.txt.in index c273e9889f..13559bba27 100644 --- a/cmake/taostools_CMakeLists.txt.in +++ b/cmake/taostools_CMakeLists.txt.in @@ -2,7 +2,7 @@ # taos-tools ExternalProject_Add(taos-tools GIT_REPOSITORY https://github.com/taosdata/taos-tools.git - GIT_TAG 2dba49c + GIT_TAG 404d8da SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools" BINARY_DIR "" #BUILD_IN_SOURCE TRUE From b6daab624b6fc62481b449d95b9797fb1a984e65 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Tue, 13 Sep 2022 17:30:20 +0800 Subject: [PATCH 039/138] more code --- include/common/tdataformat.h | 4 +- source/common/src/tdataformat.c | 137 +++++++++++++++++-------- source/dnode/vnode/src/tsdb/tsdbUtil.c | 2 +- 3 files changed, 96 insertions(+), 47 deletions(-) diff --git a/include/common/tdataformat.h b/include/common/tdataformat.h index 4e5ecd90dc..726e0eba6b 100644 --- a/include/common/tdataformat.h +++ b/include/common/tdataformat.h @@ -107,10 +107,10 @@ int32_t parseJsontoTagData(const char *json, SArray *pTagVals, STag **ppTag, voi // SColData ================================ void tColDataInit(SColData *pColData, int16_t cid, int8_t type, int8_t smaOn); -void tColDataReset(SColData *pColData); +void tColDataClear(SColData *pColData); void tColDataDestroy(void *ph); int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal); -int32_t tColDataGetValue(SColData *pColData, int32_t iRow, SColVal *pColVal); +void tColDataGetValue(SColData *pColData, int32_t iRow, SColVal *pColVal); int32_t tColDataCopy(SColData *pColDataSrc, SColData *pColDataDest); int32_t tPutColData(uint8_t *p, SColData *pColData); int32_t tGetColData(uint8_t *p, SColData *pColData); diff --git a/source/common/src/tdataformat.c b/source/common/src/tdataformat.c index fb18fb9e0f..ee68e53e18 100644 --- a/source/common/src/tdataformat.c +++ b/source/common/src/tdataformat.c @@ -1186,10 +1186,10 @@ void tColDataInit(SColData *pColData, int16_t cid, int8_t type, int8_t smaOn) { pColData->cid = cid; pColData->type = type; pColData->smaOn = smaOn; - tColDataReset(pColData); + tColDataClear(pColData); } -void tColDataReset(SColData *pColData) { +void tColDataClear(SColData *pColData) { pColData->nVal = 0; pColData->flag = 0; pColData->nData = 0; @@ -1346,6 +1346,97 @@ _exit: return code; } +static FORCE_INLINE void tColDataGetValue1(SColData *pColData, int32_t iVal, SColVal *pColVal) { // HAS_NONE + *pColVal = COL_VAL_NONE(pColData->cid, pColData->type); +} +static FORCE_INLINE void tColDataGetValue2(SColData *pColData, int32_t iVal, SColVal *pColVal) { // HAS_NULL + *pColVal = COL_VAL_NULL(pColData->cid, pColData->type); +} +static FORCE_INLINE void tColDataGetValue3(SColData *pColData, int32_t iVal, SColVal *pColVal) { // HAS_NULL|HAS_NONE + switch (GET_BIT1(pColData->pBitMap, iVal)) { + case 0: + *pColVal = COL_VAL_NONE(pColData->cid, pColData->type); + break; + case 1: + *pColVal = COL_VAL_NULL(pColData->cid, pColData->type); + break; + default: + ASSERT(0); + } +} +static FORCE_INLINE void tColDataGetValue4(SColData *pColData, int32_t iVal, SColVal *pColVal) { // HAS_VALUE + SValue value; + if (IS_VAR_DATA_TYPE(pColData->type)) { + if (iVal + 1 < pColData->nVal) { + value.nData = pColData->aOffset[iVal + 1] - pColData->aOffset[iVal]; + } else { + value.nData = pColData->nData - pColData->aOffset[iVal]; + } + value.pData = pColData->pData + pColData->aOffset[iVal]; + } else { + tGetValue(pColData->pData + tDataTypes[pColData->type].bytes * iVal, &value, pColData->type); + } + *pColVal = COL_VAL_VALUE(pColData->cid, pColData->type, value); +} +static FORCE_INLINE void tColDataGetValue5(SColData *pColData, int32_t iVal, + SColVal *pColVal) { // HAS_VALUE|HAS_NONE + switch (GET_BIT1(pColData->pBitMap, iVal)) { + case 0: + *pColVal = COL_VAL_NONE(pColData->cid, pColData->type); + break; + case 1: + tColDataGetValue4(pColData, iVal, pColVal); + break; + default: + ASSERT(0); + } +} +static FORCE_INLINE void tColDataGetValue6(SColData *pColData, int32_t iVal, + SColVal *pColVal) { // HAS_VALUE|HAS_NULL + switch (GET_BIT1(pColData->pBitMap, iVal)) { + case 0: + *pColVal = COL_VAL_NULL(pColData->cid, pColData->type); + break; + case 1: + tColDataGetValue4(pColData, iVal, pColVal); + break; + default: + ASSERT(0); + } +} +static FORCE_INLINE void tColDataGetValue7(SColData *pColData, int32_t iVal, + SColVal *pColVal) { // HAS_VALUE|HAS_NULL|HAS_NONE + switch (GET_BIT2(pColData->pBitMap, iVal)) { + case 0: + *pColVal = COL_VAL_NONE(pColData->cid, pColData->type); + break; + case 1: + *pColVal = COL_VAL_NULL(pColData->cid, pColData->type); + break; + case 2: + tColDataGetValue4(pColData, iVal, pColVal); + break; + default: + ASSERT(0); + } +} +static void (*tColDataGetValueImpl[])(SColData *pColData, int32_t iVal, SColVal *pColVal) = { + NULL, // 0 + tColDataGetValue1, // HAS_NONE + tColDataGetValue2, // HAS_NULL + tColDataGetValue3, // HAS_NULL | HAS_NONE + tColDataGetValue4, // HAS_VALUE + tColDataGetValue5, // HAS_VALUE | HAS_NONE + tColDataGetValue6, // HAS_VALUE | HAS_NULL + tColDataGetValue7 // HAS_VALUE | HAS_NULL | HAS_NONE +}; +void tColDataGetValue(SColData *pColData, int32_t iVal, SColVal *pColVal) { + ASSERT(iVal >= 0 && iVal < pColData->nVal); + ASSERT(pColData->flag); + + tColDataGetValueImpl[pColData->flag](pColData, iVal, pColVal); +} + int32_t tColDataCopy(SColData *pColDataSrc, SColData *pColDataDest) { int32_t code = 0; int32_t size; @@ -1382,48 +1473,6 @@ int32_t tColDataCopy(SColData *pColDataSrc, SColData *pColDataDest) { if (code) goto _exit; memcpy(pColDataDest->pData, pColDataSrc->pData, pColDataDest->nData); -_exit: - return code; -} - -int32_t tColDataGetValue(SColData *pColData, int32_t iVal, SColVal *pColVal) { - int32_t code = 0; - - ASSERT(iVal < pColData->nVal); - ASSERT(pColData->flag); - - if (pColData->flag == HAS_NONE) { - *pColVal = COL_VAL_NONE(pColData->cid, pColData->type); - goto _exit; - } else if (pColData->flag == HAS_NULL) { - *pColVal = COL_VAL_NULL(pColData->cid, pColData->type); - goto _exit; - } else if (pColData->flag != HAS_VALUE) { - uint8_t v = GET_BIT2(pColData->pBitMap, iVal); - if (v == 0) { - *pColVal = COL_VAL_NONE(pColData->cid, pColData->type); - goto _exit; - } else if (v == 1) { - *pColVal = COL_VAL_NULL(pColData->cid, pColData->type); - goto _exit; - } - } - - // get value - SValue value; - if (IS_VAR_DATA_TYPE(pColData->type)) { - if (iVal + 1 < pColData->nVal) { - value.nData = pColData->aOffset[iVal + 1] - pColData->aOffset[iVal]; - } else { - value.nData = pColData->nData - pColData->aOffset[iVal]; - } - - value.pData = pColData->pData + pColData->aOffset[iVal]; - } else { - tGetValue(pColData->pData + tDataTypes[pColData->type].bytes * iVal, &value, pColData->type); - } - *pColVal = COL_VAL_VALUE(pColData->cid, pColData->type, value); - _exit: return code; } \ No newline at end of file diff --git a/source/dnode/vnode/src/tsdb/tsdbUtil.c b/source/dnode/vnode/src/tsdb/tsdbUtil.c index 0a78085db2..32fc7b82a1 100644 --- a/source/dnode/vnode/src/tsdb/tsdbUtil.c +++ b/source/dnode/vnode/src/tsdb/tsdbUtil.c @@ -1009,7 +1009,7 @@ void tBlockDataClear(SBlockData *pBlockData) { pBlockData->nRow = 0; for (int32_t iColData = 0; iColData < taosArrayGetSize(pBlockData->aIdx); iColData++) { SColData *pColData = tBlockDataGetColDataByIdx(pBlockData, iColData); - tColDataReset(pColData); + tColDataClear(pColData); } } From aa204ec62be3f12a81af6c6d86ceb011d7c112c9 Mon Sep 17 00:00:00 2001 From: Shuduo Sang Date: Tue, 13 Sep 2022 17:30:47 +0800 Subject: [PATCH 040/138] test: fix location in develop-test/5-taos-tools/taosbenchmark/demo.py --- .../5-taos-tools/taosbenchmark/demo.py | 24 ++++++++++--------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/tests/develop-test/5-taos-tools/taosbenchmark/demo.py b/tests/develop-test/5-taos-tools/taosbenchmark/demo.py index 99e8cd36a4..f62cb05269 100644 --- a/tests/develop-test/5-taos-tools/taosbenchmark/demo.py +++ b/tests/develop-test/5-taos-tools/taosbenchmark/demo.py @@ -22,9 +22,9 @@ from util.dnodes import * class TDTestCase: def caseDescription(self): - ''' + """ [TD-13823] taosBenchmark test cases - ''' + """ return def init(self, conn, logSql): @@ -34,19 +34,19 @@ class TDTestCase: def getPath(self, tool="taosBenchmark"): selfPath = os.path.dirname(os.path.realpath(__file__)) - if ("community" in selfPath): - projPath = selfPath[:selfPath.find("community")] + if "community" in selfPath: + projPath = selfPath[: selfPath.find("community")] else: - projPath = selfPath[:selfPath.find("tests")] + projPath = selfPath[: selfPath.find("tests")] paths = [] for root, dirs, files in os.walk(projPath): - if ((tool) in files): + if (tool) in files: rootRealPath = os.path.dirname(os.path.realpath(root)) - if ("packaging" not in rootRealPath): + if "packaging" not in rootRealPath: paths.append(os.path.join(root, tool)) break - if (len(paths) == 0): + if len(paths) == 0: tdLog.exit("taosBenchmark not found!") return else: @@ -55,7 +55,7 @@ class TDTestCase: def run(self): binPath = self.getPath() - cmd = "%s -n 100 -t 100 -y" %binPath + cmd = "%s -n 100 -t 100 -y" % binPath tdLog.info("%s" % cmd) os.system("%s" % cmd) tdSql.execute("use test") @@ -83,8 +83,10 @@ class TDTestCase: tdSql.query("select count(*) from test.meters where groupid >= 0") tdSql.checkData(0, 0, 10000) - tdSql.query("select count(*) from test.meters where location = 'San Francisco' or location = 'Los Angles' or location = 'San Diego' or location = 'San Jose' or \ - location = 'Palo Alto' or location = 'Campbell' or location = 'Mountain View' or location = 'Sunnyvale' or location = 'Santa Clara' or location = 'Cupertino' ") + tdSql.query( + "select count(*) from test.meters where location = 'California.SanFrancisco' or location = 'California.LosAngles' or location = 'California.SanDiego' or location = 'California.SanJose' or \ + location = 'California.PaloAlto' or location = 'California.Campbell' or location = 'California.MountainView' or location = 'California.Sunnyvale' or location = 'California.SantaClara' or location = 'California.Cupertino' " + ) tdSql.checkData(0, 0, 10000) def stop(self): From 632a26d0fe8612e7f72d5cc2347d68836dff2279 Mon Sep 17 00:00:00 2001 From: Haojun Liao Date: Tue, 13 Sep 2022 17:39:43 +0800 Subject: [PATCH 041/138] refactor(query): do some internal refactor. --- source/libs/executor/inc/executorimpl.h | 42 +-- source/libs/executor/src/executorimpl.c | 350 ++---------------- source/libs/executor/src/timewindowoperator.c | 166 ++++----- 3 files changed, 115 insertions(+), 443 deletions(-) diff --git a/source/libs/executor/inc/executorimpl.h b/source/libs/executor/inc/executorimpl.h index a9826e0018..61c6f9878e 100644 --- a/source/libs/executor/inc/executorimpl.h +++ b/source/libs/executor/inc/executorimpl.h @@ -584,11 +584,12 @@ typedef struct SIntervalAggOperatorInfo { typedef struct SMergeAlignedIntervalAggOperatorInfo { SIntervalAggOperatorInfo* intervalAggOperatorInfo; - bool hasGroupId; +// bool hasGroupId; uint64_t groupId; // current groupId int64_t curTs; // current ts SSDataBlock* prefetchedBlock; SNode* pCondition; + SResultRow* pResultRow; } SMergeAlignedIntervalAggOperatorInfo; typedef struct SStreamIntervalOperatorInfo { @@ -648,7 +649,6 @@ typedef struct SAggOperatorInfo { } SAggOperatorInfo; typedef struct SProjectOperatorInfo { - // SOptrBasicInfo should be first, SAggSupporter should be second for stream encode SOptrBasicInfo binfo; SAggSupporter aggSup; SNode* pFilterNode; // filter info, which is push down by optimizer @@ -690,7 +690,6 @@ typedef struct SFillOperatorInfo { } SFillOperatorInfo; typedef struct SGroupbyOperatorInfo { - // SOptrBasicInfo should be first, SAggSupporter should be second for stream encode SOptrBasicInfo binfo; SAggSupporter aggSup; @@ -737,7 +736,6 @@ typedef struct SWindowRowsSup { } SWindowRowsSup; typedef struct SSessionAggOperatorInfo { - // SOptrBasicInfo should be first, SAggSupporter should be second for stream encode SOptrBasicInfo binfo; SAggSupporter aggSup; @@ -825,7 +823,6 @@ typedef struct SStateWindowOperatorInfo { SStateKeys stateKey; int32_t tsSlotId; // primary timestamp column slot id STimeWindowAggSupp twAggSup; - // bool reptScan; const SNode* pCondition; } SStateWindowOperatorInfo; @@ -846,24 +843,6 @@ typedef struct SStreamStateAggOperatorInfo { bool ignoreExpiredData; } SStreamStateAggOperatorInfo; -typedef struct SSortedMergeOperatorInfo { - // SOptrBasicInfo should be first, SAggSupporter should be second for stream encode - SOptrBasicInfo binfo; - SAggSupporter aggSup; - - SArray* pSortInfo; - int32_t numOfSources; - SSortHandle* pSortHandle; - int32_t bufPageSize; - uint32_t sortBufSize; // max buffer size for in-memory sort - int32_t resultRowFactor; - bool hasGroupVal; - SDiskbasedBuf* pTupleStore; // keep the final results - int32_t numOfResPerPage; - char** groupVal; - SArray* groupInfo; -} SSortedMergeOperatorInfo; - typedef struct SSortOperatorInfo { SOptrBasicInfo binfo; uint32_t sortBufSize; // max buffer size for in-memory sort @@ -871,11 +850,10 @@ typedef struct SSortOperatorInfo { SSortHandle* pSortHandle; SArray* pColMatchInfo; // for index map from table scan output int32_t bufPageSize; - - int64_t startTs; // sort start time - uint64_t sortElapsed; // sort elapsed time, time to flush to disk not included. - SLimitInfo limitInfo; - SNode* pCondition; + int64_t startTs; // sort start time + uint64_t sortElapsed; // sort elapsed time, time to flush to disk not included. + SLimitInfo limitInfo; + SNode* pCondition; } SSortOperatorInfo; typedef struct STagFilterOperatorInfo { @@ -907,7 +885,6 @@ SOperatorFpSet createOperatorFpSet(__optr_open_fn_t openFn, __optr_fn_t nextFn, __optr_decode_fn_t decode, __optr_explain_fn_t explain); int32_t operatorDummyOpenFn(SOperatorInfo* pOperator); -void operatorDummyCloseFn(void* param, int32_t numOfCols); int32_t appendDownstream(SOperatorInfo* p, SOperatorInfo** pDownstream, int32_t num); void initBasicInfo(SOptrBasicInfo* pInfo, SSDataBlock* pBlock); @@ -942,7 +919,6 @@ int32_t addTagPseudoColumnData(SReadHandle* pHandle, SExprInfo* pPseudoExpr, int SSDataBlock* pBlock, const char* idStr); void cleanupAggSup(SAggSupporter* pAggSup); -void destroyBasicOperatorInfo(void* param, int32_t numOfOutput); void appendOneRowToDataBlock(SSDataBlock* pBlock, STupleHandle* pTupleHandle); void setTbNameColData(void* pMeta, const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, int32_t functionId); @@ -1089,10 +1065,8 @@ void appendOneRow(SSDataBlock* pBlock, TSKEY* pStartTs, TSKEY* pEn void printDataBlock(SSDataBlock* pBlock, const char* flag); uint64_t calGroupIdByData(SPartitionBySupporter* pParSup, SExprSupp* pExprSup, SSDataBlock* pBlock, int32_t rowId); -int32_t finalizeResultRowIntoResultDataBlock(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, - SqlFunctionCtx* pCtx, SExprInfo* pExprInfo, int32_t numOfExprs, - const int32_t* rowCellOffset, SSDataBlock* pBlock, - SExecTaskInfo* pTaskInfo); +int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, + SExprSupp* pSup, SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo); int32_t createScanTableListInfo(SScanPhysiNode* pScanNode, SNodeList* pGroupTags, bool groupSort, SReadHandle* pHandle, STableListInfo* pTableListInfo, SNode* pTagCond, SNode* pTagIndexCond, diff --git a/source/libs/executor/src/executorimpl.c b/source/libs/executor/src/executorimpl.c index 205bcd58df..e5f0d4d177 100644 --- a/source/libs/executor/src/executorimpl.c +++ b/source/libs/executor/src/executorimpl.c @@ -132,8 +132,6 @@ SOperatorFpSet createOperatorFpSet(__optr_open_fn_t openFn, __optr_fn_t nextFn, return fpSet; } -void operatorDummyCloseFn(void* param, int32_t numOfCols) {} - static int32_t doCopyToSDataBlock(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf, SGroupResInfo* pGroupResInfo); @@ -1269,33 +1267,12 @@ static void doUpdateNumOfRows(SqlFunctionCtx* pCtx, SResultRow* pRow, int32_t nu } } -// todo extract method with copytoSSDataBlock -int32_t finalizeResultRowIntoResultDataBlock(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, - SqlFunctionCtx* pCtx, SExprInfo* pExprInfo, int32_t numOfExprs, - const int32_t* rowCellOffset, SSDataBlock* pBlock, - SExecTaskInfo* pTaskInfo) { - SFilePage* page = getBufPage(pBuf, resultRowPosition->pageId); - SResultRow* pRow = (SResultRow*)((char*)page + resultRowPosition->offset); - - doUpdateNumOfRows(pCtx, pRow, numOfExprs, rowCellOffset); - if (pRow->numOfRows == 0) { - releaseBufPage(pBuf, page); - return 0; - } - - while (pBlock->info.rows + pRow->numOfRows > pBlock->info.capacity) { - int32_t code = blockDataEnsureCapacity(pBlock, pBlock->info.capacity * 1.25); - if (TAOS_FAILED(code)) { - releaseBufPage(pBuf, page); - qError("%s ensure result data capacity failed, code %s", GET_TASKID(pTaskInfo), tstrerror(code)); - T_LONG_JMP(pTaskInfo->env, code); - } - } - +static void doCopyResultToDataBlock(SExprInfo* pExprInfo, int32_t numOfExprs, SResultRow* pRow, SqlFunctionCtx* pCtx, + SSDataBlock* pBlock, const int32_t* rowEntryOffset, SExecTaskInfo* pTaskInfo) { for (int32_t j = 0; j < numOfExprs; ++j) { int32_t slotId = pExprInfo[j].base.resSchema.slotId; - pCtx[j].resultInfo = getResultEntryInfo(pRow, j, rowCellOffset); + pCtx[j].resultInfo = getResultEntryInfo(pRow, j, rowEntryOffset); if (pCtx[j].fpSet.finalize) { int32_t code = pCtx[j].fpSet.finalize(&pCtx[j], pBlock); if (TAOS_FAILED(code)) { @@ -1303,7 +1280,7 @@ int32_t finalizeResultRowIntoResultDataBlock(SDiskbasedBuf* pBuf, SResultRowPosi T_LONG_JMP(pTaskInfo->env, code); } } else if (strcmp(pCtx[j].pExpr->pExpr->_function.functionName, "_select_value") == 0) { - // do nothing, todo refactor + // do nothing } else { // expand the result into multiple rows. E.g., _wstart, top(k, 20) // the _wstart needs to copy to 20 following rows, since the results of top-k expands to 20 different rows. @@ -1314,10 +1291,39 @@ int32_t finalizeResultRowIntoResultDataBlock(SDiskbasedBuf* pBuf, SResultRowPosi } } } +} + +int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, + SExprSupp* pSup, SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo) { + SFilePage* page = getBufPage(pBuf, resultRowPosition->pageId); + SResultRow* pRow = (SResultRow*)((char*)page + resultRowPosition->offset); + + SqlFunctionCtx* pCtx = pSup->pCtx; + SExprInfo* pExprInfo = pSup->pExprInfo; + const int32_t* rowEntryOffset = pSup->rowEntryInfoOffset; + + doUpdateNumOfRows(pCtx, pRow, pSup->numOfExprs, rowEntryOffset); + if (pRow->numOfRows == 0) { + releaseBufPage(pBuf, page); + return 0; + } + + int32_t size = pBlock->info.capacity; + while (pBlock->info.rows + pRow->numOfRows > size) { + size = size * 1.25; + } + + int32_t code = blockDataEnsureCapacity(pBlock, size); + if (TAOS_FAILED(code)) { + releaseBufPage(pBuf, page); + qError("%s ensure result data capacity failed, code %s", GET_TASKID(pTaskInfo), tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } + + doCopyResultToDataBlock(pExprInfo, pSup->numOfExprs, pRow, pCtx, pBlock, rowEntryOffset, pTaskInfo); releaseBufPage(pBuf, page); pBlock->info.rows += pRow->numOfRows; - return 0; } @@ -1362,32 +1368,7 @@ int32_t doCopyToSDataBlock(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprS } pGroupResInfo->index += 1; - - for (int32_t j = 0; j < numOfExprs; ++j) { - int32_t slotId = pExprInfo[j].base.resSchema.slotId; - - pCtx[j].resultInfo = getResultEntryInfo(pRow, j, rowEntryOffset); - if (pCtx[j].fpSet.finalize) { -#ifdef BUF_PAGE_DEBUG - qDebug("\npage_finalize %d", numOfExprs); -#endif - int32_t code = pCtx[j].fpSet.finalize(&pCtx[j], pBlock); - if (TAOS_FAILED(code)) { - qError("%s build result data block error, code %s", GET_TASKID(pTaskInfo), tstrerror(code)); - T_LONG_JMP(pTaskInfo->env, code); - } - } else if (strcmp(pCtx[j].pExpr->pExpr->_function.functionName, "_select_value") == 0) { - // do nothing, todo refactor - } else { - // expand the result into multiple rows. E.g., _wstart, top(k, 20) - // the _wstart needs to copy to 20 following rows, since the results of top-k expands to 20 different rows. - SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, slotId); - char* in = GET_ROWCELL_INTERBUF(pCtx[j].resultInfo); - for (int32_t k = 0; k < pRow->numOfRows; ++k) { - colDataAppend(pColInfoData, pBlock->info.rows + k, in, pCtx[j].resultInfo->isNullRes); - } - } - } + doCopyResultToDataBlock(pExprInfo, numOfExprs, pRow, pCtx, pBlock, rowEntryOffset, pTaskInfo); releaseBufPage(pBuf, page); pBlock->info.rows += pRow->numOfRows; @@ -2307,21 +2288,6 @@ _error: static int32_t doInitAggInfoSup(SAggSupporter* pAggSup, SqlFunctionCtx* pCtx, int32_t numOfOutput, size_t keyBufSize, const char* pKey); -static void destroySortedMergeOperatorInfo(void* param, int32_t numOfOutput) { - SSortedMergeOperatorInfo* pInfo = (SSortedMergeOperatorInfo*)param; - taosArrayDestroy(pInfo->pSortInfo); - taosArrayDestroy(pInfo->groupInfo); - - if (pInfo->pSortHandle != NULL) { - tsortDestroySortHandle(pInfo->pSortHandle); - } - - blockDataDestroy(pInfo->binfo.pRes); - cleanupAggSup(&pInfo->aggSup); - - taosMemoryFreeClear(param); -} - static bool needToMerge(SSDataBlock* pBlock, SArray* groupInfo, char** buf, int32_t rowIndex) { size_t size = taosArrayGetSize(groupInfo); if (size == 0) { @@ -2357,41 +2323,6 @@ static bool needToMerge(SSDataBlock* pBlock, SArray* groupInfo, char** buf, int3 return 0; } -static void doMergeResultImpl(SSortedMergeOperatorInfo* pInfo, SqlFunctionCtx* pCtx, int32_t numOfExpr, - int32_t rowIndex) { - for (int32_t j = 0; j < numOfExpr; ++j) { // TODO set row index - // pCtx[j].startRow = rowIndex; - } - - for (int32_t j = 0; j < numOfExpr; ++j) { - int32_t functionId = pCtx[j].functionId; - // pCtx[j].fpSet->addInput(&pCtx[j]); - - // if (functionId < 0) { - // SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1); - // doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_MERGE); - // } else { - // assert(!TSDB_FUNC_IS_SCALAR(functionId)); - // aAggs[functionId].mergeFunc(&pCtx[j]); - // } - } -} - -static void doFinalizeResultImpl(SqlFunctionCtx* pCtx, int32_t numOfExpr) { - for (int32_t j = 0; j < numOfExpr; ++j) { - int32_t functionId = pCtx[j].functionId; - // if (functionId == FUNC_TAG_DUMMY || functionId == FUNC_TS_DUMMY) { - // continue; - // } - - // if (functionId < 0) { - // SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1); - // doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_FINALIZE); - // } else { - // pCtx[j].fpSet.finalize(&pCtx[j]); - } -} - static bool saveCurrentTuple(char** rowColData, SArray* pColumnList, SSDataBlock* pBlock, int32_t rowIndex) { int32_t size = (int32_t)taosArrayGetSize(pColumnList); @@ -2406,210 +2337,6 @@ static bool saveCurrentTuple(char** rowColData, SArray* pColumnList, SSDataBlock return true; } -static void doMergeImpl(SOperatorInfo* pOperator, int32_t numOfExpr, SSDataBlock* pBlock) { - SSortedMergeOperatorInfo* pInfo = pOperator->info; - - SqlFunctionCtx* pCtx = pOperator->exprSupp.pCtx; - - for (int32_t i = 0; i < pBlock->info.rows; ++i) { - if (!pInfo->hasGroupVal) { - ASSERT(i == 0); - doMergeResultImpl(pInfo, pCtx, numOfExpr, i); - pInfo->hasGroupVal = saveCurrentTuple(pInfo->groupVal, pInfo->groupInfo, pBlock, i); - } else { - if (needToMerge(pBlock, pInfo->groupInfo, pInfo->groupVal, i)) { - doMergeResultImpl(pInfo, pCtx, numOfExpr, i); - } else { - doFinalizeResultImpl(pCtx, numOfExpr); - int32_t numOfRows = getNumOfResult(pOperator->exprSupp.pCtx, pOperator->exprSupp.numOfExprs, NULL); - // setTagValueForMultipleRows(pCtx, pOperator->exprSupp.numOfExprs, numOfRows); - - // TODO check for available buffer; - - // next group info data - pInfo->binfo.pRes->info.rows += numOfRows; - for (int32_t j = 0; j < numOfExpr; ++j) { - if (pCtx[j].functionId < 0) { - continue; - } - - pCtx[j].fpSet.process(&pCtx[j]); - } - - doMergeResultImpl(pInfo, pCtx, numOfExpr, i); - pInfo->hasGroupVal = saveCurrentTuple(pInfo->groupVal, pInfo->groupInfo, pBlock, i); - } - } - } -} - -static SSDataBlock* doMerge(SOperatorInfo* pOperator) { - SSortedMergeOperatorInfo* pInfo = pOperator->info; - SSortHandle* pHandle = pInfo->pSortHandle; - - SSDataBlock* pDataBlock = createOneDataBlock(pInfo->binfo.pRes, false); - blockDataEnsureCapacity(pDataBlock, pOperator->resultInfo.capacity); - - while (1) { - blockDataCleanup(pDataBlock); - while (1) { - STupleHandle* pTupleHandle = tsortNextTuple(pHandle); - if (pTupleHandle == NULL) { - break; - } - - // build datablock for merge for one group - appendOneRowToDataBlock(pDataBlock, pTupleHandle); - if (pDataBlock->info.rows >= pOperator->resultInfo.capacity) { - break; - } - } - - if (pDataBlock->info.rows == 0) { - break; - } - - setInputDataBlock(pOperator, pOperator->exprSupp.pCtx, pDataBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); - // updateOutputBuf(&pInfo->binfo, &pAggInfo->bufCapacity, pBlock->info.rows * pAggInfo->resultRowFactor, - // pOperator->pRuntimeEnv, true); - doMergeImpl(pOperator, pOperator->exprSupp.numOfExprs, pDataBlock); - // flush to tuple store, and after all data have been handled, return to upstream node or sink node - } - - doFinalizeResultImpl(pOperator->exprSupp.pCtx, pOperator->exprSupp.numOfExprs); - int32_t numOfRows = getNumOfResult(pOperator->exprSupp.pCtx, pOperator->exprSupp.numOfExprs, NULL); - // setTagValueForMultipleRows(pCtx, pOperator->exprSupp.numOfExprs, numOfRows); - - // TODO check for available buffer; - - // next group info data - pInfo->binfo.pRes->info.rows += numOfRows; - return (pInfo->binfo.pRes->info.rows > 0) ? pInfo->binfo.pRes : NULL; -} - -SSDataBlock* getSortedMergeBlockData(SSortHandle* pHandle, SSDataBlock* pDataBlock, int32_t capacity, - SArray* pColMatchInfo, SSortedMergeOperatorInfo* pInfo) { - blockDataCleanup(pDataBlock); - - SSDataBlock* p = tsortGetSortedDataBlock(pHandle); - if (p == NULL) { - return NULL; - } - - blockDataEnsureCapacity(p, capacity); - - while (1) { - STupleHandle* pTupleHandle = tsortNextTuple(pHandle); - if (pTupleHandle == NULL) { - break; - } - - appendOneRowToDataBlock(p, pTupleHandle); - if (p->info.rows >= capacity) { - break; - } - } - - if (p->info.rows > 0) { - int32_t numOfCols = taosArrayGetSize(pColMatchInfo); - for (int32_t i = 0; i < numOfCols; ++i) { - SColMatchInfo* pmInfo = taosArrayGet(pColMatchInfo, i); - ASSERT(pmInfo->matchType == COL_MATCH_FROM_SLOT_ID); - - SColumnInfoData* pSrc = taosArrayGet(p->pDataBlock, pmInfo->srcSlotId); - SColumnInfoData* pDst = taosArrayGet(pDataBlock->pDataBlock, pmInfo->targetSlotId); - colDataAssign(pDst, pSrc, p->info.rows, &pDataBlock->info); - } - - pDataBlock->info.rows = p->info.rows; - pDataBlock->info.capacity = p->info.rows; - } - - blockDataDestroy(p); - return (pDataBlock->info.rows > 0) ? pDataBlock : NULL; -} - -static SSDataBlock* doSortedMerge(SOperatorInfo* pOperator) { - if (pOperator->status == OP_EXEC_DONE) { - return NULL; - } - - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - SSortedMergeOperatorInfo* pInfo = pOperator->info; - if (pOperator->status == OP_RES_TO_RETURN) { - return getSortedMergeBlockData(pInfo->pSortHandle, pInfo->binfo.pRes, pOperator->resultInfo.capacity, NULL, pInfo); - } - - int32_t numOfBufPage = pInfo->sortBufSize / pInfo->bufPageSize; - pInfo->pSortHandle = tsortCreateSortHandle(pInfo->pSortInfo, SORT_MULTISOURCE_MERGE, pInfo->bufPageSize, numOfBufPage, - pInfo->binfo.pRes, "GET_TASKID(pTaskInfo)"); - - tsortSetFetchRawDataFp(pInfo->pSortHandle, loadNextDataBlock, NULL, NULL); - - for (int32_t i = 0; i < pOperator->numOfDownstream; ++i) { - SSortSource* ps = taosMemoryCalloc(1, sizeof(SSortSource)); - ps->param = pOperator->pDownstream[i]; - tsortAddSource(pInfo->pSortHandle, ps); - } - - int32_t code = tsortOpen(pInfo->pSortHandle); - if (code != TSDB_CODE_SUCCESS) { - T_LONG_JMP(pTaskInfo->env, terrno); - } - - pOperator->status = OP_RES_TO_RETURN; - return doMerge(pOperator); -} - -static int32_t initGroupCol(SExprInfo* pExprInfo, int32_t numOfCols, SArray* pGroupInfo, - SSortedMergeOperatorInfo* pInfo) { - if (pGroupInfo == NULL || taosArrayGetSize(pGroupInfo) == 0) { - return 0; - } - - int32_t len = 0; - SArray* plist = taosArrayInit(3, sizeof(SColumn)); - pInfo->groupInfo = taosArrayInit(3, sizeof(int32_t)); - - if (plist == NULL || pInfo->groupInfo == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; - } - - size_t numOfGroupCol = taosArrayGetSize(pInfo->groupInfo); - for (int32_t i = 0; i < numOfGroupCol; ++i) { - SColumn* pCol = taosArrayGet(pGroupInfo, i); - for (int32_t j = 0; j < numOfCols; ++j) { - SExprInfo* pe = &pExprInfo[j]; - if (pe->base.resSchema.slotId == pCol->colId) { - taosArrayPush(plist, pCol); - taosArrayPush(pInfo->groupInfo, &j); - len += pCol->bytes; - break; - } - } - } - - ASSERT(taosArrayGetSize(pGroupInfo) == taosArrayGetSize(plist)); - - pInfo->groupVal = taosMemoryCalloc(1, (POINTER_BYTES * numOfGroupCol + len)); - if (pInfo->groupVal == NULL) { - taosArrayDestroy(plist); - return TSDB_CODE_OUT_OF_MEMORY; - } - - int32_t offset = 0; - char* start = (char*)(pInfo->groupVal + (POINTER_BYTES * numOfGroupCol)); - for (int32_t i = 0; i < numOfGroupCol; ++i) { - pInfo->groupVal[i] = start + offset; - SColumn* pCol = taosArrayGet(plist, i); - offset += pCol->bytes; - } - - taosArrayDestroy(plist); - - return TSDB_CODE_SUCCESS; -} - int32_t getTableScanInfo(SOperatorInfo* pOperator, int32_t* order, int32_t* scanFlag) { // todo add more information about exchange operation int32_t type = pOperator->operatorType; @@ -3342,13 +3069,6 @@ void cleanupBasicInfo(SOptrBasicInfo* pInfo) { pInfo->pRes = blockDataDestroy(pInfo->pRes); } -void destroyBasicOperatorInfo(void* param, int32_t numOfOutput) { - SOptrBasicInfo* pInfo = (SOptrBasicInfo*)param; - cleanupBasicInfo(pInfo); - - taosMemoryFreeClear(param); -} - static void freeItem(void* pItem) { void** p = pItem; if (*p != NULL) { diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c index d773f8a629..81a5d9953c 100644 --- a/source/libs/executor/src/timewindowoperator.c +++ b/source/libs/executor/src/timewindowoperator.c @@ -46,19 +46,6 @@ static SResultRowPosition addToOpenWindowList(SResultRowInfo* pResultRowInfo, co uint64_t groupId); static void doCloseWindow(SResultRowInfo* pResultRowInfo, const SIntervalAggOperatorInfo* pInfo, SResultRow* pResult); -///* -// * There are two cases to handle: -// * -// * 1. Query range is not set yet (queryRangeSet = 0). we need to set the query range info, including -// * pQueryAttr->lastKey, pQueryAttr->window.skey, and pQueryAttr->eKey. -// * 2. Query range is set and query is in progress. There may be another result with the same query ranges to be -// * merged during merge stage. In this case, we need the pTableQueryInfo->lastResRows to decide if there -// * is a previous result generated or not. -// */ -// static void setIntervalQueryRange(STableQueryInfo* pTableQueryInfo, TSKEY key, STimeWindow* pQRange) { -// // do nothing -//} - static TSKEY getStartTsKey(STimeWindow* win, const TSKEY* tsCols) { return tsCols == NULL ? win->skey : tsCols[0]; } static int32_t setTimeWindowOutputBuf(SResultRowInfo* pResultRowInfo, STimeWindow* win, bool masterscan, @@ -3004,9 +2991,9 @@ static void addRetriveWindow(SArray* wins, SStreamFinalIntervalOperatorInfo* pIn SPullWindowInfo pull = {.window = nextWin, .groupId = winKey->groupId}; // add pull data request savePullWindow(&pull, pInfo->pPullWins); - int32_t size = taosArrayGetSize(pInfo->pChildren); - addPullWindow(pInfo->pPullDataMap, winKey, size); - qDebug("===stream===prepare retrive for delete %" PRId64 ", size:%d", winKey->ts, size); + int32_t size1 = taosArrayGetSize(pInfo->pChildren); + addPullWindow(pInfo->pPullDataMap, winKey, size1); + qDebug("===stream===prepare retrive for delete %" PRId64 ", size:%d", winKey->ts, size1); } } } @@ -4884,66 +4871,64 @@ void destroyMergeAlignedIntervalOperatorInfo(void* param) { taosMemoryFreeClear(param); } -static int32_t outputMergeAlignedIntervalResult(SOperatorInfo* pOperatorInfo, uint64_t tableGroupId, - SSDataBlock* pResultBlock, TSKEY wstartTs) { - SMergeAlignedIntervalAggOperatorInfo* miaInfo = pOperatorInfo->info; +static SResultRow* doSetSingleOutputTupleBuf(SResultRowInfo* pResultRowInfo, SAggSupporter* pSup) { + SResultRow* pResult = getNewResultRow(pSup->pResultBuf, &pSup->currentPageId, pSup->resultRowSize); + pResultRowInfo->cur = (SResultRowPosition){.pageId = pResult->pageId, .offset = pResult->offset}; + return pResult; +} - SIntervalAggOperatorInfo* iaInfo = miaInfo->intervalAggOperatorInfo; - SExecTaskInfo* pTaskInfo = pOperatorInfo->pTaskInfo; - SExprSupp* pSup = &pOperatorInfo->exprSupp; +static int32_t setSingleOutputTupleBuf(SResultRowInfo* pResultRowInfo, STimeWindow* win, SResultRow** pResult, + SExprSupp* pExprSup, SAggSupporter* pAggSup) { + if (*pResult == NULL) { + *pResult = doSetSingleOutputTupleBuf(pResultRowInfo, pAggSup); + if (*pResult == NULL) { + return terrno; + } + } - SET_RES_WINDOW_KEY(iaInfo->aggSup.keyBuf, &wstartTs, TSDB_KEYSIZE, tableGroupId); - SResultRowPosition* p1 = (SResultRowPosition*)tSimpleHashGet( - iaInfo->aggSup.pResultRowHashTable, iaInfo->aggSup.keyBuf, GET_RES_WINDOW_KEY_LEN(TSDB_KEYSIZE)); - ASSERT(p1 != NULL); - - finalizeResultRowIntoResultDataBlock(iaInfo->aggSup.pResultBuf, p1, pSup->pCtx, pSup->pExprInfo, pSup->numOfExprs, - pSup->rowEntryInfoOffset, pResultBlock, pTaskInfo); - tSimpleHashRemove(iaInfo->aggSup.pResultRowHashTable, iaInfo->aggSup.keyBuf, GET_RES_WINDOW_KEY_LEN(TSDB_KEYSIZE)); - ASSERT(tSimpleHashGetSize(iaInfo->aggSup.pResultRowHashTable) == 0); + // set time window for current result ,todo extract method + (*pResult)->win = (*win); + (*pResult)->numOfRows = 0; + (*pResult)->closed = false; + (*pResult)->endInterp = false; + (*pResult)->startInterp = false; + memset((*pResult)->pEntryInfo, 0, pAggSup->resultRowSize - sizeof(SResultRow)); + setResultRowInitCtx((*pResult), pExprSup->pCtx, pExprSup->numOfExprs, pExprSup->rowEntryInfoOffset); return TSDB_CODE_SUCCESS; } static void doMergeAlignedIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResultRowInfo, - SSDataBlock* pBlock, int32_t scanFlag, SSDataBlock* pResultBlock) { + SSDataBlock* pBlock, SSDataBlock* pResultBlock) { SMergeAlignedIntervalAggOperatorInfo* miaInfo = pOperatorInfo->info; SIntervalAggOperatorInfo* iaInfo = miaInfo->intervalAggOperatorInfo; SExecTaskInfo* pTaskInfo = pOperatorInfo->pTaskInfo; SExprSupp* pSup = &pOperatorInfo->exprSupp; + SInterval* pInterval = &iaInfo->interval; - int32_t startPos = 0; - int32_t numOfOutput = pSup->numOfExprs; - int64_t* tsCols = extractTsCol(pBlock, iaInfo); - uint64_t tableGroupId = pBlock->info.groupId; - SResultRow* pResult = NULL; + int32_t startPos = 0; + int64_t* tsCols = extractTsCol(pBlock, iaInfo); TSKEY ts = getStartTsKey(&pBlock->info.window, tsCols); // there is an result exists if (miaInfo->curTs != INT64_MIN) { - ASSERT(tSimpleHashGetSize(iaInfo->aggSup.pResultRowHashTable) == 1); - if (ts != miaInfo->curTs) { - outputMergeAlignedIntervalResult(pOperatorInfo, tableGroupId, pResultBlock, miaInfo->curTs); + finalizeResultRows(iaInfo->aggSup.pResultBuf, &pResultRowInfo->cur, pSup, pResultBlock, pTaskInfo); miaInfo->curTs = ts; } } else { miaInfo->curTs = ts; - ASSERT(tSimpleHashGetSize(iaInfo->aggSup.pResultRowHashTable) == 0); } STimeWindow win = {0}; win.skey = miaInfo->curTs; - win.ekey = - taosTimeAdd(win.skey, iaInfo->interval.interval, iaInfo->interval.intervalUnit, iaInfo->interval.precision) - 1; + win.ekey = taosTimeAdd(win.skey, pInterval->interval, pInterval->intervalUnit, pInterval->precision) - 1; - // TODO: remove the hash table (groupid + winkey => result row position) - int32_t ret = setTimeWindowOutputBuf(pResultRowInfo, &win, (scanFlag == MAIN_SCAN), &pResult, tableGroupId, - pSup->pCtx, numOfOutput, pSup->rowEntryInfoOffset, &iaInfo->aggSup, pTaskInfo); - if (ret != TSDB_CODE_SUCCESS || pResult == NULL) { - T_LONG_JMP(pTaskInfo->env, TSDB_CODE_QRY_OUT_OF_MEMORY); + int32_t ret = setSingleOutputTupleBuf(pResultRowInfo, &win, &miaInfo->pResultRow, pSup, &iaInfo->aggSup); + if (ret != TSDB_CODE_SUCCESS || miaInfo->pResultRow == NULL) { + T_LONG_JMP(pTaskInfo->env, ret); } int32_t currPos = startPos; @@ -4956,21 +4941,18 @@ static void doMergeAlignedIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultR updateTimeWindowInfo(&iaInfo->twAggSup.timeWindowData, &currWin, true); doApplyFunctions(pTaskInfo, pSup->pCtx, &iaInfo->twAggSup.timeWindowData, startPos, currPos - startPos, - pBlock->info.rows, numOfOutput); + pBlock->info.rows, pSup->numOfExprs); - outputMergeAlignedIntervalResult(pOperatorInfo, tableGroupId, pResultBlock, miaInfo->curTs); + finalizeResultRows(iaInfo->aggSup.pResultBuf, &pResultRowInfo->cur, pSup, pResultBlock, pTaskInfo); miaInfo->curTs = tsCols[currPos]; currWin.skey = miaInfo->curTs; - currWin.ekey = taosTimeAdd(currWin.skey, iaInfo->interval.interval, iaInfo->interval.intervalUnit, - iaInfo->interval.precision) - - 1; + currWin.ekey = taosTimeAdd(currWin.skey, pInterval->interval, pInterval->intervalUnit, pInterval->precision) - 1; startPos = currPos; - ret = setTimeWindowOutputBuf(pResultRowInfo, &currWin, (scanFlag == MAIN_SCAN), &pResult, tableGroupId, pSup->pCtx, - numOfOutput, pSup->rowEntryInfoOffset, &iaInfo->aggSup, pTaskInfo); - if (ret != TSDB_CODE_SUCCESS || pResult == NULL) { - T_LONG_JMP(pTaskInfo->env, TSDB_CODE_QRY_OUT_OF_MEMORY); + ret = setSingleOutputTupleBuf(pResultRowInfo, &win, &miaInfo->pResultRow, pSup, &iaInfo->aggSup); + if (ret != TSDB_CODE_SUCCESS || miaInfo->pResultRow == NULL) { + T_LONG_JMP(pTaskInfo->env, ret); } miaInfo->curTs = currWin.skey; @@ -4978,68 +4960,66 @@ static void doMergeAlignedIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultR updateTimeWindowInfo(&iaInfo->twAggSup.timeWindowData, &currWin, true); doApplyFunctions(pTaskInfo, pSup->pCtx, &iaInfo->twAggSup.timeWindowData, startPos, currPos - startPos, - pBlock->info.rows, numOfOutput); + pBlock->info.rows, pSup->numOfExprs); } static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) { SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - SMergeAlignedIntervalAggOperatorInfo* miaInfo = pOperator->info; - SIntervalAggOperatorInfo* iaInfo = miaInfo->intervalAggOperatorInfo; + SMergeAlignedIntervalAggOperatorInfo* pMiaInfo = pOperator->info; + SIntervalAggOperatorInfo* pIaInfo = pMiaInfo->intervalAggOperatorInfo; - SExprSupp* pSup = &pOperator->exprSupp; - SSDataBlock* pRes = iaInfo->binfo.pRes; - - SOperatorInfo* downstream = pOperator->pDownstream[0]; - int32_t scanFlag = MAIN_SCAN; + SExprSupp* pSup = &pOperator->exprSupp; + SSDataBlock* pRes = pIaInfo->binfo.pRes; + SResultRowInfo* pResultRowInfo = &pIaInfo->binfo.resultRowInfo; + SOperatorInfo* downstream = pOperator->pDownstream[0]; + int32_t scanFlag = MAIN_SCAN; while (1) { SSDataBlock* pBlock = NULL; - if (miaInfo->prefetchedBlock == NULL) { + if (pMiaInfo->prefetchedBlock == NULL) { pBlock = downstream->fpSet.getNextFn(downstream); } else { - pBlock = miaInfo->prefetchedBlock; - miaInfo->prefetchedBlock = NULL; + pBlock = pMiaInfo->prefetchedBlock; + pMiaInfo->prefetchedBlock = NULL; - miaInfo->groupId = pBlock->info.groupId; + pMiaInfo->groupId = pBlock->info.groupId; } + // no data exists, all query processing is done if (pBlock == NULL) { - // close last unfinalized time window - if (miaInfo->curTs != INT64_MIN) { - ASSERT(tSimpleHashGetSize(iaInfo->aggSup.pResultRowHashTable) == 1); - outputMergeAlignedIntervalResult(pOperator, miaInfo->groupId, pRes, miaInfo->curTs); - miaInfo->curTs = INT64_MIN; + // close last unclosed time window + if (pMiaInfo->curTs != INT64_MIN) { + finalizeResultRows(pIaInfo->aggSup.pResultBuf, &pResultRowInfo->cur, pSup, pRes, pTaskInfo); + pMiaInfo->curTs = INT64_MIN; } doSetOperatorCompleted(pOperator); break; } - if (!miaInfo->hasGroupId) { - miaInfo->hasGroupId = true; - miaInfo->groupId = pBlock->info.groupId; - } else if (miaInfo->groupId != pBlock->info.groupId) { + if (pMiaInfo->groupId != pBlock->info.groupId && pMiaInfo->groupId != 0) { // if there are unclosed time window, close it firstly. - ASSERT(miaInfo->curTs != INT64_MIN); - outputMergeAlignedIntervalResult(pOperator, miaInfo->groupId, pRes, miaInfo->curTs); - miaInfo->prefetchedBlock = pBlock; - miaInfo->curTs = INT64_MIN; + ASSERT(pMiaInfo->curTs != INT64_MIN); + finalizeResultRows(pIaInfo->aggSup.pResultBuf, &pResultRowInfo->cur, pSup, pRes, pTaskInfo); + + pMiaInfo->prefetchedBlock = pBlock; + pMiaInfo->curTs = INT64_MIN; + pMiaInfo->groupId = 0; break; } - getTableScanInfo(pOperator, &iaInfo->inputOrder, &scanFlag); - setInputDataBlock(pOperator, pSup->pCtx, pBlock, iaInfo->inputOrder, scanFlag, true); - doMergeAlignedIntervalAggImpl(pOperator, &iaInfo->binfo.resultRowInfo, pBlock, scanFlag, pRes); + getTableScanInfo(pOperator, &pIaInfo->inputOrder, &scanFlag); + setInputDataBlock(pOperator, pSup->pCtx, pBlock, pIaInfo->inputOrder, scanFlag, true); + doMergeAlignedIntervalAggImpl(pOperator, &pIaInfo->binfo.resultRowInfo, pBlock, pRes); - doFilter(miaInfo->pCondition, pRes, NULL); + doFilter(pMiaInfo->pCondition, pRes, NULL); if (pRes->info.rows >= pOperator->resultInfo.capacity) { break; } } - pRes->info.groupId = miaInfo->groupId; - miaInfo->hasGroupId = false; + pRes->info.groupId = pMiaInfo->groupId; } static SSDataBlock* mergeAlignedIntervalAgg(SOperatorInfo* pOperator) { @@ -5191,8 +5171,7 @@ static int32_t finalizeWindowResult(SOperatorInfo* pOperatorInfo, uint64_t table SResultRowPosition* p1 = (SResultRowPosition*)tSimpleHashGet( iaInfo->aggSup.pResultRowHashTable, iaInfo->aggSup.keyBuf, GET_RES_WINDOW_KEY_LEN(TSDB_KEYSIZE)); ASSERT(p1 != NULL); - finalizeResultRowIntoResultDataBlock(iaInfo->aggSup.pResultBuf, p1, pExprSup->pCtx, pExprSup->pExprInfo, - pExprSup->numOfExprs, pExprSup->rowEntryInfoOffset, pResultBlock, pTaskInfo); +// finalizeResultRows(iaInfo->aggSup.pResultBuf, p1, pResultBlock, pTaskInfo); tSimpleHashRemove(iaInfo->aggSup.pResultRowHashTable, iaInfo->aggSup.keyBuf, GET_RES_WINDOW_KEY_LEN(TSDB_KEYSIZE)); return TSDB_CODE_SUCCESS; } @@ -5201,9 +5180,7 @@ static int32_t outputPrevIntervalResult(SOperatorInfo* pOperatorInfo, uint64_t t STimeWindow* newWin) { SMergeIntervalAggOperatorInfo* miaInfo = pOperatorInfo->info; SIntervalAggOperatorInfo* iaInfo = &miaInfo->intervalAggOperatorInfo; - SExecTaskInfo* pTaskInfo = pOperatorInfo->pTaskInfo; bool ascScan = (iaInfo->inputOrder == TSDB_ORDER_ASC); - SExprSupp* pExprSup = &pOperatorInfo->exprSupp; SGroupTimeWindow groupTimeWindow = {.groupId = tableGroupId, .window = *newWin}; tdListAppend(miaInfo->groupIntervals, &groupTimeWindow); @@ -5216,9 +5193,10 @@ static int32_t outputPrevIntervalResult(SOperatorInfo* pOperatorInfo, uint64_t t if (prevGrpWin->groupId != tableGroupId) { continue; } + STimeWindow* prevWin = &prevGrpWin->window; if ((ascScan && newWin->skey > prevWin->ekey) || ((!ascScan) && newWin->skey < prevWin->ekey)) { - finalizeWindowResult(pOperatorInfo, tableGroupId, prevWin, pResultBlock); +// finalizeWindowResult(pOperatorInfo, tableGroupId, prevWin, pResultBlock); tdListPopNode(miaInfo->groupIntervals, listNode); } } @@ -5378,7 +5356,7 @@ static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) { if (listNode != NULL) { SGroupTimeWindow* grpWin = (SGroupTimeWindow*)(listNode->data); - finalizeWindowResult(pOperator, grpWin->groupId, &grpWin->window, pRes); +// finalizeWindowResult(pOperator, grpWin->groupId, &grpWin->window, pRes); pRes->info.groupId = grpWin->groupId; } } From 60574763a9e7ff8f28d4e5607a7fc8c35680478c Mon Sep 17 00:00:00 2001 From: Haojun Liao Date: Tue, 13 Sep 2022 17:41:31 +0800 Subject: [PATCH 042/138] refactor(query): do some internal refactor. --- source/libs/executor/src/timewindowoperator.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c index 81a5d9953c..c4525cc3b9 100644 --- a/source/libs/executor/src/timewindowoperator.c +++ b/source/libs/executor/src/timewindowoperator.c @@ -4865,7 +4865,7 @@ _error: return NULL; } -void destroyMergeAlignedIntervalOperatorInfo(void* param) { +void destroyMAIOperatorInfo(void* param) { SMergeAlignedIntervalAggOperatorInfo* miaInfo = (SMergeAlignedIntervalAggOperatorInfo*)param; destroyIntervalOperatorInfo(miaInfo->intervalAggOperatorInfo); taosMemoryFreeClear(param); @@ -5118,7 +5118,7 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, pOperator->info = miaInfo; pOperator->fpSet = createOperatorFpSet(operatorDummyOpenFn, mergeAlignedIntervalAgg, NULL, NULL, - destroyMergeAlignedIntervalOperatorInfo, NULL, NULL, NULL); + destroyMAIOperatorInfo, NULL, NULL, NULL); code = appendDownstream(pOperator, &downstream, 1); if (code != TSDB_CODE_SUCCESS) { @@ -5128,7 +5128,7 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, return pOperator; _error: - destroyMergeAlignedIntervalOperatorInfo(miaInfo); + destroyMAIOperatorInfo(miaInfo); taosMemoryFreeClear(pOperator); pTaskInfo->code = code; return NULL; From b82f27ec03279a2db352a6bfad66f5a8e544f76b Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Tue, 13 Sep 2022 17:48:57 +0800 Subject: [PATCH 043/138] tsc: handle schedule error --- include/util/tsched.h | 6 ++---- source/client/src/clientImpl.c | 7 ++++++- source/libs/qcom/src/queryUtil.c | 5 +---- source/util/src/tsched.c | 13 +++++++------ 4 files changed, 16 insertions(+), 15 deletions(-) diff --git a/include/util/tsched.h b/include/util/tsched.h index 347cacd191..379456afe6 100644 --- a/include/util/tsched.h +++ b/include/util/tsched.h @@ -31,7 +31,6 @@ typedef struct SSchedMsg { void *thandle; } SSchedMsg; - typedef struct { char label[TSDB_LABEL_LEN]; tsem_t emptySem; @@ -48,7 +47,6 @@ typedef struct { void *pTimer; } SSchedQueue; - /** * Create a thread-safe ring-buffer based task queue and return the instance. A thread * pool will be created to consume the messages in the queue. @@ -57,7 +55,7 @@ typedef struct { * @param label the label of the queue * @return the created queue scheduler */ -void *taosInitScheduler(int32_t capacity, int32_t numOfThreads, const char *label, SSchedQueue* pSched); +void *taosInitScheduler(int32_t capacity, int32_t numOfThreads, const char *label, SSchedQueue *pSched); /** * Create a thread-safe ring-buffer based task queue and return the instance. @@ -83,7 +81,7 @@ void taosCleanUpScheduler(void *queueScheduler); * @param queueScheduler the queue scheduler instance * @param pMsg the message for the task */ -void taosScheduleTask(void *queueScheduler, SSchedMsg *pMsg); +int taosScheduleTask(void *queueScheduler, SSchedMsg *pMsg); #ifdef __cplusplus } diff --git a/source/client/src/clientImpl.c b/source/client/src/clientImpl.c index 5ebc2729f8..39b4b069a0 100644 --- a/source/client/src/clientImpl.c +++ b/source/client/src/clientImpl.c @@ -1399,7 +1399,12 @@ void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) { arg->msg = *pMsg; arg->pEpset = tEpSet; - taosAsyncExec(doProcessMsgFromServer, arg, NULL); + if (0 != taosAsyncExec(doProcessMsgFromServer, arg, NULL)) { + tscError("failed to sched msg to tsc, tsc ready to quit"); + rpcFreeCont(pMsg->pCont); + taosMemoryFree(arg->pEpset); + taosMemoryFree(arg); + } } TAOS* taos_connect_auth(const char* ip, const char* user, const char* auth, const char* db, uint16_t port) { diff --git a/source/libs/qcom/src/queryUtil.c b/source/libs/qcom/src/queryUtil.c index d848016e46..8162b922ce 100644 --- a/source/libs/qcom/src/queryUtil.c +++ b/source/libs/qcom/src/queryUtil.c @@ -134,8 +134,7 @@ int32_t taosAsyncExec(__async_exec_fn_t execFn, void* execParam, int32_t* code) schedMsg.thandle = execParam; schedMsg.msg = code; - taosScheduleTask(&pTaskQueue, &schedMsg); - return 0; + return taosScheduleTask(&pTaskQueue, &schedMsg); } void destroySendMsgInfo(SMsgSendInfo* pMsgBody) { @@ -472,5 +471,3 @@ int32_t cloneDbVgInfo(SDBVgInfo* pSrc, SDBVgInfo** pDst) { return TSDB_CODE_SUCCESS; } - - diff --git a/source/util/src/tsched.c b/source/util/src/tsched.c index 89471c4347..9cf9e2c431 100644 --- a/source/util/src/tsched.c +++ b/source/util/src/tsched.c @@ -149,18 +149,18 @@ void *taosProcessSchedQueue(void *scheduler) { return NULL; } -void taosScheduleTask(void *queueScheduler, SSchedMsg *pMsg) { +int taosScheduleTask(void *queueScheduler, SSchedMsg *pMsg) { SSchedQueue *pSched = (SSchedQueue *)queueScheduler; int32_t ret = 0; if (pSched == NULL) { uError("sched is not ready, msg:%p is dropped", pMsg); - return; + return -1; } if (atomic_load_8(&pSched->stop)) { uError("sched is already stopped, msg:%p is dropped", pMsg); - return; + return -1; } if ((ret = tsem_wait(&pSched->emptySem)) != 0) { @@ -185,6 +185,7 @@ void taosScheduleTask(void *queueScheduler, SSchedMsg *pMsg) { uFatal("post %s fullSem failed(%s)", pSched->label, strerror(errno)); ASSERT(0); } + return ret; } void taosCleanUpScheduler(void *param) { @@ -192,11 +193,11 @@ void taosCleanUpScheduler(void *param) { if (pSched == NULL) return; uDebug("start to cleanup %s schedQsueue", pSched->label); - + atomic_store_8(&pSched->stop, 1); taosMsleep(200); - + for (int32_t i = 0; i < pSched->numOfThreads; ++i) { if (taosCheckPthreadValid(pSched->qthread[i])) { tsem_post(&pSched->fullSem); @@ -220,7 +221,7 @@ void taosCleanUpScheduler(void *param) { if (pSched->queue) taosMemoryFree(pSched->queue); if (pSched->qthread) taosMemoryFree(pSched->qthread); - //taosMemoryFree(pSched); + // taosMemoryFree(pSched); } // for debug purpose, dump the scheduler status every 1min. From 9355996eb19f29910af5a4bcee38b96824211bbb Mon Sep 17 00:00:00 2001 From: Shuduo Sang Date: Tue, 13 Sep 2022 17:50:35 +0800 Subject: [PATCH 044/138] docs: change location to align with taosbenchmark --- docs/en/05-get-started/01-docker.md | 6 +++--- docs/en/05-get-started/03-package.md | 6 +++--- docs/en/14-reference/03-connector/06-rust.mdx | 6 +++--- .../src/main/java/com/taos/example/SubscribeDemo.java | 8 ++++---- .../com/taos/example/highvolume/MockDataSource.java | 4 ++-- docs/examples/python/mockdatasource.py | 10 +++++----- .../rust/nativeexample/examples/stmt_example.rs | 2 +- .../rust/nativeexample/examples/subscribe_demo.rs | 6 +++--- .../rust/restexample/examples/insert_example.rs | 8 ++++---- docs/zh/05-get-started/01-docker.md | 6 +++--- docs/zh/05-get-started/03-package.md | 6 +++--- docs/zh/08-connector/06-rust.mdx | 6 +++--- 12 files changed, 37 insertions(+), 37 deletions(-) diff --git a/docs/en/05-get-started/01-docker.md b/docs/en/05-get-started/01-docker.md index 66f7d5d594..6191492b37 100644 --- a/docs/en/05-get-started/01-docker.md +++ b/docs/en/05-get-started/01-docker.md @@ -52,7 +52,7 @@ Start TDengine service and execute `taosBenchmark` (formerly named `taosdemo`) i taosBenchmark ``` -This command creates the `meters` supertable in the `test` database. In the `meters` supertable, it then creates 10,000 subtables named `d0` to `d9999`. Each table has 10,000 rows and each row has four columns: `ts`, `current`, `voltage`, and `phase`. The timestamps of the data in these columns range from 2017-07-14 10:40:00 000 to 2017-07-14 10:40:09 999. Each table is randomly assigned a `groupId` tag from 1 to 10 and a `location` tag of either `Campbell`, `Cupertino`, `Los Angeles`, `Mountain View`, `Palo Alto`, `San Diego`, `San Francisco`, `San Jose`, `Santa Clara` or `Sunnyvale`. +This command creates the `meters` supertable in the `test` database. In the `meters` supertable, it then creates 10,000 subtables named `d0` to `d9999`. Each table has 10,000 rows and each row has four columns: `ts`, `current`, `voltage`, and `phase`. The timestamps of the data in these columns range from 2017-07-14 10:40:00 000 to 2017-07-14 10:40:09 999. Each table is randomly assigned a `groupId` tag from 1 to 10 and a `location` tag of either `California.Campbell`, `California.Cupertino`, `California.LosAngeles`, `California.MountainView`, `California.PaloAlto`, `California.SanDiego`, `California.SanFrancisco`, `California.SanJose`, `California.SantaClara` or `California.Sunnyvale`. The `taosBenchmark` command creates a deployment with 100 million data points that you can use for testing purposes. The time required to create the deployment depends on your hardware. On most modern servers, the deployment is created in ten to twenty seconds. @@ -74,10 +74,10 @@ Query the average, maximum, and minimum values of all 100 million rows of data: SELECT AVG(current), MAX(voltage), MIN(phase) FROM test.meters; ``` -Query the number of rows whose `location` tag is `San Francisco`: +Query the number of rows whose `location` tag is `California.SanFrancisco`: ```sql -SELECT COUNT(*) FROM test.meters WHERE location = "San Francisco"; +SELECT COUNT(*) FROM test.meters WHERE location = "California.SanFrancisco"; ``` Query the average, maximum, and minimum values of all rows whose `groupId` tag is `10`: diff --git a/docs/en/05-get-started/03-package.md b/docs/en/05-get-started/03-package.md index 7257fccc80..b0400de673 100644 --- a/docs/en/05-get-started/03-package.md +++ b/docs/en/05-get-started/03-package.md @@ -221,7 +221,7 @@ Start TDengine service and execute `taosBenchmark` (formerly named `taosdemo`) i taosBenchmark ``` -This command creates the `meters` supertable in the `test` database. In the `meters` supertable, it then creates 10,000 subtables named `d0` to `d9999`. Each table has 10,000 rows and each row has four columns: `ts`, `current`, `voltage`, and `phase`. The timestamps of the data in these columns range from 2017-07-14 10:40:00 000 to 2017-07-14 10:40:09 999. Each table is randomly assigned a `groupId` tag from 1 to 10 and a `location` tag of either `Campbell`, `Cupertino`, `Los Angeles`, `Mountain View`, `Palo Alto`, `San Diego`, `San Francisco`, `San Jose`, `Santa Clara` or `Sunnyvale`. +This command creates the `meters` supertable in the `test` database. In the `meters` supertable, it then creates 10,000 subtables named `d0` to `d9999`. Each table has 10,000 rows and each row has four columns: `ts`, `current`, `voltage`, and `phase`. The timestamps of the data in these columns range from 2017-07-14 10:40:00 000 to 2017-07-14 10:40:09 999. Each table is randomly assigned a `groupId` tag from 1 to 10 and a `location` tag of either `California.Campbell`, `California.Cupertino`, `California.LosAngeles`, `California.MountainView`, `California.PaloAlto`, `California.SanDiego`, `California.SanFrancisco`, `California.SanJose`, `California.SantaClara` or `California.Sunnyvale`. The `taosBenchmark` command creates a deployment with 100 million data points that you can use for testing purposes. The time required to create the deployment depends on your hardware. On most modern servers, the deployment is created in ten to twenty seconds. @@ -243,10 +243,10 @@ Query the average, maximum, and minimum values of all 100 million rows of data: SELECT AVG(current), MAX(voltage), MIN(phase) FROM test.meters; ``` -Query the number of rows whose `location` tag is `San Francisco`: +Query the number of rows whose `location` tag is `California.SanFrancisco`: ```sql -SELECT COUNT(*) FROM test.meters WHERE location = "San Francisco"; +SELECT COUNT(*) FROM test.meters WHERE location = "California.SanFrancisco"; ``` Query the average, maximum, and minimum values of all rows whose `groupId` tag is `10`: diff --git a/docs/en/14-reference/03-connector/06-rust.mdx b/docs/en/14-reference/03-connector/06-rust.mdx index 0d391c6ac3..530287e2a4 100644 --- a/docs/en/14-reference/03-connector/06-rust.mdx +++ b/docs/en/14-reference/03-connector/06-rust.mdx @@ -155,15 +155,15 @@ async fn demo(taos: &Taos, db: &str) -> Result<(), Error> { let inserted = taos.exec_many([ // create super table "CREATE TABLE `meters` (`ts` TIMESTAMP, `current` FLOAT, `voltage` INT, `phase` FLOAT) \ - TAGS (`groupid` INT, `location` BINARY(16))", + TAGS (`groupid` INT, `location` BINARY(24))", // create child table - "CREATE TABLE `d0` USING `meters` TAGS(0, 'Los Angles')", + "CREATE TABLE `d0` USING `meters` TAGS(0, 'California.LosAngles')", // insert into child table "INSERT INTO `d0` values(now - 10s, 10, 116, 0.32)", // insert with NULL values "INSERT INTO `d0` values(now - 8s, NULL, NULL, NULL)", // insert and automatically create table with tags if not exists - "INSERT INTO `d1` USING `meters` TAGS(1, 'San Francisco') values(now - 9s, 10.1, 119, 0.33)", + "INSERT INTO `d1` USING `meters` TAGS(1, 'California.SanFrancisco') values(now - 9s, 10.1, 119, 0.33)", // insert many records in a single sql "INSERT INTO `d1` values (now-8s, 10, 120, 0.33) (now - 6s, 10, 119, 0.34) (now - 4s, 11.2, 118, 0.322)", ]).await?; diff --git a/docs/examples/java/src/main/java/com/taos/example/SubscribeDemo.java b/docs/examples/java/src/main/java/com/taos/example/SubscribeDemo.java index 179e6e6911..e9af5e9ce0 100644 --- a/docs/examples/java/src/main/java/com/taos/example/SubscribeDemo.java +++ b/docs/examples/java/src/main/java/com/taos/example/SubscribeDemo.java @@ -38,12 +38,12 @@ public class SubscribeDemo { statement.executeUpdate("create database " + DB_NAME); statement.executeUpdate("use " + DB_NAME); statement.executeUpdate( - "CREATE TABLE `meters` (`ts` TIMESTAMP, `current` FLOAT, `voltage` INT) TAGS (`groupid` INT, `location` BINARY(16))"); - statement.executeUpdate("CREATE TABLE `d0` USING `meters` TAGS(0, 'Los Angles')"); + "CREATE TABLE `meters` (`ts` TIMESTAMP, `current` FLOAT, `voltage` INT) TAGS (`groupid` INT, `location` BINARY(24))"); + statement.executeUpdate("CREATE TABLE `d0` USING `meters` TAGS(0, 'California.LosAngles')"); statement.executeUpdate("INSERT INTO `d0` values(now - 10s, 0.32, 116)"); statement.executeUpdate("INSERT INTO `d0` values(now - 8s, NULL, NULL)"); statement.executeUpdate( - "INSERT INTO `d1` USING `meters` TAGS(1, 'San Francisco') values(now - 9s, 10.1, 119)"); + "INSERT INTO `d1` USING `meters` TAGS(1, 'California.SanFrancisco') values(now - 9s, 10.1, 119)"); statement.executeUpdate( "INSERT INTO `d1` values (now-8s, 10, 120) (now - 6s, 10, 119) (now - 4s, 11.2, 118)"); // create topic @@ -75,4 +75,4 @@ public class SubscribeDemo { } timer.cancel(); } -} \ No newline at end of file +} diff --git a/docs/examples/java/src/main/java/com/taos/example/highvolume/MockDataSource.java b/docs/examples/java/src/main/java/com/taos/example/highvolume/MockDataSource.java index 6fe83f002e..f0ebc53b4b 100644 --- a/docs/examples/java/src/main/java/com/taos/example/highvolume/MockDataSource.java +++ b/docs/examples/java/src/main/java/com/taos/example/highvolume/MockDataSource.java @@ -16,7 +16,7 @@ class MockDataSource implements Iterator { private int currentTbId = -1; // mock values - String[] location = {"LosAngeles", "SanDiego", "Hollywood", "Compton", "San Francisco"}; + String[] location = {"California.LosAngeles", "California.SanDiego", "California.SanJose", "California.Campbell", "California.SanFrancisco"}; float[] current = {8.8f, 10.7f, 9.9f, 8.9f, 9.4f}; int[] voltage = {119, 116, 111, 113, 118}; float[] phase = {0.32f, 0.34f, 0.33f, 0.329f, 0.141f}; @@ -50,4 +50,4 @@ class MockDataSource implements Iterator { return sb.toString(); } -} \ No newline at end of file +} diff --git a/docs/examples/python/mockdatasource.py b/docs/examples/python/mockdatasource.py index 852860aec0..1c516a800e 100644 --- a/docs/examples/python/mockdatasource.py +++ b/docs/examples/python/mockdatasource.py @@ -3,11 +3,11 @@ import time class MockDataSource: samples = [ - "8.8,119,0.32,LosAngeles,0", - "10.7,116,0.34,SanDiego,1", - "9.9,111,0.33,Hollywood,2", - "8.9,113,0.329,Compton,3", - "9.4,118,0.141,San Francisco,4" + "8.8,119,0.32,California.LosAngeles,0", + "10.7,116,0.34,California.SanDiego,1", + "9.9,111,0.33,California.SanJose,2", + "8.9,113,0.329,California.Campbell,3", + "9.4,118,0.141,California.SanFrancisco,4" ] def __init__(self, tb_name_prefix, table_count): diff --git a/docs/examples/rust/nativeexample/examples/stmt_example.rs b/docs/examples/rust/nativeexample/examples/stmt_example.rs index 26084746f2..9cf8e8e1fc 100644 --- a/docs/examples/rust/nativeexample/examples/stmt_example.rs +++ b/docs/examples/rust/nativeexample/examples/stmt_example.rs @@ -12,7 +12,7 @@ async fn main() -> anyhow::Result<()> { // bind table name and tags stmt.set_tbname_tags( "d1001", - &[Value::VarChar("San Fransico".into()), Value::Int(2)], + &[Value::VarChar("California.SanFransico".into()), Value::Int(2)], )?; // bind values. let values = vec![ diff --git a/docs/examples/rust/nativeexample/examples/subscribe_demo.rs b/docs/examples/rust/nativeexample/examples/subscribe_demo.rs index 7e0a347948..11d6d4e004 100644 --- a/docs/examples/rust/nativeexample/examples/subscribe_demo.rs +++ b/docs/examples/rust/nativeexample/examples/subscribe_demo.rs @@ -19,13 +19,13 @@ struct Record { async fn prepare(taos: Taos) -> anyhow::Result<()> { let inserted = taos.exec_many([ // create child table - "CREATE TABLE `d0` USING `meters` TAGS(0, 'Los Angles')", + "CREATE TABLE `d0` USING `meters` TAGS(0, 'California.LosAngles')", // insert into child table "INSERT INTO `d0` values(now - 10s, 10, 116, 0.32)", // insert with NULL values "INSERT INTO `d0` values(now - 8s, NULL, NULL, NULL)", // insert and automatically create table with tags if not exists - "INSERT INTO `d1` USING `meters` TAGS(1, 'San Francisco') values(now - 9s, 10.1, 119, 0.33)", + "INSERT INTO `d1` USING `meters` TAGS(1, 'California.SanFrancisco') values(now - 9s, 10.1, 119, 0.33)", // insert many records in a single sql "INSERT INTO `d1` values (now-8s, 10, 120, 0.33) (now - 6s, 10, 119, 0.34) (now - 4s, 11.2, 118, 0.322)", ]).await?; @@ -48,7 +48,7 @@ async fn main() -> anyhow::Result<()> { format!("CREATE DATABASE `{db}`"), format!("USE `{db}`"), // create super table - format!("CREATE TABLE `meters` (`ts` TIMESTAMP, `current` FLOAT, `voltage` INT, `phase` FLOAT) TAGS (`groupid` INT, `location` BINARY(16))"), + format!("CREATE TABLE `meters` (`ts` TIMESTAMP, `current` FLOAT, `voltage` INT, `phase` FLOAT) TAGS (`groupid` INT, `location` BINARY(24))"), // create topic for subscription format!("CREATE TOPIC tmq_meters with META AS DATABASE {db}") ]) diff --git a/docs/examples/rust/restexample/examples/insert_example.rs b/docs/examples/rust/restexample/examples/insert_example.rs index 27b2bb4788..11a84f1661 100644 --- a/docs/examples/rust/restexample/examples/insert_example.rs +++ b/docs/examples/rust/restexample/examples/insert_example.rs @@ -14,14 +14,14 @@ async fn main() -> anyhow::Result<()> { ]).await?; let inserted = taos.exec("INSERT INTO - power.d1001 USING power.meters TAGS('San Francisco', 2) + power.d1001 USING power.meters TAGS('California.SanFrancisco', 2) VALUES ('2018-10-03 14:38:05.000', 10.30000, 219, 0.31000) ('2018-10-03 14:38:15.000', 12.60000, 218, 0.33000) ('2018-10-03 14:38:16.800', 12.30000, 221, 0.31000) - power.d1002 USING power.meters TAGS('San Francisco', 3) + power.d1002 USING power.meters TAGS('California.SanFrancisco', 3) VALUES ('2018-10-03 14:38:16.650', 10.30000, 218, 0.25000) - power.d1003 USING power.meters TAGS('Los Angeles', 2) + power.d1003 USING power.meters TAGS('California.LosAngeles', 2) VALUES ('2018-10-03 14:38:05.500', 11.80000, 221, 0.28000) ('2018-10-03 14:38:16.600', 13.40000, 223, 0.29000) - power.d1004 USING power.meters TAGS('Los Angeles', 3) + power.d1004 USING power.meters TAGS('California.LosAngeles', 3) VALUES ('2018-10-03 14:38:05.000', 10.80000, 223, 0.29000) ('2018-10-03 14:38:06.500', 11.50000, 221, 0.35000)").await?; assert_eq!(inserted, 8); diff --git a/docs/zh/05-get-started/01-docker.md b/docs/zh/05-get-started/01-docker.md index e3345fed96..0f004581b5 100644 --- a/docs/zh/05-get-started/01-docker.md +++ b/docs/zh/05-get-started/01-docker.md @@ -52,7 +52,7 @@ taos> $ taosBenchmark ``` -该命令将在数据库 `test` 下面自动创建一张超级表 `meters`，该超级表下有 1 万张表，表名为 `d0` 到 `d9999`，每张表有 1 万条记录，每条记录有 `ts`、`current`、`voltage`、`phase` 四个字段，时间戳从 2017-07-14 10:40:00 000 到 2017-07-14 10:40:09 999，每张表带有标签 `location` 和 `groupId`，groupId 被设置为 1 到 10，location 被设置为 `Campbell`、`Cupertino`、`Los Angeles`、`Mountain View`、`Palo Alto`、`San Diego`、`San Francisco`、`San Jose`、`Santa Clara` 或者 `Sunnyvale`。 +该命令将在数据库 `test` 下面自动创建一张超级表 `meters`，该超级表下有 1 万张表，表名为 `d0` 到 `d9999`，每张表有 1 万条记录，每条记录有 `ts`、`current`、`voltage`、`phase` 四个字段，时间戳从 2017-07-14 10:40:00 000 到 2017-07-14 10:40:09 999，每张表带有标签 `location` 和 `groupId`，groupId 被设置为 1 到 10，location 被设置为 `California.Campbell`、`California.Cupertino`、`California.LosAngeles`、`California.MountainView`、`California.PaloAlto`、`California.SanDiego`、`California.SanFrancisco`、`California.SanJose`、`California.SantaClara` 或者 `California.Sunnyvale`。 这条命令很快完成 1 亿条记录的插入。具体时间取决于硬件性能，即使在一台普通的 PC 服务器往往也仅需十几秒。 @@ -74,10 +74,10 @@ SELECT COUNT(*) FROM test.meters; SELECT AVG(current), MAX(voltage), MIN(phase) FROM test.meters; ``` -查询 location = "San Francisco" 的记录总条数： +查询 location = "California.SanFrancisco" 的记录总条数： ```sql -SELECT COUNT(*) FROM test.meters WHERE location = "San Francisco"; +SELECT COUNT(*) FROM test.meters WHERE location = "California.SanFrancisco"; ``` 查询 groupId = 10 的所有记录的平均值、最大值、最小值等： diff --git a/docs/zh/05-get-started/03-package.md b/docs/zh/05-get-started/03-package.md index cb2553a0bf..66863d1bd9 100644 --- a/docs/zh/05-get-started/03-package.md +++ b/docs/zh/05-get-started/03-package.md @@ -223,7 +223,7 @@ Query OK, 2 row(s) in set (0.003128s) $ taosBenchmark ``` -该命令将在数据库 `test` 下面自动创建一张超级表 `meters`，该超级表下有 1 万张表，表名为 `d0` 到 `d9999`，每张表有 1 万条记录，每条记录有 `ts`、`current`、`voltage`、`phase` 四个字段，时间戳从 2017-07-14 10:40:00 000 到 2017-07-14 10:40:09 999，每张表带有标签 `location` 和 `groupId`，groupId 被设置为 1 到 10，location 被设置为 `Campbell`、`Cupertino`、`Los Angeles`、`Mountain View`、`Palo Alto`、`San Diego`、`San Francisco`、`San Jose`、`Santa Clara` 或者 `Sunnyvale`。 +该命令将在数据库 `test` 下面自动创建一张超级表 `meters`，该超级表下有 1 万张表，表名为 `d0` 到 `d9999`，每张表有 1 万条记录，每条记录有 `ts`、`current`、`voltage`、`phase` 四个字段，时间戳从 2017-07-14 10:40:00 000 到 2017-07-14 10:40:09 999，每张表带有标签 `location` 和 `groupId`，groupId 被设置为 1 到 10，location 被设置为 `California.Campbell`、`California.Cupertino`、`California.LosAngeles`、`California.MountainView`、`California.PaloAlto`、`California.SanDiego`、`California.SanFrancisco`、`California.SanJose`、`California.SantaClara` 或者 `California.Sunnyvale`。 这条命令很快完成 1 亿条记录的插入。具体时间取决于硬件性能，即使在一台普通的 PC 服务器往往也仅需十几秒。 @@ -245,10 +245,10 @@ SELECT COUNT(*) FROM test.meters; SELECT AVG(current), MAX(voltage), MIN(phase) FROM test.meters; ``` -查询 location = "San Francisco" 的记录总条数： +查询 location = "California.SanFrancisco" 的记录总条数： ```sql -SELECT COUNT(*) FROM test.meters WHERE location = "San Francisco"; +SELECT COUNT(*) FROM test.meters WHERE location = "Calaifornia.SanFrancisco"; ``` 查询 groupId = 10 的所有记录的平均值、最大值、最小值等： diff --git a/docs/zh/08-connector/06-rust.mdx b/docs/zh/08-connector/06-rust.mdx index 26f53c82d6..b838e5c5a2 100644 --- a/docs/zh/08-connector/06-rust.mdx +++ b/docs/zh/08-connector/06-rust.mdx @@ -155,15 +155,15 @@ async fn demo(taos: &Taos, db: &str) -> Result<(), Error> { let inserted = taos.exec_many([ // create super table "CREATE TABLE `meters` (`ts` TIMESTAMP, `current` FLOAT, `voltage` INT, `phase` FLOAT) \ - TAGS (`groupid` INT, `location` BINARY(16))", + TAGS (`groupid` INT, `location` BINARY(24))", // create child table - "CREATE TABLE `d0` USING `meters` TAGS(0, 'Los Angles')", + "CREATE TABLE `d0` USING `meters` TAGS(0, 'California.LosAngles')", // insert into child table "INSERT INTO `d0` values(now - 10s, 10, 116, 0.32)", // insert with NULL values "INSERT INTO `d0` values(now - 8s, NULL, NULL, NULL)", // insert and automatically create table with tags if not exists - "INSERT INTO `d1` USING `meters` TAGS(1, 'San Francisco') values(now - 9s, 10.1, 119, 0.33)", + "INSERT INTO `d1` USING `meters` TAGS(1, 'California.SanFrancisco') values(now - 9s, 10.1, 119, 0.33)", // insert many records in a single sql "INSERT INTO `d1` values (now-8s, 10, 120, 0.33) (now - 6s, 10, 119, 0.34) (now - 4s, 11.2, 118, 0.322)", ]).await?; From b84017f2b90f8e7900eb424cf180ed451b191485 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Tue, 13 Sep 2022 17:49:35 +0800 Subject: [PATCH 045/138] feat: database option 'tsdb_pagesize' --- include/common/tmsg.h | 1 + source/common/src/systable.c | 3 ++- source/common/src/tmsg.c | 2 ++ source/dnode/mgmt/mgmt_vnode/src/vmHandle.c | 9 ++++++--- source/dnode/mnode/impl/inc/mndDef.h | 1 + source/dnode/mnode/impl/src/mndDb.c | 20 +++++++++++++++++++- source/dnode/mnode/impl/src/mndVgroup.c | 3 ++- source/dnode/vnode/src/vnd/vnodeCfg.c | 9 ++++++--- 8 files changed, 39 insertions(+), 9 deletions(-) diff --git a/include/common/tmsg.h b/include/common/tmsg.h index d3db2f318c..dfce7e54d0 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -1201,6 +1201,7 @@ typedef struct { int16_t sstTrigger; int16_t hashPrefix; int16_t hashSuffix; + int32_t tsdbPageSize; } SCreateVnodeReq; int32_t tSerializeSCreateVnodeReq(void* buf, int32_t bufLen, SCreateVnodeReq* pReq); diff --git a/source/common/src/systable.c b/source/common/src/systable.c index f77320c5ac..496806d877 100644 --- a/source/common/src/systable.c +++ b/source/common/src/systable.c @@ -102,9 +102,10 @@ static const SSysDbTableSchema userDBSchema[] = { {.name = "wal_retention_size", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT, .sysInfo = true}, {.name = "wal_roll_period", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true}, {.name = "wal_segment_size", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT, .sysInfo = true}, - {.name = "sst_trigger", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT, .sysInfo = true}, + {.name = "stt_trigger", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT, .sysInfo = true}, {.name = "table_prefix", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT, .sysInfo = true}, {.name = "table_suffix", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT, .sysInfo = true}, + {.name = "tsdb_pagesize", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true}, }; static const SSysDbTableSchema userFuncSchema[] = { diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index 7d8461ca60..cbd6bc3ed7 100644 --- a/source/common/src/tmsg.c +++ b/source/common/src/tmsg.c @@ -3782,6 +3782,7 @@ int32_t tSerializeSCreateVnodeReq(void *buf, int32_t bufLen, SCreateVnodeReq *pR if (tEncodeI16(&encoder, pReq->sstTrigger) < 0) return -1; if (tEncodeI16(&encoder, pReq->hashPrefix) < 0) return -1; if (tEncodeI16(&encoder, pReq->hashSuffix) < 0) return -1; + if (tEncodeI32(&encoder, pReq->tsdbPageSize) < 0) return -1; tEndEncode(&encoder); @@ -3857,6 +3858,7 @@ int32_t tDeserializeSCreateVnodeReq(void *buf, int32_t bufLen, SCreateVnodeReq * if (tDecodeI16(&decoder, &pReq->sstTrigger) < 0) return -1; if (tDecodeI16(&decoder, &pReq->hashPrefix) < 0) return -1; if (tDecodeI16(&decoder, &pReq->hashSuffix) < 0) return -1; + if (tDecodeI32(&decoder, &pReq->tsdbPageSize) < 0) return -1; tEndDecode(&decoder); tDecoderClear(&decoder); diff --git a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c index 981576efec..3d292f6463 100644 --- a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c +++ b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c @@ -173,6 +173,7 @@ static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) { pCfg->hashMethod = pCreate->hashMethod; pCfg->hashPrefix = pCreate->hashPrefix; pCfg->hashSuffix = pCreate->hashSuffix; + pCfg->tsdbPageSize = pCreate->tsdbPageSize; pCfg->standby = pCfg->standby; pCfg->syncCfg.myIndex = pCreate->selfIndex; @@ -222,9 +223,11 @@ int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { return -1; } - dInfo("vgId:%d, start to create vnode, tsma:%d standby:%d cacheLast:%d cacheLastSize:%d sstTrigger:%d", - createReq.vgId, createReq.isTsma, createReq.standby, createReq.cacheLast, createReq.cacheLastSize, - createReq.sstTrigger); + dInfo( + "vgId:%d, start to create vnode, tsma:%d standby:%d cacheLast:%d cacheLastSize:%d sstTrigger:%d " + "tsdbPageSize:%d", + createReq.vgId, createReq.isTsma, createReq.standby, createReq.cacheLast, createReq.cacheLastSize, + createReq.sstTrigger, createReq.tsdbPageSize); dInfo("vgId:%d, hashMethod:%d begin:%u end:%u prefix:%d surfix:%d", createReq.vgId, createReq.hashMethod, createReq.hashBegin, createReq.hashEnd, createReq.hashPrefix, createReq.hashSuffix); vmGenerateVnodeCfg(&createReq, &vnodeCfg); diff --git a/source/dnode/mnode/impl/inc/mndDef.h b/source/dnode/mnode/impl/inc/mndDef.h index 9632be1b24..cd08ee4ad5 100644 --- a/source/dnode/mnode/impl/inc/mndDef.h +++ b/source/dnode/mnode/impl/inc/mndDef.h @@ -308,6 +308,7 @@ typedef struct { int16_t hashPrefix; int16_t hashSuffix; int16_t sstTrigger; + int32_t tsdbPageSize; int32_t numOfRetensions; SArray* pRetensions; int32_t walRetentionPeriod; diff --git a/source/dnode/mnode/impl/src/mndDb.c b/source/dnode/mnode/impl/src/mndDb.c index 9e58b74017..d42ba1f7ff 100644 --- a/source/dnode/mnode/impl/src/mndDb.c +++ b/source/dnode/mnode/impl/src/mndDb.c @@ -31,7 +31,7 @@ #include "systable.h" #define DB_VER_NUMBER 1 -#define DB_RESERVE_SIZE 58 +#define DB_RESERVE_SIZE 54 static SSdbRaw *mndDbActionEncode(SDbObj *pDb); static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw); @@ -128,6 +128,7 @@ static SSdbRaw *mndDbActionEncode(SDbObj *pDb) { SDB_SET_INT16(pRaw, dataPos, pDb->cfg.sstTrigger, _OVER) SDB_SET_INT16(pRaw, dataPos, pDb->cfg.hashPrefix, _OVER) SDB_SET_INT16(pRaw, dataPos, pDb->cfg.hashSuffix, _OVER) + SDB_SET_INT32(pRaw, dataPos, pDb->cfg.tsdbPageSize, _OVER) SDB_SET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER) SDB_SET_DATALEN(pRaw, dataPos, _OVER) @@ -214,10 +215,20 @@ static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw) { SDB_GET_INT16(pRaw, dataPos, &pDb->cfg.sstTrigger, _OVER) SDB_GET_INT16(pRaw, dataPos, &pDb->cfg.hashPrefix, _OVER) SDB_GET_INT16(pRaw, dataPos, &pDb->cfg.hashSuffix, _OVER) + SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.tsdbPageSize, _OVER) SDB_GET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER) taosInitRWLatch(&pDb->lock); + if (pDb->cfg.tsdbPageSize <= TSDB_MIN_TSDB_PAGESIZE) { + mInfo("db:%s, tsdbPageSize set from %d to default %d", pDb->name, pDb->cfg.tsdbPageSize, + TSDB_DEFAULT_TSDB_PAGESIZE); + } + + if (pDb->cfg.sstTrigger <= TSDB_MIN_STT_TRIGGER) { + mInfo("db:%s, sstTrigger set from %d to default %d", pDb->name, pDb->cfg.sstTrigger, TSDB_DEFAULT_SST_TRIGGER); + } + terrno = 0; _OVER: @@ -262,6 +273,7 @@ static int32_t mndDbActionUpdate(SSdb *pSdb, SDbObj *pOld, SDbObj *pNew) { pOld->cfg.cacheLast = pNew->cfg.cacheLast; pOld->cfg.replications = pNew->cfg.replications; pOld->cfg.sstTrigger = pNew->cfg.sstTrigger; + pOld->cfg.tsdbPageSize = pNew->cfg.tsdbPageSize; taosWUnLockLatch(&pOld->lock); return 0; } @@ -341,6 +353,7 @@ static int32_t mndCheckDbCfg(SMnode *pMnode, SDbCfg *pCfg) { if (pCfg->sstTrigger < TSDB_MIN_STT_TRIGGER || pCfg->sstTrigger > TSDB_MAX_STT_TRIGGER) return -1; if (pCfg->hashPrefix < TSDB_MIN_HASH_PREFIX || pCfg->hashPrefix > TSDB_MAX_HASH_PREFIX) return -1; if (pCfg->hashSuffix < TSDB_MIN_HASH_SUFFIX || pCfg->hashSuffix > TSDB_MAX_HASH_SUFFIX) return -1; + if (pCfg->tsdbPageSize < TSDB_MIN_TSDB_PAGESIZE || pCfg->tsdbPageSize > TSDB_MAX_TSDB_PAGESIZE) return -1; terrno = 0; return terrno; @@ -377,6 +390,7 @@ static void mndSetDefaultDbCfg(SDbCfg *pCfg) { if (pCfg->sstTrigger <= 0) pCfg->sstTrigger = TSDB_DEFAULT_SST_TRIGGER; if (pCfg->hashPrefix < 0) pCfg->hashPrefix = TSDB_DEFAULT_HASH_PREFIX; if (pCfg->hashSuffix < 0) pCfg->hashSuffix = TSDB_DEFAULT_HASH_SUFFIX; + if (pCfg->tsdbPageSize <= 0) pCfg->tsdbPageSize = TSDB_DEFAULT_TSDB_PAGESIZE; } static int32_t mndSetCreateDbRedoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups) { @@ -496,6 +510,7 @@ static int32_t mndCreateDb(SMnode *pMnode, SRpcMsg *pReq, SCreateDbReq *pCreate, .sstTrigger = pCreate->sstTrigger, .hashPrefix = pCreate->hashPrefix, .hashSuffix = pCreate->hashSuffix, + .tsdbPageSize = pCreate->tsdbPageSize, }; dbObj.cfg.numOfRetensions = pCreate->numOfRetensions; @@ -1726,6 +1741,9 @@ static void mndDumpDbInfoData(SMnode *pMnode, SSDataBlock *pBlock, SDbObj *pDb, pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.hashSuffix, false); + + pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); + colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.tsdbPageSize, false); } taosMemoryFree(buf); diff --git a/source/dnode/mnode/impl/src/mndVgroup.c b/source/dnode/mnode/impl/src/mndVgroup.c index de29dea511..f71b46ce34 100644 --- a/source/dnode/mnode/impl/src/mndVgroup.c +++ b/source/dnode/mnode/impl/src/mndVgroup.c @@ -237,7 +237,8 @@ void *mndBuildCreateVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVg createReq.sstTrigger = pDb->cfg.sstTrigger; createReq.hashPrefix = pDb->cfg.hashPrefix; createReq.hashSuffix = pDb->cfg.hashSuffix; - +createReq.tsdbPageSize = pDb->cfg.tsdbPageSize; + for (int32_t v = 0; v < pVgroup->replica; ++v) { SReplica *pReplica = &createReq.replicas[v]; SVnodeGid *pVgid = &pVgroup->vnodeGid[v]; diff --git a/source/dnode/vnode/src/vnd/vnodeCfg.c b/source/dnode/vnode/src/vnd/vnodeCfg.c index 9ed72eeecd..ac13dd8a4e 100644 --- a/source/dnode/vnode/src/vnd/vnodeCfg.c +++ b/source/dnode/vnode/src/vnd/vnodeCfg.c @@ -115,6 +115,7 @@ int vnodeEncodeConfig(const void *pObj, SJson *pJson) { if (tjsonAddIntegerToObject(pJson, "hashMethod", pCfg->hashMethod) < 0) return -1; if (tjsonAddIntegerToObject(pJson, "hashPrefix", pCfg->hashPrefix) < 0) return -1; if (tjsonAddIntegerToObject(pJson, "hashSuffix", pCfg->hashSuffix) < 0) return -1; + if (tjsonAddIntegerToObject(pJson, "tsdbPageSize", pCfg->tsdbPageSize) < 0) return -1; if (tjsonAddIntegerToObject(pJson, "syncCfg.replicaNum", pCfg->syncCfg.replicaNum) < 0) return -1; if (tjsonAddIntegerToObject(pJson, "syncCfg.myIndex", pCfg->syncCfg.myIndex) < 0) return -1; @@ -215,7 +216,7 @@ int vnodeDecodeConfig(const SJson *pJson, void *pObj) { tjsonGetNumberValue(pJson, "wal.level", pCfg->walCfg.level, code); if (code < 0) return -1; tjsonGetNumberValue(pJson, "sstTrigger", pCfg->sttTrigger, code); - if (code < 0) return -1; + if (code < 0) pCfg->sttTrigger = TSDB_DEFAULT_SST_TRIGGER; tjsonGetNumberValue(pJson, "hashBegin", pCfg->hashBegin, code); if (code < 0) return -1; tjsonGetNumberValue(pJson, "hashEnd", pCfg->hashEnd, code); @@ -223,9 +224,11 @@ int vnodeDecodeConfig(const SJson *pJson, void *pObj) { tjsonGetNumberValue(pJson, "hashMethod", pCfg->hashMethod, code); if (code < 0) return -1; tjsonGetNumberValue(pJson, "hashPrefix", pCfg->hashPrefix, code); - if (code < 0) return -1; + if (code < 0) pCfg->hashPrefix = TSDB_DEFAULT_HASH_PREFIX; tjsonGetNumberValue(pJson, "hashSuffix", pCfg->hashSuffix, code); - if (code < 0) return -1; + if (code < 0) pCfg->hashSuffix = TSDB_DEFAULT_HASH_SUFFIX; + tjsonGetNumberValue(pJson, "tsdbPageSize", pCfg->tsdbPageSize, code); + if (code < 0) pCfg->tsdbPageSize = TSDB_DEFAULT_TSDB_PAGESIZE; tjsonGetNumberValue(pJson, "syncCfg.replicaNum", pCfg->syncCfg.replicaNum, code); if (code < 0) return -1; From 6b2bf42f6824df1599303768160cfc403c04b7c1 Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Tue, 13 Sep 2022 16:45:40 +0800 Subject: [PATCH 046/138] fix(query): twa function output NULL if input has overlap timestamps TD-18224 --- include/util/taoserror.h | 1 + source/libs/function/src/builtinsimpl.c | 30 +++++++++---------------- source/util/src/terror.c | 1 + 3 files changed, 12 insertions(+), 20 deletions(-) diff --git a/include/util/taoserror.h b/include/util/taoserror.h index d16a599811..0058b03b30 100644 --- a/include/util/taoserror.h +++ b/include/util/taoserror.h @@ -577,6 +577,7 @@ int32_t* taosGetErrno(); #define TSDB_CODE_FUNC_FUNTION_PARA_TYPE TAOS_DEF_ERROR_CODE(0, 0x2802) #define TSDB_CODE_FUNC_FUNTION_PARA_VALUE TAOS_DEF_ERROR_CODE(0, 0x2803) #define TSDB_CODE_FUNC_NOT_BUILTIN_FUNTION TAOS_DEF_ERROR_CODE(0, 0x2804) +#define TSDB_CODE_FUNC_DUP_TIMESTAMP TAOS_DEF_ERROR_CODE(0, 0x012B) //udf #define TSDB_CODE_UDF_STOPPING TAOS_DEF_ERROR_CODE(0, 0x2901) diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c index 35e3e07839..7d8c231c15 100644 --- a/source/libs/function/src/builtinsimpl.c +++ b/source/libs/function/src/builtinsimpl.c @@ -5447,8 +5447,7 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { numOfElems++; if (pInfo->p.key == st.key) { - numOfElems = 0; - goto _twa_over; + return TSDB_CODE_FUNC_DUP_TIMESTAMP; } INIT_INTP_POINT(st, tsList[i], val[i]); @@ -5467,8 +5466,7 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { numOfElems++; if (pInfo->p.key == st.key) { - numOfElems = 0; - goto _twa_over; + return TSDB_CODE_FUNC_DUP_TIMESTAMP; } INIT_INTP_POINT(st, tsList[i], val[i]); @@ -5486,8 +5484,7 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { numOfElems++; if (pInfo->p.key == st.key) { - numOfElems = 0; - goto _twa_over; + return TSDB_CODE_FUNC_DUP_TIMESTAMP; } INIT_INTP_POINT(st, tsList[i], val[i]); @@ -5505,8 +5502,7 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { numOfElems++; if (pInfo->p.key == st.key) { - numOfElems = 0; - goto _twa_over; + return TSDB_CODE_FUNC_DUP_TIMESTAMP; } INIT_INTP_POINT(st, tsList[i], val[i]); @@ -5524,8 +5520,7 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { numOfElems++; if (pInfo->p.key == st.key) { - numOfElems = 0; - goto _twa_over; + return TSDB_CODE_FUNC_DUP_TIMESTAMP; } INIT_INTP_POINT(st, tsList[i], val[i]); @@ -5543,8 +5538,7 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { numOfElems++; if (pInfo->p.key == st.key) { - numOfElems = 0; - goto _twa_over; + return TSDB_CODE_FUNC_DUP_TIMESTAMP; } INIT_INTP_POINT(st, tsList[i], val[i]); @@ -5562,8 +5556,7 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { numOfElems++; if (pInfo->p.key == st.key) { - numOfElems = 0; - goto _twa_over; + return TSDB_CODE_FUNC_DUP_TIMESTAMP; } INIT_INTP_POINT(st, tsList[i], val[i]); @@ -5581,8 +5574,7 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { numOfElems++; if (pInfo->p.key == st.key) { - numOfElems = 0; - goto _twa_over; + return TSDB_CODE_FUNC_DUP_TIMESTAMP; } INIT_INTP_POINT(st, tsList[i], val[i]); @@ -5600,8 +5592,7 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { numOfElems++; if (pInfo->p.key == st.key) { - numOfElems = 0; - goto _twa_over; + return TSDB_CODE_FUNC_DUP_TIMESTAMP; } INIT_INTP_POINT(st, tsList[i], val[i]); @@ -5619,8 +5610,7 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { numOfElems++; if (pInfo->p.key == st.key) { - numOfElems = 0; - goto _twa_over; + return TSDB_CODE_FUNC_DUP_TIMESTAMP; } INIT_INTP_POINT(st, tsList[i], val[i]); diff --git a/source/util/src/terror.c b/source/util/src/terror.c index 044cdc86b4..ab0771d218 100644 --- a/source/util/src/terror.c +++ b/source/util/src/terror.c @@ -579,6 +579,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_FUNC_FUNTION_PARA_NUM, "Invalid function par TAOS_DEFINE_ERROR(TSDB_CODE_FUNC_FUNTION_PARA_TYPE, "Invalid function para type") TAOS_DEFINE_ERROR(TSDB_CODE_FUNC_FUNTION_PARA_VALUE, "Invalid function para value") TAOS_DEFINE_ERROR(TSDB_CODE_FUNC_NOT_BUILTIN_FUNTION, "Not buildin function") +TAOS_DEFINE_ERROR(TSDB_CODE_FUNC_DUP_TIMESTAMP, "Duplicate timestamps not allowed in function") //udf TAOS_DEFINE_ERROR(TSDB_CODE_UDF_STOPPING, "udf is stopping") From c497b7b77d67db3a03458f0f34d081d4f5f031c9 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Tue, 13 Sep 2022 18:17:24 +0800 Subject: [PATCH 047/138] refact more code --- include/common/tdataformat.h | 6 +- source/common/src/tdataformat.c | 190 +++++++++++++++++++++++++++----- 2 files changed, 163 insertions(+), 33 deletions(-) diff --git a/include/common/tdataformat.h b/include/common/tdataformat.h index 726e0eba6b..c51eff6a48 100644 --- a/include/common/tdataformat.h +++ b/include/common/tdataformat.h @@ -38,9 +38,9 @@ typedef struct STagVal STagVal; typedef struct STag STag; typedef struct SColData SColData; -#define HAS_NONE ((int8_t)0x1) -#define HAS_NULL ((int8_t)0x2) -#define HAS_VALUE ((int8_t)0x4) +#define HAS_NONE ((uint8_t)0x1) +#define HAS_NULL ((uint8_t)0x2) +#define HAS_VALUE ((uint8_t)0x4) // bitmap ================================ const static uint8_t BIT2_MAP[4][4] = {{0b00000000, 0b00000001, 0b00000010, 0}, diff --git a/source/common/src/tdataformat.c b/source/common/src/tdataformat.c index ee68e53e18..6affa2bf50 100644 --- a/source/common/src/tdataformat.c +++ b/source/common/src/tdataformat.c @@ -1239,87 +1239,218 @@ _exit: static FORCE_INLINE int32_t tColDataAppendValue1(SColData *pColData, SColVal *pColVal) { // HAS_NONE int32_t code = 0; - if (pColVal->isNone) { - } else if (pColVal->isNull) { - pColData->flag |= HAS_NULL; - // TODO - } else { - pColData->flag |= HAS_VALUE; - // TODO + if (!pColVal->isNone) { + code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1)); + if (code) goto _exit; + + for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) { + SET_BIT1(pColData->pBitMap, iVal, 0); + } + SET_BIT1(pColData->pBitMap, pColData->nVal, 1); + + if (pColVal->isNull) { + pColData->flag |= HAS_NULL; + } else { + pColData->flag |= HAS_VALUE; + code = tColDataPutValue(pColData, pColVal); + if (code) goto _exit; + } } pColData->nVal++; +_exit: return code; } static FORCE_INLINE int32_t tColDataAppendValue2(SColData *pColData, SColVal *pColVal) { // HAS_NULL int32_t code = 0; - if (pColVal->isNone) { - pColData->flag |= HAS_NONE; - // TODO - } else if (pColVal->isNull) { - } else { - pColData->flag |= HAS_VALUE; - // TODO + if (!pColVal->isNull) { + code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1)); + if (code) goto _exit; + + if (pColVal->isNone) { + pColData->flag |= HAS_NONE; + + for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) { + SET_BIT1(pColData->pBitMap, iVal, 1); + } + SET_BIT1(pColData->pBitMap, pColData->nVal, 0); + } else { + pColData->flag |= HAS_VALUE; + + for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) { + SET_BIT1(pColData->pBitMap, iVal, 0); + } + SET_BIT1(pColData->pBitMap, pColData->nVal, 1); + + code = tColDataPutValue(pColData, pColVal); + if (code) goto _exit; + } } pColData->nVal++; +_exit: return code; } -static FORCE_INLINE int32_t tColDataAppendValue3(SColData *pColData, SColVal *pColVal) { // HAS_NONE | HAS_NULL +static FORCE_INLINE int32_t tColDataAppendValue3(SColData *pColData, SColVal *pColVal) { // HAS_NULL|HAS_NONE int32_t code = 0; if (pColVal->isNone) { + code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1)); + if (code) goto _exit; + + SET_BIT1(pColData->pBitMap, pColData->nVal, 0); } else if (pColVal->isNull) { + code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1)); + if (code) goto _exit; + + SET_BIT1(pColData->pBitMap, pColData->nVal, 1); } else { + uint8_t *pBitMap = NULL; + code = tRealloc(&pBitMap, BIT2_SIZE(pColData->nVal + 1)); + if (code) goto _exit; + + for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) { + SET_BIT2(pBitMap, iVal, GET_BIT1(pColData->pBitMap, iVal)); + } + SET_BIT2(pBitMap, pColData->nVal, 2); + + pColData->flag |= HAS_VALUE; + + tFree(pColData->pBitMap); + pColData->pBitMap = pBitMap; + + code = tColDataPutValue(pColData, pColVal); + if (code) goto _exit; } pColData->nVal++; +_exit: return code; } static FORCE_INLINE int32_t tColDataAppendValue4(SColData *pColData, SColVal *pColVal) { // HAS_VALUE int32_t code = 0; if (pColVal->isNone) { + pColData->flag |= HAS_NONE; + + code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1)); + if (code) goto _exit; + + for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) { + SET_BIT1(pColData->pBitMap, iVal, 1); + } + SET_BIT1(pColData->pBitMap, pColData->nVal, 0); } else if (pColVal->isNull) { + pColData->flag |= HAS_NULL; + + code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1)); + if (code) goto _exit; + + for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) { + SET_BIT1(pColData->pBitMap, iVal, 1); + } + SET_BIT1(pColData->pBitMap, pColData->nVal, 0); } else { + code = tColDataPutValue(pColData, pColVal); + if (code) goto _exit; } pColData->nVal++; +_exit: return code; } -static FORCE_INLINE int32_t tColDataAppendValue5(SColData *pColData, SColVal *pColVal) { // HAS_VALUE | HAS_NONE +static FORCE_INLINE int32_t tColDataAppendValue5(SColData *pColData, SColVal *pColVal) { // HAS_VALUE|HAS_NONE + int32_t code = 0; + + if (pColVal->isNull) { + pColData->flag |= HAS_NULL; + + uint8_t *pBitMap = NULL; + code = tRealloc(&pBitMap, BIT2_SIZE(pColData->nVal + 1)); + if (code) goto _exit; + + for (int32_t iVal = 0; iVal < pColData->nData; iVal++) { + SET_BIT2(pBitMap, iVal, GET_BIT1(pColData->pBitMap, iVal) ? 2 : 0); + } + SET_BIT2(pBitMap, pColData->nVal, 1); + + tFree(pColData->pBitMap); + pColData->pBitMap = pBitMap; + } else { + code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1)); + if (code) goto _exit; + + if (pColVal->isNone) { + SET_BIT1(pColData->pBitMap, pColData->nVal, 0); + } else { + SET_BIT1(pColData->pBitMap, pColData->nVal, 1); + + code = tColDataPutValue(pColData, pColVal); + if (code) goto _exit; + } + } + + pColData->nVal++; + +_exit: + return code; +} +static FORCE_INLINE int32_t tColDataAppendValue6(SColData *pColData, SColVal *pColVal) { // HAS_VALUE|HAS_NULL int32_t code = 0; if (pColVal->isNone) { - } else if (pColVal->isNull) { - } else { - } - pColData->nVal++; - - return code; -} -static FORCE_INLINE int32_t tColDataAppendValue6(SColData *pColData, SColVal *pColVal) { // HAS_VALUE | HAS_NULL - int32_t code = 0; - - if (pColVal->isNone) { - } else if (pColVal->isNull) { + pColData->flag |= HAS_NONE; + + uint8_t *pBitMap = NULL; + code = tRealloc(&pBitMap, BIT2_SIZE(pColData->nVal + 1)); + if (code) goto _exit; + + for (int32_t iVal = 0; iVal < pColData->nData; iVal++) { + SET_BIT2(pBitMap, iVal, GET_BIT1(pColData->pBitMap, iVal) ? 2 : 1); + } + SET_BIT2(pBitMap, pColData->nVal, 0); + + tFree(pColData->pBitMap); + pColData->pBitMap = pBitMap; } else { + code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1)); + if (code) goto _exit; + + if (pColVal->isNull) { + SET_BIT1(pColData->pBitMap, pColData->nVal, 0); + } else { + SET_BIT1(pColData->pBitMap, pColData->nVal, 1); + + code = tColDataPutValue(pColData, pColVal); + if (code) goto _exit; + } } pColData->nVal++; +_exit: return code; } static FORCE_INLINE int32_t tColDataAppendValue7(SColData *pColData, - SColVal *pColVal) { // HAS_VALUE | HAS_NULL | HAS_NONE + SColVal *pColVal) { // HAS_VALUE|HAS_NULL|HAS_NONE int32_t code = 0; + code = tRealloc(&pColData->pBitMap, BIT2_SIZE(pColData->nVal + 1)); + if (code) goto _exit; + if (pColVal->isNone) { + SET_BIT2(pColData->pBitMap, pColData->nVal, 0); } else if (pColVal->isNull) { + SET_BIT2(pColData->pBitMap, pColData->nVal, 1); } else { + SET_BIT2(pColData->pBitMap, pColData->nVal, 2); + + code = tColDataPutValue(pColData, pColVal); + if (code) goto _exit; } pColData->nVal++; +_exit: return code; } static int32_t (*tColDataAppendValueImpl[])(SColData *pColData, SColVal *pColVal) = { @@ -1332,7 +1463,6 @@ static int32_t (*tColDataAppendValueImpl[])(SColData *pColData, SColVal *pColVal tColDataAppendValue6, // HAS_VALUE | HAS_NULL tColDataAppendValue7 // HAS_VALUE | HAS_NULL | HAS_NONE }; - int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal) { int32_t code = 0; From ad45c0a84806decee413b68770a62810f9a8715a Mon Sep 17 00:00:00 2001 From: Haojun Liao Date: Tue, 13 Sep 2022 18:22:58 +0800 Subject: [PATCH 048/138] fix(query): set the group id. --- source/libs/executor/src/executil.c | 10 +++++-- source/libs/executor/src/timewindowoperator.c | 28 ++++++++++++------- 2 files changed, 26 insertions(+), 12 deletions(-) diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c index 3965b7e5b2..410da92013 100644 --- a/source/libs/executor/src/executil.c +++ b/source/libs/executor/src/executil.c @@ -800,9 +800,15 @@ int32_t getTableList(void* metaHandle, void* pVnode, SScanPhysiNode* pScanNode, taosMemoryFreeClear(pColInfoData); } - for (int i = 0; i < taosArrayGetSize(res); i++) { + size_t numOfTables = taosArrayGetSize(res); + for (int i = 0; i < numOfTables; i++) { STableKeyInfo info = {.uid = *(uint64_t*)taosArrayGet(res, i), .groupId = 0}; - taosArrayPush(pListInfo->pTableList, &info); + void* p = taosArrayPush(pListInfo->pTableList, &info); + if (p == NULL) { + taosArrayDestroy(res); + return TSDB_CODE_OUT_OF_MEMORY; + } + qDebug("tagfilter get uid:%ld", info.uid); } diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c index c4525cc3b9..7239927a6c 100644 --- a/source/libs/executor/src/timewindowoperator.c +++ b/source/libs/executor/src/timewindowoperator.c @@ -4872,8 +4872,8 @@ void destroyMAIOperatorInfo(void* param) { } static SResultRow* doSetSingleOutputTupleBuf(SResultRowInfo* pResultRowInfo, SAggSupporter* pSup) { - SResultRow* pResult = getNewResultRow(pSup->pResultBuf, &pSup->currentPageId, pSup->resultRowSize); - pResultRowInfo->cur = (SResultRowPosition){.pageId = pResult->pageId, .offset = pResult->offset}; + SResultRow* pResult = getNewResultRow(pSup->pResultBuf, &pSup->currentPageId, pSup->resultRowSize); + pResultRowInfo->cur = (SResultRowPosition){.pageId = pResult->pageId, .offset = pResult->offset}; return pResult; } @@ -4998,15 +4998,23 @@ static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) { break; } - if (pMiaInfo->groupId != pBlock->info.groupId && pMiaInfo->groupId != 0) { - // if there are unclosed time window, close it firstly. - ASSERT(pMiaInfo->curTs != INT64_MIN); - finalizeResultRows(pIaInfo->aggSup.pResultBuf, &pResultRowInfo->cur, pSup, pRes, pTaskInfo); + if (pMiaInfo->groupId == 0) { + if (pMiaInfo->groupId != pBlock->info.groupId) { + pMiaInfo->groupId = pBlock->info.groupId; + } + } else { + if (pMiaInfo->groupId != pBlock->info.groupId) { + // if there are unclosed time window, close it firstly. + ASSERT(pMiaInfo->curTs != INT64_MIN); + finalizeResultRows(pIaInfo->aggSup.pResultBuf, &pResultRowInfo->cur, pSup, pRes, pTaskInfo); - pMiaInfo->prefetchedBlock = pBlock; - pMiaInfo->curTs = INT64_MIN; - pMiaInfo->groupId = 0; - break; + pMiaInfo->prefetchedBlock = pBlock; + pMiaInfo->curTs = INT64_MIN; + pMiaInfo->groupId = 0; + break; + } else { + // continue + } } getTableScanInfo(pOperator, &pIaInfo->inputOrder, &scanFlag); From 5463159a3d5a8f56a4f3f08f9864a79c24013c0d Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Tue, 13 Sep 2022 18:24:29 +0800 Subject: [PATCH 049/138] fix twa function input dup timestamps --- source/libs/function/src/builtinsimpl.c | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c index 7d8c231c15..5862a06aac 100644 --- a/source/libs/function/src/builtinsimpl.c +++ b/source/libs/function/src/builtinsimpl.c @@ -5446,11 +5446,11 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { } numOfElems++; + INIT_INTP_POINT(st, tsList[i], val[i]); if (pInfo->p.key == st.key) { return TSDB_CODE_FUNC_DUP_TIMESTAMP; } - INIT_INTP_POINT(st, tsList[i], val[i]); pInfo->dOutput += twa_get_area(pInfo->p, st); pInfo->p = st; } @@ -5465,11 +5465,11 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { } numOfElems++; + INIT_INTP_POINT(st, tsList[i], val[i]); if (pInfo->p.key == st.key) { return TSDB_CODE_FUNC_DUP_TIMESTAMP; } - INIT_INTP_POINT(st, tsList[i], val[i]); pInfo->dOutput += twa_get_area(pInfo->p, st); pInfo->p = st; } @@ -5483,11 +5483,11 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { } numOfElems++; + INIT_INTP_POINT(st, tsList[i], val[i]); if (pInfo->p.key == st.key) { return TSDB_CODE_FUNC_DUP_TIMESTAMP; } - INIT_INTP_POINT(st, tsList[i], val[i]); pInfo->dOutput += twa_get_area(pInfo->p, st); pInfo->p = st; } @@ -5501,11 +5501,11 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { } numOfElems++; + INIT_INTP_POINT(st, tsList[i], val[i]); if (pInfo->p.key == st.key) { return TSDB_CODE_FUNC_DUP_TIMESTAMP; } - INIT_INTP_POINT(st, tsList[i], val[i]); pInfo->dOutput += twa_get_area(pInfo->p, st); pInfo->p = st; } @@ -5519,11 +5519,11 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { } numOfElems++; + INIT_INTP_POINT(st, tsList[i], val[i]); if (pInfo->p.key == st.key) { return TSDB_CODE_FUNC_DUP_TIMESTAMP; } - INIT_INTP_POINT(st, tsList[i], val[i]); pInfo->dOutput += twa_get_area(pInfo->p, st); pInfo->p = st; } @@ -5537,11 +5537,11 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { } numOfElems++; + INIT_INTP_POINT(st, tsList[i], val[i]); if (pInfo->p.key == st.key) { return TSDB_CODE_FUNC_DUP_TIMESTAMP; } - INIT_INTP_POINT(st, tsList[i], val[i]); pInfo->dOutput += twa_get_area(pInfo->p, st); pInfo->p = st; } @@ -5555,11 +5555,11 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { } numOfElems++; + INIT_INTP_POINT(st, tsList[i], val[i]); if (pInfo->p.key == st.key) { return TSDB_CODE_FUNC_DUP_TIMESTAMP; } - INIT_INTP_POINT(st, tsList[i], val[i]); pInfo->dOutput += twa_get_area(pInfo->p, st); pInfo->p = st; } @@ -5573,11 +5573,11 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { } numOfElems++; + INIT_INTP_POINT(st, tsList[i], val[i]); if (pInfo->p.key == st.key) { return TSDB_CODE_FUNC_DUP_TIMESTAMP; } - INIT_INTP_POINT(st, tsList[i], val[i]); pInfo->dOutput += twa_get_area(pInfo->p, st); pInfo->p = st; } @@ -5591,11 +5591,11 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { } numOfElems++; + INIT_INTP_POINT(st, tsList[i], val[i]); if (pInfo->p.key == st.key) { return TSDB_CODE_FUNC_DUP_TIMESTAMP; } - INIT_INTP_POINT(st, tsList[i], val[i]); pInfo->dOutput += twa_get_area(pInfo->p, st); pInfo->p = st; } @@ -5609,11 +5609,11 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) { } numOfElems++; + INIT_INTP_POINT(st, tsList[i], val[i]); if (pInfo->p.key == st.key) { return TSDB_CODE_FUNC_DUP_TIMESTAMP; } - INIT_INTP_POINT(st, tsList[i], val[i]); pInfo->dOutput += twa_get_area(pInfo->p, st); pInfo->p = st; } From 8055e79a828f7d12008b81ff7f36963c86ba2bd2 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Tue, 13 Sep 2022 18:17:17 +0800 Subject: [PATCH 050/138] feat: database option 'tsdb_pagesize' --- source/dnode/mgmt/mgmt_vnode/src/vmHandle.c | 2 +- source/dnode/vnode/src/vnd/vnodeCfg.c | 3 +-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c index 3d292f6463..e3ad1b9389 100644 --- a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c +++ b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c @@ -173,7 +173,7 @@ static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) { pCfg->hashMethod = pCreate->hashMethod; pCfg->hashPrefix = pCreate->hashPrefix; pCfg->hashSuffix = pCreate->hashSuffix; - pCfg->tsdbPageSize = pCreate->tsdbPageSize; + pCfg->tsdbPageSize = pCreate->tsdbPageSize * 1024; pCfg->standby = pCfg->standby; pCfg->syncCfg.myIndex = pCreate->selfIndex; diff --git a/source/dnode/vnode/src/vnd/vnodeCfg.c b/source/dnode/vnode/src/vnd/vnodeCfg.c index ac13dd8a4e..5adb2eb359 100644 --- a/source/dnode/vnode/src/vnd/vnodeCfg.c +++ b/source/dnode/vnode/src/vnd/vnodeCfg.c @@ -227,8 +227,6 @@ int vnodeDecodeConfig(const SJson *pJson, void *pObj) { if (code < 0) pCfg->hashPrefix = TSDB_DEFAULT_HASH_PREFIX; tjsonGetNumberValue(pJson, "hashSuffix", pCfg->hashSuffix, code); if (code < 0) pCfg->hashSuffix = TSDB_DEFAULT_HASH_SUFFIX; - tjsonGetNumberValue(pJson, "tsdbPageSize", pCfg->tsdbPageSize, code); - if (code < 0) pCfg->tsdbPageSize = TSDB_DEFAULT_TSDB_PAGESIZE; tjsonGetNumberValue(pJson, "syncCfg.replicaNum", pCfg->syncCfg.replicaNum, code); if (code < 0) return -1; @@ -258,6 +256,7 @@ int vnodeDecodeConfig(const SJson *pJson, void *pObj) { } tjsonGetNumberValue(pJson, "tsdbPageSize", pCfg->tsdbPageSize, code); + if (code < 0) pCfg->tsdbPageSize = TSDB_DEFAULT_TSDB_PAGESIZE * 1024; return 0; } From 9c6e8aade503a4d8cd062f62bf7821b9b9c4f568 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Tue, 13 Sep 2022 18:31:49 +0800 Subject: [PATCH 051/138] feat: database option 'tsdb_pagesize' --- source/dnode/mnode/impl/src/mndVgroup.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/dnode/mnode/impl/src/mndVgroup.c b/source/dnode/mnode/impl/src/mndVgroup.c index f71b46ce34..a95bdef323 100644 --- a/source/dnode/mnode/impl/src/mndVgroup.c +++ b/source/dnode/mnode/impl/src/mndVgroup.c @@ -237,8 +237,8 @@ void *mndBuildCreateVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVg createReq.sstTrigger = pDb->cfg.sstTrigger; createReq.hashPrefix = pDb->cfg.hashPrefix; createReq.hashSuffix = pDb->cfg.hashSuffix; -createReq.tsdbPageSize = pDb->cfg.tsdbPageSize; - + createReq.tsdbPageSize = pDb->cfg.tsdbPageSize; + for (int32_t v = 0; v < pVgroup->replica; ++v) { SReplica *pReplica = &createReq.replicas[v]; SVnodeGid *pVgid = &pVgroup->vnodeGid[v]; From 9ee003c971aa2c064c1da800aa1e366ffd262eab Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Tue, 13 Sep 2022 18:32:17 +0800 Subject: [PATCH 052/138] fix test case --- tests/system-test/2-query/twa.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/system-test/2-query/twa.py b/tests/system-test/2-query/twa.py index 62940477cf..4c163da485 100644 --- a/tests/system-test/2-query/twa.py +++ b/tests/system-test/2-query/twa.py @@ -124,7 +124,7 @@ class TDTestCase: tdSql.checkData(0,1,4.500000000) # mixup with other functions - tdSql.query(f"select twa(c1),twa(c2),max(c1),elapsed(ts) from {dbname}.stb1 ") + tdSql.query(f"select twa(c1),twa(c2),max(c1),elapsed(ts) from {dbname}.ct1 ") tdSql.checkData(0,0,1.000000000) tdSql.checkData(0,1,11111.000000000) tdSql.checkData(0,2,1) From 990416d20dd84b2a236320755bf3e358790c723a Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Tue, 13 Sep 2022 18:32:22 +0800 Subject: [PATCH 053/138] enh(tsc): handle schedule error --- source/libs/transport/src/transCli.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/source/libs/transport/src/transCli.c b/source/libs/transport/src/transCli.c index 4a0008b5ff..07e671ad05 100644 --- a/source/libs/transport/src/transCli.c +++ b/source/libs/transport/src/transCli.c @@ -374,10 +374,12 @@ void cliHandleResp(SCliConn* conn) { if (pCtx == NULL && CONN_NO_PERSIST_BY_APP(conn)) { tDebug("%s except, conn %p read while cli ignore it", CONN_GET_INST_LABEL(conn), conn); + transFreeCont(transMsg.pCont); return; } if (CONN_RELEASE_BY_SERVER(conn) && transMsg.info.ahandle == NULL) { tDebug("%s except, conn %p read while cli ignore it", CONN_GET_INST_LABEL(conn), conn); + transFreeCont(transMsg.pCont); return; } From 3dec6668a9fed326e4885eba8039add57eec3229 Mon Sep 17 00:00:00 2001 From: Haojun Liao Date: Tue, 13 Sep 2022 18:33:45 +0800 Subject: [PATCH 054/138] fix(query): return correct error code. --- source/libs/executor/src/executorimpl.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/libs/executor/src/executorimpl.c b/source/libs/executor/src/executorimpl.c index e5f0d4d177..202d8eadde 100644 --- a/source/libs/executor/src/executorimpl.c +++ b/source/libs/executor/src/executorimpl.c @@ -3534,7 +3534,7 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo STagScanPhysiNode* pScanPhyNode = (STagScanPhysiNode*)pPhyNode; int32_t code = getTableList(pHandle->meta, pHandle->vnode, pScanPhyNode, pTagCond, pTagIndexCond, pTableListInfo); if (code != TSDB_CODE_SUCCESS) { - pTaskInfo->code = terrno; + pTaskInfo->code = code; qError("failed to getTableList, code: %s", tstrerror(code)); return NULL; } From d585c20aa3472baf82cbdd68c22281b866073afe Mon Sep 17 00:00:00 2001 From: Xiaoyu Wang Date: Tue, 13 Sep 2022 18:58:56 +0800 Subject: [PATCH 055/138] enh: count(tbname) optimize --- source/libs/parser/src/parAstCreater.c | 2 +- source/libs/parser/src/parTranslater.c | 33 +++++++++++++++++++ source/libs/planner/test/planOptimizeTest.cpp | 2 ++ 3 files changed, 36 insertions(+), 1 deletion(-) diff --git a/source/libs/parser/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c index 655bb68206..511ae25810 100644 --- a/source/libs/parser/src/parAstCreater.c +++ b/source/libs/parser/src/parAstCreater.c @@ -1303,7 +1303,7 @@ SNode* createShowStmtWithCond(SAstCreateContext* pCxt, ENodeType type, SNode* pD EOperatorType tableCondType) { CHECK_PARSER_STATUS(pCxt); if (needDbShowStmt(type) && NULL == pDbName) { - snprintf(pCxt->pQueryCxt->pMsg, pCxt->pQueryCxt->msgLen, "db not specified"); + snprintf(pCxt->pQueryCxt->pMsg, pCxt->pQueryCxt->msgLen, "database not specified"); pCxt->errCode = TSDB_CODE_PAR_SYNTAX_ERROR; return NULL; } diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index 2af4032fd8..f1a59ebf51 100644 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -1283,6 +1283,36 @@ static int32_t rewriteCountStar(STranslateContext* pCxt, SFunctionNode* pCount) return code; } +static bool isCountTbname(SFunctionNode* pFunc) { + if (FUNCTION_TYPE_COUNT != pFunc->funcType || 1 != LIST_LENGTH(pFunc->pParameterList)) { + return false; + } + SNode* pPara = nodesListGetNode(pFunc->pParameterList, 0); + return (QUERY_NODE_FUNCTION == nodeType(pPara) && FUNCTION_TYPE_TBNAME == ((SFunctionNode*)pPara)->funcType); +} + +// count(tbname) is rewritten as count(ts) for scannning optimization +static int32_t rewriteCountTbname(STranslateContext* pCxt, SFunctionNode* pCount) { + SFunctionNode* pTbname = (SFunctionNode*)nodesListGetNode(pCount->pParameterList, 0); + const char* pTableAlias = NULL; + if (LIST_LENGTH(pTbname->pParameterList) > 0) { + pTableAlias = ((SValueNode*)nodesListGetNode(pTbname->pParameterList, 0))->literal; + } + STableNode* pTable = NULL; + int32_t code = findTable(pCxt, pTableAlias, &pTable); + if (TSDB_CODE_SUCCESS == code) { + SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + if (NULL == pCol) { + code = TSDB_CODE_OUT_OF_MEMORY; + } else { + setColumnInfoBySchema((SRealTableNode*)pTable, ((SRealTableNode*)pTable)->pMeta->schema, -1, pCol); + NODES_DESTORY_LIST(pCount->pParameterList); + code = nodesListMakeAppend(&pCount->pParameterList, (SNode*)pCol); + } + } + return code; +} + static bool hasInvalidFuncNesting(SNodeList* pParameterList) { bool hasInvalidFunc = false; nodesWalkExprs(pParameterList, haveVectorFunction, &hasInvalidFunc); @@ -1318,6 +1348,9 @@ static int32_t translateAggFunc(STranslateContext* pCxt, SFunctionNode* pFunc) { if (isCountStar(pFunc)) { return rewriteCountStar(pCxt, pFunc); } + if (isCountTbname(pFunc)) { + return rewriteCountTbname(pCxt, pFunc); + } return TSDB_CODE_SUCCESS; } diff --git a/source/libs/planner/test/planOptimizeTest.cpp b/source/libs/planner/test/planOptimizeTest.cpp index 6c5b760564..c2a0aee847 100644 --- a/source/libs/planner/test/planOptimizeTest.cpp +++ b/source/libs/planner/test/planOptimizeTest.cpp @@ -35,6 +35,8 @@ TEST_F(PlanOptimizeTest, scanPath) { run("SELECT LAST(c1) FROM t1 WHERE ts BETWEEN '2022-7-29 11:10:10' AND '2022-7-30 11:10:10' INTERVAL(10S) " "FILL(LINEAR)"); + + run("SELECT COUNT(TBNAME) FROM t1"); } TEST_F(PlanOptimizeTest, pushDownCondition) { From b914e37874b1d2ea5e693bb482fcc420e936a4ea Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Tue, 13 Sep 2022 19:05:35 +0800 Subject: [PATCH 056/138] enh(tsc): handle schedule error --- source/libs/transport/src/transCli.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/libs/transport/src/transCli.c b/source/libs/transport/src/transCli.c index 07e671ad05..18efabd44f 100644 --- a/source/libs/transport/src/transCli.c +++ b/source/libs/transport/src/transCli.c @@ -395,7 +395,7 @@ void cliHandleResp(SCliConn* conn) { } if (CONN_NO_PERSIST_BY_APP(conn)) { - addConnToPool(pThrd->pool, conn); + return addConnToPool(pThrd->pool, conn); } uv_read_start((uv_stream_t*)conn->stream, cliAllocRecvBufferCb, cliRecvCb); From 3922ea4922520a1d73a045a05b43a906bad831df Mon Sep 17 00:00:00 2001 From: Minglei Jin Date: Tue, 13 Sep 2022 18:02:00 +0800 Subject: [PATCH 057/138] fix: drop page from rbtree before releasing --- source/libs/tdb/src/db/tdbPager.c | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/source/libs/tdb/src/db/tdbPager.c b/source/libs/tdb/src/db/tdbPager.c index bb2151ed9d..2cc62d3d6a 100644 --- a/source/libs/tdb/src/db/tdbPager.c +++ b/source/libs/tdb/src/db/tdbPager.c @@ -185,10 +185,10 @@ int tdbPagerWrite(SPager *pPager, SPage *pPage) { // ref page one more time so the page will not be release tdbRefPage(pPage); tdbDebug("pcache/mdirty page %p/%d/%d", pPage, TDB_PAGE_PGNO(pPage), pPage->id); - /* + // Set page as dirty pPage->isDirty = 1; - + /* // Add page to dirty list(TODO: NOT use O(n^2) algorithm) for (ppPage = &pPager->pDirty; (*ppPage) && TDB_PAGE_PGNO(*ppPage) < TDB_PAGE_PGNO(pPage); ppPage = &((*ppPage)->pDirtyNext)) { @@ -260,6 +260,7 @@ int tdbPagerCommit(SPager *pPager, TXN *pTxn) { pPage->isDirty = 0; + // tRBTreeDrop(&pPager->rbt, (SRBTreeNode *)pPage); tdbPCacheRelease(pPager->pCache, pPage, pTxn); } @@ -345,15 +346,19 @@ int tdbPagerAbort(SPager *pPager, TXN *pTxn) { } */ // 3, release the dirty pages - for (pPage = pPager->pDirty; pPage; pPage = pPager->pDirty) { - pPager->pDirty = pPage->pDirtyNext; - pPage->pDirtyNext = NULL; + SRBTreeIter iter = tRBTreeIterCreate(&pPager->rbt, 1); + SRBTreeNode *pNode = NULL; + while ((pNode = tRBTreeIterNext(&iter)) != NULL) { + pPage = (SPage *)pNode; pPage->isDirty = 0; + // tRBTreeDrop(&pPager->rbt, (SRBTreeNode *)pPage); tdbPCacheRelease(pPager->pCache, pPage, pTxn); } + tRBTreeCreate(&pPager->rbt, pageCmpFn); + // 4, remove the journal file tdbOsClose(pPager->jfd); tdbOsRemove(pPager->jFileName); From 0277a96b5fd863f610223e421bbea0f03b7fea32 Mon Sep 17 00:00:00 2001 From: Shuduo Sang Date: Tue, 13 Sep 2022 19:30:28 +0800 Subject: [PATCH 058/138] fix: tag length of 5-taos-tools/taosbenchmark/demo.py --- tests/develop-test/5-taos-tools/taosbenchmark/demo.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/develop-test/5-taos-tools/taosbenchmark/demo.py b/tests/develop-test/5-taos-tools/taosbenchmark/demo.py index f62cb05269..a44ad4c1d0 100644 --- a/tests/develop-test/5-taos-tools/taosbenchmark/demo.py +++ b/tests/develop-test/5-taos-tools/taosbenchmark/demo.py @@ -77,7 +77,7 @@ class TDTestCase: tdSql.checkData(4, 3, "TAG") tdSql.checkData(5, 0, "location") tdSql.checkData(5, 1, "VARCHAR") - tdSql.checkData(5, 2, 16) + tdSql.checkData(5, 2, 24) tdSql.checkData(5, 3, "TAG") tdSql.query("select count(*) from test.meters where groupid >= 0") From 2b8b1ebc866abd65d11621b5058b3c659c7dd809 Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Tue, 13 Sep 2022 20:45:28 +0800 Subject: [PATCH 059/138] fix: fix mem leak --- source/libs/transport/src/transCli.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/libs/transport/src/transCli.c b/source/libs/transport/src/transCli.c index 18efabd44f..dcfa93431b 100644 --- a/source/libs/transport/src/transCli.c +++ b/source/libs/transport/src/transCli.c @@ -374,12 +374,12 @@ void cliHandleResp(SCliConn* conn) { if (pCtx == NULL && CONN_NO_PERSIST_BY_APP(conn)) { tDebug("%s except, conn %p read while cli ignore it", CONN_GET_INST_LABEL(conn), conn); - transFreeCont(transMsg.pCont); + transFreeMsg(transMsg.pCont); return; } if (CONN_RELEASE_BY_SERVER(conn) && transMsg.info.ahandle == NULL) { tDebug("%s except, conn %p read while cli ignore it", CONN_GET_INST_LABEL(conn), conn); - transFreeCont(transMsg.pCont); + transFreeMsg(transMsg.pCont); return; } From 7cc095419f68b7e872ac82d1537f0104c903925e Mon Sep 17 00:00:00 2001 From: Shuduo Sang Date: Tue, 13 Sep 2022 16:56:52 +0000 Subject: [PATCH 060/138] feat: update taos-tools 3588b3d for 3.0 --- cmake/taostools_CMakeLists.txt.in | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/taostools_CMakeLists.txt.in b/cmake/taostools_CMakeLists.txt.in index 13559bba27..0f7a450920 100644 --- a/cmake/taostools_CMakeLists.txt.in +++ b/cmake/taostools_CMakeLists.txt.in @@ -2,7 +2,7 @@ # taos-tools ExternalProject_Add(taos-tools GIT_REPOSITORY https://github.com/taosdata/taos-tools.git - GIT_TAG 404d8da + GIT_TAG 3588b3d SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools" BINARY_DIR "" #BUILD_IN_SOURCE TRUE From 0e1a4212075a8f87557acec8d82a0734120e89e0 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Wed, 14 Sep 2022 09:35:57 +0800 Subject: [PATCH 061/138] refact --- source/common/src/tdataformat.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/source/common/src/tdataformat.c b/source/common/src/tdataformat.c index 6affa2bf50..ed2d68961f 100644 --- a/source/common/src/tdataformat.c +++ b/source/common/src/tdataformat.c @@ -1457,11 +1457,11 @@ static int32_t (*tColDataAppendValueImpl[])(SColData *pColData, SColVal *pColVal tColDataAppendValue0, // 0 tColDataAppendValue1, // HAS_NONE tColDataAppendValue2, // HAS_NULL - tColDataAppendValue3, // HAS_NULL | HAS_NONE + tColDataAppendValue3, // HAS_NULL|HAS_NONE tColDataAppendValue4, // HAS_VALUE - tColDataAppendValue5, // HAS_VALUE | HAS_NONE - tColDataAppendValue6, // HAS_VALUE | HAS_NULL - tColDataAppendValue7 // HAS_VALUE | HAS_NULL | HAS_NONE + tColDataAppendValue5, // HAS_VALUE|HAS_NONE + tColDataAppendValue6, // HAS_VALUE|HAS_NULL + tColDataAppendValue7 // HAS_VALUE|HAS_NULL|HAS_NONE }; int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal) { int32_t code = 0; From 7f03ffcd7596655f8b7f349012cd380e41e545a7 Mon Sep 17 00:00:00 2001 From: Haojun Liao Date: Wed, 14 Sep 2022 09:57:37 +0800 Subject: [PATCH 062/138] fix(query): set correct group id. --- source/libs/executor/src/timewindowoperator.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c index 7239927a6c..6568c85edb 100644 --- a/source/libs/executor/src/timewindowoperator.c +++ b/source/libs/executor/src/timewindowoperator.c @@ -4992,6 +4992,7 @@ static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) { if (pMiaInfo->curTs != INT64_MIN) { finalizeResultRows(pIaInfo->aggSup.pResultBuf, &pResultRowInfo->cur, pSup, pRes, pTaskInfo); pMiaInfo->curTs = INT64_MIN; + pRes->info.groupId = pMiaInfo->groupId; } doSetOperatorCompleted(pOperator); @@ -5007,8 +5008,9 @@ static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) { // if there are unclosed time window, close it firstly. ASSERT(pMiaInfo->curTs != INT64_MIN); finalizeResultRows(pIaInfo->aggSup.pResultBuf, &pResultRowInfo->cur, pSup, pRes, pTaskInfo); - pMiaInfo->prefetchedBlock = pBlock; + + pRes->info.groupId = pMiaInfo->groupId; pMiaInfo->curTs = INT64_MIN; pMiaInfo->groupId = 0; break; @@ -5026,8 +5028,6 @@ static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) { break; } } - - pRes->info.groupId = pMiaInfo->groupId; } static SSDataBlock* mergeAlignedIntervalAgg(SOperatorInfo* pOperator) { From fbcef61d069adbee89c844d3c7281bbee9d2ef1a Mon Sep 17 00:00:00 2001 From: Xiaoyu Wang Date: Wed, 14 Sep 2022 10:34:13 +0800 Subject: [PATCH 063/138] enh: add binary serialization method to node structure --- source/common/src/tmsg.c | 10 +++--- source/libs/nodes/src/nodesMsgFuncs.c | 47 ++++++++++++++++++++++++--- 2 files changed, 46 insertions(+), 11 deletions(-) diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index ea25094d10..45861984b0 100644 --- a/source/common/src/tmsg.c +++ b/source/common/src/tmsg.c @@ -4718,9 +4718,8 @@ int32_t tSerializeSVDeleteReq(void *buf, int32_t bufLen, SVDeleteReq *pReq) { if (tEncodeU64(&encoder, pReq->queryId) < 0) return -1; if (tEncodeU64(&encoder, pReq->taskId) < 0) return -1; if (tEncodeU32(&encoder, pReq->sqlLen) < 0) return -1; - if (tEncodeU32(&encoder, pReq->phyLen) < 0) return -1; if (tEncodeCStr(&encoder, pReq->sql) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->msg) < 0) return -1; + if (tEncodeBinary(&encoder, pReq->msg, pReq->phyLen) < 0) return -1; tEndEncode(&encoder); int32_t tlen = encoder.pos; @@ -4750,13 +4749,12 @@ int32_t tDeserializeSVDeleteReq(void *buf, int32_t bufLen, SVDeleteReq *pReq) { if (tDecodeU64(&decoder, &pReq->queryId) < 0) return -1; if (tDecodeU64(&decoder, &pReq->taskId) < 0) return -1; if (tDecodeU32(&decoder, &pReq->sqlLen) < 0) return -1; - if (tDecodeU32(&decoder, &pReq->phyLen) < 0) return -1; pReq->sql = taosMemoryCalloc(1, pReq->sqlLen + 1); if (NULL == pReq->sql) return -1; - pReq->msg = taosMemoryCalloc(1, pReq->phyLen + 1); - if (NULL == pReq->msg) return -1; if (tDecodeCStrTo(&decoder, pReq->sql) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->msg) < 0) return -1; + uint64_t msgLen = 0; + if (tDecodeBinaryAlloc(&decoder, (void **)&pReq->msg, &msgLen) < 0) return -1; + pReq->phyLen = msgLen; tEndDecode(&decoder); diff --git a/source/libs/nodes/src/nodesMsgFuncs.c b/source/libs/nodes/src/nodesMsgFuncs.c index 9a093fca99..efe820fee2 100644 --- a/source/libs/nodes/src/nodesMsgFuncs.c +++ b/source/libs/nodes/src/nodesMsgFuncs.c @@ -254,6 +254,11 @@ static int32_t tlvDecodeDynBinary(STlv* pTlv, void** pValue) { return TSDB_CODE_SUCCESS; } +static int32_t tlvDecodeBinary(STlv* pTlv, void* pValue) { + memcpy(pValue, pTlv->value, pTlv->len); + return TSDB_CODE_SUCCESS; +} + static int32_t tlvDecodeObjFromTlv(STlv* pTlv, FToObject func, void* pObj) { STlvDecoder decoder = {.bufSize = pTlv->len, .offset = 0, .pBuf = pTlv->value}; return func(&decoder, pObj); @@ -469,7 +474,15 @@ static int32_t msgToColumnNode(STlvDecoder* pDecoder, void* pObj) { return code; } -enum { VALUE_CODE_EXPR_BASE = 1, VALUE_CODE_LITERAL, VALUE_CODE_IS_NULL, VALUE_CODE_DATUM }; +enum { + VALUE_CODE_EXPR_BASE = 1, + VALUE_CODE_LITERAL, + VALUE_CODE_IS_DURATION, + VALUE_CODE_TRANSLATE, + VALUE_CODE_NOT_RESERVED, + VALUE_CODE_IS_NULL, + VALUE_CODE_DATUM +}; static int32_t datumToMsg(const void* pObj, STlvEncoder* pEncoder) { const SValueNode* pNode = (const SValueNode*)pObj; @@ -524,9 +537,18 @@ static int32_t valueNodeToMsg(const void* pObj, STlvEncoder* pEncoder) { code = tlvEncodeCStr(pEncoder, VALUE_CODE_LITERAL, pNode->literal); } if (TSDB_CODE_SUCCESS == code) { - code = tlvEncodeBool(pEncoder, VALUE_CODE_IS_NULL, pNode->isNull); + code = tlvEncodeBool(pEncoder, VALUE_CODE_IS_DURATION, pNode->isDuration); } if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeBool(pEncoder, VALUE_CODE_TRANSLATE, pNode->translate); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeBool(pEncoder, VALUE_CODE_NOT_RESERVED, pNode->notReserved); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeBool(pEncoder, VALUE_CODE_IS_NULL, pNode->isNull); + } + if (TSDB_CODE_SUCCESS == code && !pNode->isNull) { code = datumToMsg(pNode, pEncoder); } @@ -590,12 +612,18 @@ static int32_t msgToDatum(STlv* pTlv, void* pObj) { break; case TSDB_DATA_TYPE_NCHAR: case TSDB_DATA_TYPE_VARCHAR: - case TSDB_DATA_TYPE_VARBINARY: - code = tlvDecodeDynBinary(pTlv, (void**)&pNode->datum.p); + case TSDB_DATA_TYPE_VARBINARY: { + pNode->datum.p = taosMemoryCalloc(1, pNode->node.resType.bytes + VARSTR_HEADER_SIZE + 1); + if (NULL == pNode->datum.p) { + code = TSDB_CODE_OUT_OF_MEMORY; + break; + } + code = tlvDecodeBinary(pTlv, pNode->datum.p); if (TSDB_CODE_SUCCESS == code) { - varDataSetLen(pNode->datum.p, pNode->node.resType.bytes - VARSTR_HEADER_SIZE); + varDataSetLen(pNode->datum.p, pTlv->len - VARSTR_HEADER_SIZE); } break; + } case TSDB_DATA_TYPE_JSON: code = tlvDecodeDynBinary(pTlv, (void**)&pNode->datum.p); break; @@ -622,6 +650,15 @@ static int32_t msgToValueNode(STlvDecoder* pDecoder, void* pObj) { case VALUE_CODE_LITERAL: code = tlvDecodeCStrP(pTlv, &pNode->literal); break; + case VALUE_CODE_IS_DURATION: + code = tlvDecodeBool(pTlv, &pNode->isDuration); + break; + case VALUE_CODE_TRANSLATE: + code = tlvDecodeBool(pTlv, &pNode->translate); + break; + case VALUE_CODE_NOT_RESERVED: + code = tlvDecodeBool(pTlv, &pNode->notReserved); + break; case VALUE_CODE_IS_NULL: code = tlvDecodeBool(pTlv, &pNode->isNull); break; From 0bb1dc9d1ffc2d7be5b6c84b17fbb5d57a274f1d Mon Sep 17 00:00:00 2001 From: Haojun Liao Date: Wed, 14 Sep 2022 11:00:44 +0800 Subject: [PATCH 064/138] fix(query): reset the output buffer when results have been produced. --- source/libs/executor/inc/executil.h | 1 + source/libs/executor/src/executil.c | 11 +++++++++++ source/libs/executor/src/executorimpl.c | 5 +++-- source/libs/executor/src/timewindowoperator.c | 10 +++------- 4 files changed, 18 insertions(+), 9 deletions(-) diff --git a/source/libs/executor/inc/executil.h b/source/libs/executor/inc/executil.h index 0722c2b306..3f40c18a28 100644 --- a/source/libs/executor/inc/executil.h +++ b/source/libs/executor/inc/executil.h @@ -88,6 +88,7 @@ struct SqlFunctionCtx; size_t getResultRowSize(struct SqlFunctionCtx* pCtx, int32_t numOfOutput); void initResultRowInfo(SResultRowInfo* pResultRowInfo); void closeResultRow(SResultRow* pResultRow); +void resetResultRow(SResultRow* pResultRow, size_t entrySize); struct SResultRowEntryInfo* getResultEntryInfo(const SResultRow* pRow, int32_t index, const int32_t* offset); diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c index 410da92013..cfc5fec25f 100644 --- a/source/libs/executor/src/executil.c +++ b/source/libs/executor/src/executil.c @@ -33,6 +33,17 @@ void initResultRowInfo(SResultRowInfo* pResultRowInfo) { void closeResultRow(SResultRow* pResultRow) { pResultRow->closed = true; } +void resetResultRow(SResultRow* pResultRow, size_t entrySize) { + pResultRow->numOfRows = 0; + pResultRow->closed = false; + pResultRow->endInterp = false; + pResultRow->startInterp = false; + + if (entrySize > 0) { + memset(pResultRow->pEntryInfo, 0, entrySize); + } +} + // TODO refactor: use macro SResultRowEntryInfo* getResultEntryInfo(const SResultRow* pRow, int32_t index, const int32_t* offset) { assert(index >= 0 && offset != NULL); diff --git a/source/libs/executor/src/executorimpl.c b/source/libs/executor/src/executorimpl.c index 202d8eadde..cd1177794e 100644 --- a/source/libs/executor/src/executorimpl.c +++ b/source/libs/executor/src/executorimpl.c @@ -1293,8 +1293,9 @@ static void doCopyResultToDataBlock(SExprInfo* pExprInfo, int32_t numOfExprs, SR } } -int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, - SExprSupp* pSup, SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo) { +// todo refactor. SResultRow has direct pointer in miainfo +int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, SExprSupp* pSup, + SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo) { SFilePage* page = getBufPage(pBuf, resultRowPosition->pageId); SResultRow* pRow = (SResultRow*)((char*)page + resultRowPosition->offset); diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c index 6568c85edb..c24e04eab1 100644 --- a/source/libs/executor/src/timewindowoperator.c +++ b/source/libs/executor/src/timewindowoperator.c @@ -4886,14 +4886,8 @@ static int32_t setSingleOutputTupleBuf(SResultRowInfo* pResultRowInfo, STimeWind } } - // set time window for current result ,todo extract method + // set time window for current result (*pResult)->win = (*win); - (*pResult)->numOfRows = 0; - (*pResult)->closed = false; - (*pResult)->endInterp = false; - (*pResult)->startInterp = false; - memset((*pResult)->pEntryInfo, 0, pAggSup->resultRowSize - sizeof(SResultRow)); - setResultRowInitCtx((*pResult), pExprSup->pCtx, pExprSup->numOfExprs, pExprSup->rowEntryInfoOffset); return TSDB_CODE_SUCCESS; } @@ -4916,6 +4910,7 @@ static void doMergeAlignedIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultR if (miaInfo->curTs != INT64_MIN) { if (ts != miaInfo->curTs) { finalizeResultRows(iaInfo->aggSup.pResultBuf, &pResultRowInfo->cur, pSup, pResultBlock, pTaskInfo); + resetResultRow(miaInfo->pResultRow, iaInfo->aggSup.resultRowSize - sizeof(SResultRow)); miaInfo->curTs = ts; } } else { @@ -4944,6 +4939,7 @@ static void doMergeAlignedIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultR pBlock->info.rows, pSup->numOfExprs); finalizeResultRows(iaInfo->aggSup.pResultBuf, &pResultRowInfo->cur, pSup, pResultBlock, pTaskInfo); + resetResultRow(miaInfo->pResultRow, iaInfo->aggSup.resultRowSize - sizeof(SResultRow)); miaInfo->curTs = tsCols[currPos]; currWin.skey = miaInfo->curTs; From e076b8c7c24208b3c9d2ca3653c6930454380f85 Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Wed, 14 Sep 2022 11:05:24 +0800 Subject: [PATCH 065/138] fix test case --- tests/system-test/2-query/max_partition.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/system-test/2-query/max_partition.py b/tests/system-test/2-query/max_partition.py index 01c2677242..08bb7675ad 100644 --- a/tests/system-test/2-query/max_partition.py +++ b/tests/system-test/2-query/max_partition.py @@ -181,7 +181,7 @@ class TDTestCase: # bug need fix tdSql.checkData(0,1,None) - tdSql.query(f"select c1 , twa(c1) from {dbname}.stb partition by c1 order by c1") + tdSql.query(f"select c1 , twa(c1) from {dbname}.sub_stb_1 partition by c1 order by c1") tdSql.checkRows(11) tdSql.checkData(0,1,None) From 892d7861f08ef62da6f6748b4fd24df6c041b3f6 Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Wed, 14 Sep 2022 11:06:37 +0800 Subject: [PATCH 066/138] fix(tsc): avoid mem leak --- source/client/src/clientImpl.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/source/client/src/clientImpl.c b/source/client/src/clientImpl.c index 39b4b069a0..e7b34ab783 100644 --- a/source/client/src/clientImpl.c +++ b/source/client/src/clientImpl.c @@ -1369,7 +1369,7 @@ int32_t doProcessMsgFromServer(void* param) { updateTargetEpSet(pSendInfo, pTscObj, pMsg, pEpSet); SDataBuf buf = { - .msgType = pMsg->msgType, .len = pMsg->contLen, .pData = NULL, .handle = pMsg->info.handle, .pEpSet = pEpSet}; + .msgType = pMsg->msgType, .len = pMsg->contLen, .pData = NULL, .handle = pMsg->info.handle, .pEpSet = NULL}; if (pMsg->contLen > 0) { buf.pData = taosMemoryCalloc(1, pMsg->contLen); @@ -1384,6 +1384,8 @@ int32_t doProcessMsgFromServer(void* param) { pSendInfo->fp(pSendInfo->param, &buf, pMsg->code); rpcFreeCont(pMsg->pCont); destroySendMsgInfo(pSendInfo); + + taosMemoryFree(arg->pEpset); taosMemoryFree(arg); return TSDB_CODE_SUCCESS; } From 0a6ec7c0d763e288118e6e88352c7d9115244ac0 Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Wed, 14 Sep 2022 11:17:12 +0800 Subject: [PATCH 067/138] fix(query): restrict max/min function input type not including timestamp type --- source/libs/function/src/builtins.c | 20 ++------------------ source/libs/function/src/builtinsimpl.c | 6 +++--- 2 files changed, 5 insertions(+), 21 deletions(-) diff --git a/source/libs/function/src/builtins.c b/source/libs/function/src/builtins.c index 5844784ea4..f3d3393ac3 100644 --- a/source/libs/function/src/builtins.c +++ b/source/libs/function/src/builtins.c @@ -311,22 +311,6 @@ static int32_t translateInOutStr(SFunctionNode* pFunc, char* pErrBuf, int32_t le return TSDB_CODE_SUCCESS; } -static int32_t translateMinMax(SFunctionNode* pFunc, char* pErrBuf, int32_t len) { - if (1 != LIST_LENGTH(pFunc->pParameterList)) { - return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName); - } - - uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type; - if (!IS_TIMESTAMP_TYPE(paraType) && !IS_NUMERIC_TYPE(paraType) && !IS_NULL_TYPE(paraType)) { - return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName); - } else if (IS_NULL_TYPE(paraType)) { - paraType = TSDB_DATA_TYPE_BIGINT; - } - - pFunc->node.resType = (SDataType){.bytes = tDataTypes[paraType].bytes, .type = paraType}; - return TSDB_CODE_SUCCESS; -} - static int32_t translateTrimStr(SFunctionNode* pFunc, char* pErrBuf, int32_t len, bool isLtrim) { if (1 != LIST_LENGTH(pFunc->pParameterList)) { return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName); @@ -2076,7 +2060,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = { .name = "min", .type = FUNCTION_TYPE_MIN, .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SPECIAL_DATA_REQUIRED | FUNC_MGT_SELECT_FUNC, - .translateFunc = translateMinMax, + .translateFunc = translateInOutNum, .dataRequiredFunc = statisDataRequired, .getEnvFunc = getMinmaxFuncEnv, .initFunc = minmaxFunctionSetup, @@ -2091,7 +2075,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = { .name = "max", .type = FUNCTION_TYPE_MAX, .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SPECIAL_DATA_REQUIRED | FUNC_MGT_SELECT_FUNC, - .translateFunc = translateMinMax, + .translateFunc = translateInOutNum, .dataRequiredFunc = statisDataRequired, .getEnvFunc = getMinmaxFuncEnv, .initFunc = minmaxFunctionSetup, diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c index 0d7fd1a6da..c9e345f49f 100644 --- a/source/libs/function/src/builtinsimpl.c +++ b/source/libs/function/src/builtinsimpl.c @@ -1204,7 +1204,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) { pBuf->tuplePos = saveTupleData(pCtx, index, pCtx->pSrcBlock); } } else { - if (IS_SIGNED_NUMERIC_TYPE(type) || IS_TIMESTAMP_TYPE(type)) { + if (IS_SIGNED_NUMERIC_TYPE(type)) { int64_t prev = 0; GET_TYPED_DATA(prev, int64_t, type, &pBuf->v); @@ -1263,7 +1263,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) { int32_t start = pInput->startRowIndex; int32_t numOfRows = pInput->numOfRows; - if (IS_SIGNED_NUMERIC_TYPE(type) || IS_TIMESTAMP_TYPE(type) || type == TSDB_DATA_TYPE_BOOL) { + if (IS_SIGNED_NUMERIC_TYPE(type) || type == TSDB_DATA_TYPE_BOOL) { if (type == TSDB_DATA_TYPE_TINYINT || type == TSDB_DATA_TYPE_BOOL) { int8_t* pData = (int8_t*)pCol->pData; int8_t* val = (int8_t*)&pBuf->v; @@ -1357,7 +1357,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) { numOfElems += 1; } - } else if (type == TSDB_DATA_TYPE_BIGINT || type == TSDB_DATA_TYPE_TIMESTAMP) { + } else if (type == TSDB_DATA_TYPE_BIGINT) { int64_t* pData = (int64_t*)pCol->pData; int64_t* val = (int64_t*)&pBuf->v; From 00908a649c2927e166362190b6c799caeaa22777 Mon Sep 17 00:00:00 2001 From: Haojun Liao Date: Wed, 14 Sep 2022 11:44:39 +0800 Subject: [PATCH 068/138] fix(query): reset buffer after group results generated. --- source/libs/executor/src/executorimpl.c | 16 ---------------- source/libs/executor/src/timewindowoperator.c | 17 +++++++++++------ 2 files changed, 11 insertions(+), 22 deletions(-) diff --git a/source/libs/executor/src/executorimpl.c b/source/libs/executor/src/executorimpl.c index cd1177794e..677fddc85c 100644 --- a/source/libs/executor/src/executorimpl.c +++ b/source/libs/executor/src/executorimpl.c @@ -1709,22 +1709,6 @@ int32_t appendDownstream(SOperatorInfo* p, SOperatorInfo** pDownstream, int32_t static void doDestroyTableList(STableListInfo* pTableqinfoList); -static void doTableQueryInfoTimeWindowCheck(SExecTaskInfo* pTaskInfo, STableQueryInfo* pTableQueryInfo, int32_t order) { -#if 0 - if (order == TSDB_ORDER_ASC) { - assert( - (pTableQueryInfo->win.skey <= pTableQueryInfo->win.ekey) && - (pTableQueryInfo->lastKey >= pTaskInfo->window.skey) && - (pTableQueryInfo->win.skey >= pTaskInfo->window.skey && pTableQueryInfo->win.ekey <= pTaskInfo->window.ekey)); - } else { - assert( - (pTableQueryInfo->win.skey >= pTableQueryInfo->win.ekey) && - (pTableQueryInfo->lastKey <= pTaskInfo->window.skey) && - (pTableQueryInfo->win.skey <= pTaskInfo->window.skey && pTableQueryInfo->win.ekey >= pTaskInfo->window.ekey)); - } -#endif -} - typedef struct SFetchRspHandleWrapper { uint32_t exchangeId; int32_t sourceIndex; diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c index c24e04eab1..c6dca79e8d 100644 --- a/source/libs/executor/src/timewindowoperator.c +++ b/source/libs/executor/src/timewindowoperator.c @@ -4959,6 +4959,12 @@ static void doMergeAlignedIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultR pBlock->info.rows, pSup->numOfExprs); } +static void cleanupAfterGroupResultGen(SMergeAlignedIntervalAggOperatorInfo* pMiaInfo, SSDataBlock* pRes) { + pRes->info.groupId = pMiaInfo->groupId; + pMiaInfo->curTs = INT64_MIN; + pMiaInfo->groupId = 0; +} + static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) { SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; @@ -4987,8 +4993,8 @@ static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) { // close last unclosed time window if (pMiaInfo->curTs != INT64_MIN) { finalizeResultRows(pIaInfo->aggSup.pResultBuf, &pResultRowInfo->cur, pSup, pRes, pTaskInfo); - pMiaInfo->curTs = INT64_MIN; - pRes->info.groupId = pMiaInfo->groupId; + resetResultRow(pMiaInfo->pResultRow, pIaInfo->aggSup.resultRowSize - sizeof(SResultRow)); + cleanupAfterGroupResultGen(pMiaInfo, pRes); } doSetOperatorCompleted(pOperator); @@ -5004,11 +5010,10 @@ static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) { // if there are unclosed time window, close it firstly. ASSERT(pMiaInfo->curTs != INT64_MIN); finalizeResultRows(pIaInfo->aggSup.pResultBuf, &pResultRowInfo->cur, pSup, pRes, pTaskInfo); - pMiaInfo->prefetchedBlock = pBlock; + resetResultRow(pMiaInfo->pResultRow, pIaInfo->aggSup.resultRowSize - sizeof(SResultRow)); - pRes->info.groupId = pMiaInfo->groupId; - pMiaInfo->curTs = INT64_MIN; - pMiaInfo->groupId = 0; + pMiaInfo->prefetchedBlock = pBlock; + cleanupAfterGroupResultGen(pMiaInfo, pRes); break; } else { // continue From 03c867cdbfba2db4d9da1cebacec7aa283e5f859 Mon Sep 17 00:00:00 2001 From: Xiong Ju Date: Wed, 14 Sep 2022 13:25:52 +0900 Subject: [PATCH 069/138] Update trefTest.c fix typo: reson -> reason --- source/util/test/trefTest.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/util/test/trefTest.c b/source/util/test/trefTest.c index 89561e61fe..5a6790ef1d 100644 --- a/source/util/test/trefTest.c +++ b/source/util/test/trefTest.c @@ -94,7 +94,7 @@ void *openRefSpace(void *param) { pSpace->rsetId = taosOpenRef(50, myfree); if (pSpace->rsetId < 0) { - printf("failed to open ref, reson:%s\n", tstrerror(pSpace->rsetId)); + printf("failed to open ref, reason:%s\n", tstrerror(pSpace->rsetId)); return NULL; } From 2c2d5c16ed0410ae58e78c8b5586dbd583f945b2 Mon Sep 17 00:00:00 2001 From: dapan1121 Date: Wed, 14 Sep 2022 13:29:06 +0800 Subject: [PATCH 070/138] fix: fix insert memory leak --- source/client/src/clientHb.c | 3 +++ source/libs/parser/src/parInsert.c | 4 +--- source/libs/parser/src/parUtil.c | 2 +- 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/source/client/src/clientHb.c b/source/client/src/clientHb.c index 84a827ed78..e484e3c59c 100644 --- a/source/client/src/clientHb.c +++ b/source/client/src/clientHb.c @@ -414,6 +414,9 @@ int32_t hbGetQueryBasicInfo(SClientHbKey *connKey, SClientHbReq *req) { int32_t code = hbBuildQueryDesc(hbBasic, pTscObj); if (code) { releaseTscObj(connKey->tscRid); + if (hbBasic->queryDesc) { + taosArrayDestroyEx(hbBasic->queryDesc, tFreeClientHbQueryDesc); + } taosMemoryFree(hbBasic); return code; } diff --git a/source/libs/parser/src/parInsert.c b/source/libs/parser/src/parInsert.c index 162161b67a..d351333c3e 100644 --- a/source/libs/parser/src/parInsert.c +++ b/source/libs/parser/src/parInsert.c @@ -1420,9 +1420,7 @@ static int32_t parseDataFromFile(SInsertParseContext* pCxt, SToken filePath, STa } static void destroyInsertParseContextForTable(SInsertParseContext* pCxt) { - if (!pCxt->pComCxt->async) { - taosMemoryFreeClear(pCxt->pTableMeta); - } + taosMemoryFreeClear(pCxt->pTableMeta); destroyBoundColumnInfo(&pCxt->tags); tdDestroySVCreateTbReq(&pCxt->createTblReq); } diff --git a/source/libs/parser/src/parUtil.c b/source/libs/parser/src/parUtil.c index 32513fd0b6..daab80667c 100644 --- a/source/libs/parser/src/parUtil.c +++ b/source/libs/parser/src/parUtil.c @@ -1124,7 +1124,7 @@ int32_t getTableMetaFromCacheForInsert(SArray* pTableMetaPos, SParseMetaCache* p int32_t reqIndex = *(int32_t*)taosArrayGet(pTableMetaPos, tableNo); SMetaRes* pRes = taosArrayGet(pMetaCache->pTableMetaData, reqIndex); if (TSDB_CODE_SUCCESS == pRes->code) { - *pMeta = pRes->pRes; + *pMeta = tableMetaDup(pRes->pRes); if (NULL == *pMeta) { return TSDB_CODE_OUT_OF_MEMORY; } From 8905d37b7065ffc0832ae96d9141e55e55ff76b8 Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Wed, 14 Sep 2022 13:35:46 +0800 Subject: [PATCH 071/138] fix test cases --- tests/system-test/2-query/max.py | 21 ++------------- tests/system-test/2-query/min.py | 45 +++++--------------------------- 2 files changed, 8 insertions(+), 58 deletions(-) diff --git a/tests/system-test/2-query/max.py b/tests/system-test/2-query/max.py index 169b1c2c38..5cc9a2d9e8 100644 --- a/tests/system-test/2-query/max.py +++ b/tests/system-test/2-query/max.py @@ -38,18 +38,7 @@ class TDTestCase: elif i>=9: tdSql.checkData(0, 0, np.max(floatData)) - tdSql.query(f"select max(now()) from {dbname}.stb_1") - tdSql.checkRows(1) - - tdSql.query(f"select last(ts) from {dbname}.stb_1") - lastTs = tdSql.getData(0, 0) - tdSql.query(f"select max(ts) from {dbname}.stb_1") - tdSql.checkData(0, 0, lastTs) - - tdSql.query(f"select last(ts) from {dbname}.stb") - lastTs = tdSql.getData(0, 0) - tdSql.query(f"select max(ts) from {dbname}.stb") - tdSql.checkData(0, 0, lastTs) + tdSql.error(f"select max(now()) from {dbname}.stb_1") tdSql.query(f"select max(col1) from {dbname}.stb_1 where col2<=5") tdSql.checkData(0,0,5) @@ -78,13 +67,7 @@ class TDTestCase: elif i>=9: tdSql.checkData(0, 0, np.max(floatData)) - tdSql.query(f"select max(now()) from {dbname}.ntb") - tdSql.checkRows(1) - - tdSql.query(f"select last(ts) from {dbname}.ntb") - lastTs = tdSql.getData(0, 0) - tdSql.query(f"select max(ts) from {dbname}.ntb") - tdSql.checkData(0, 0, lastTs) + tdSql.error(f"select max(now()) from {dbname}.ntb") tdSql.query(f"select max(col1) from {dbname}.ntb where col2<=5") tdSql.checkData(0,0,5) diff --git a/tests/system-test/2-query/min.py b/tests/system-test/2-query/min.py index 3d46b7b222..d97c4340f4 100644 --- a/tests/system-test/2-query/min.py +++ b/tests/system-test/2-query/min.py @@ -37,6 +37,8 @@ class TDTestCase: floatData.append(i + 0.1) # max verifacation + tdSql.error(f"select min(now()) from {dbname}.stb_1") + tdSql.error(f"select min(ts) from {dbname}.stb_1") tdSql.error(f"select min(col7) from {dbname}.stb_1") tdSql.error(f"select min(col8) from {dbname}.stb_1") tdSql.error(f"select min(col9) from {dbname}.stb_1") @@ -67,20 +69,9 @@ class TDTestCase: tdSql.query(f"select min(col1) from {dbname}.stb_1 where col2>=5") tdSql.checkData(0,0,5) - tdSql.query(f"select min(now()) from {dbname}.stb_1") - tdSql.checkRows(1) - - tdSql.query(f"select first(ts) from {dbname}.stb_1") - firstTs = tdSql.getData(0, 0) - tdSql.query(f"select min(ts) from {dbname}.stb_1") - tdSql.checkData(0, 0, firstTs) - - tdSql.query(f"select first(ts) from {dbname}.stb_1") - firstTs = tdSql.getData(0, 0) - tdSql.query(f"select min(ts) from {dbname}.stb_1") - tdSql.checkData(0, 0, firstTs) - + tdSql.error(f"select min(now()) from {dbname}.stb_1") + tdSql.error(f"select min(ts) from {dbname}.stb_1") tdSql.error(f"select min(col7) from {dbname}.stb_1") tdSql.error(f"select min(col8) from {dbname}.stb_1") tdSql.error(f"select min(col9) from {dbname}.stb_1") @@ -111,19 +102,8 @@ class TDTestCase: tdSql.query(f"select min(col1) from {dbname}.stb where col2>=5") tdSql.checkData(0,0,5) - tdSql.query(f"select min(now()) from {dbname}.stb_1") - tdSql.checkRows(1) - - tdSql.query(f"select first(ts) from {dbname}.stb_1") - firstTs = tdSql.getData(0, 0) - tdSql.query(f"select min(ts) from {dbname}.stb_1") - tdSql.checkData(0, 0, firstTs) - - tdSql.query(f"select first(ts) from {dbname}.stb_1") - firstTs = tdSql.getData(0, 0) - tdSql.query(f"select min(ts) from {dbname}.stb_1") - tdSql.checkData(0, 0, firstTs) - + tdSql.error(f"select min(now()) from {dbname}.stb_1") + tdSql.error(f"select min(ts) from {dbname}.stb_1") tdSql.error(f"select min(col7) from {dbname}.ntb") tdSql.error(f"select min(col8) from {dbname}.ntb") tdSql.error(f"select min(col9) from {dbname}.ntb") @@ -154,19 +134,6 @@ class TDTestCase: tdSql.query(f"select min(col1) from {dbname}.ntb where col2>=5") tdSql.checkData(0,0,5) - tdSql.query(f"select min(now()) from {dbname}.stb_1") - tdSql.checkRows(1) - - tdSql.query(f"select first(ts) from {dbname}.stb_1") - firstTs = tdSql.getData(0, 0) - tdSql.query(f"select min(ts) from {dbname}.stb_1") - tdSql.checkData(0, 0, firstTs) - - tdSql.query(f"select first(ts) from {dbname}.stb_1") - firstTs = tdSql.getData(0, 0) - tdSql.query(f"select min(ts) from {dbname}.stb_1") - tdSql.checkData(0, 0, firstTs) - def stop(self): tdSql.close() From d2f6a7928686556ea44d9c52f2b59aaeeac25f59 Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Wed, 14 Sep 2022 13:38:39 +0800 Subject: [PATCH 072/138] fix docs --- docs/en/12-taos-sql/10-function.md | 44 +++++++++++++++--------------- docs/zh/12-taos-sql/10-function.md | 38 +++++++++++++------------- 2 files changed, 41 insertions(+), 41 deletions(-) diff --git a/docs/en/12-taos-sql/10-function.md b/docs/en/12-taos-sql/10-function.md index f74d0dbe5c..ab1d2f900b 100644 --- a/docs/en/12-taos-sql/10-function.md +++ b/docs/en/12-taos-sql/10-function.md @@ -126,7 +126,7 @@ SELECT COS(field_name) FROM { tb_name | stb_name } [WHERE clause] SELECT FLOOR(field_name) FROM { tb_name | stb_name } [WHERE clause]; ``` -**Description**: The rounded down value of a specific field +**Description**: The rounded down value of a specific field **More explanations**: The restrictions are same as those of the `CEIL` function. #### LOG @@ -173,7 +173,7 @@ SELECT POW(field_name, power) FROM { tb_name | stb_name } [WHERE clause] SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause]; ``` -**Description**: The rounded value of a specific field. +**Description**: The rounded value of a specific field. **More explanations**: The restrictions are same as those of the `CEIL` function. @@ -434,7 +434,7 @@ SELECT TO_ISO8601(ts[, timezone]) FROM { tb_name | stb_name } [WHERE clause]; **More explanations**: - You can specify a time zone in the following format: [z/Z, +/-hhmm, +/-hh, +/-hh:mm]。 For example, TO_ISO8601(1, "+00:00"). -- If the input is a UNIX timestamp, the precision of the returned value is determined by the digits of the input timestamp +- If the input is a UNIX timestamp, the precision of the returned value is determined by the digits of the input timestamp - If the input is a column of TIMESTAMP type, the precision of the returned value is same as the precision set for the current data base in use @@ -769,14 +769,14 @@ SELECT HISTOGRAM(field_name，bin_type, bin_description, normalized) FROM tb_nam **Explanations**： - bin_type: parameter to indicate the bucket type, valid inputs are: "user_input", "linear_bin", "log_bin"。 -- bin_description: parameter to describe how to generate buckets，can be in the following JSON formats for each bin_type respectively: - - "user_input": "[1, 3, 5, 7]": +- bin_description: parameter to describe how to generate buckets，can be in the following JSON formats for each bin_type respectively: + - "user_input": "[1, 3, 5, 7]": User specified bin values. - + - "linear_bin": "{"start": 0.0, "width": 5.0, "count": 5, "infinity": true}" "start" - bin starting point. "width" - bin offset. "count" - number of bins generated. "infinity" - whether to add（-inf, inf）as start/end point in generated set of bins. The above "linear_bin" descriptor generates a set of bins: [-inf, 0.0, 5.0, 10.0, 15.0, 20.0, +inf]. - + - "log_bin": "{"start":1.0, "factor": 2.0, "count": 5, "infinity": true}" "start" - bin starting point. "factor" - exponential factor of bin offset. "count" - number of bins generated. "infinity" - whether to add（-inf, inf）as start/end point in generated range of bins. The above "linear_bin" descriptor generates a set of bins: [-inf, 1.0, 2.0, 4.0, 8.0, 16.0, +inf]. @@ -862,9 +862,9 @@ SELECT INTERP(field_name) FROM { tb_name | stb_name } [WHERE where_condition] RA - `INTERP` is used to get the value that matches the specified time slice from a column. If no such value exists an interpolation value will be returned based on `FILL` parameter. - The input data of `INTERP` is the value of the specified column and a `where` clause can be used to filter the original data. If no `where` condition is specified then all original data is the input. -- The output time range of `INTERP` is specified by `RANGE(timestamp1,timestamp2)` parameter, with timestamp1<=timestamp2. timestamp1 is the starting point of the output time range and must be specified. timestamp2 is the ending point of the output time range and must be specified. -- The number of rows in the result set of `INTERP` is determined by the parameter `EVERY`. Starting from timestamp1, one interpolation is performed for every time interval specified `EVERY` parameter. -- Interpolation is performed based on `FILL` parameter. +- The output time range of `INTERP` is specified by `RANGE(timestamp1,timestamp2)` parameter, with timestamp1<=timestamp2. timestamp1 is the starting point of the output time range and must be specified. timestamp2 is the ending point of the output time range and must be specified. +- The number of rows in the result set of `INTERP` is determined by the parameter `EVERY`. Starting from timestamp1, one interpolation is performed for every time interval specified `EVERY` parameter. +- Interpolation is performed based on `FILL` parameter. - `INTERP` can only be used to interpolate in single timeline. So it must be used with `partition by tbname` when it's used on a STable. ### LAST @@ -917,7 +917,7 @@ SELECT MAX(field_name) FROM { tb_name | stb_name } [WHERE clause]; **Return value type**:Same as the data type of the column being operated upon -**Applicable data types**: Numeric, Timestamp +**Applicable data types**: Numeric **Applicable table types**: standard tables and supertables @@ -932,7 +932,7 @@ SELECT MIN(field_name) FROM {tb_name | stb_name} [WHERE clause]; **Return value type**:Same as the data type of the column being operated upon -**Applicable data types**: Numeric, Timestamp +**Applicable data types**: Numeric **Applicable table types**: standard tables and supertables @@ -968,7 +968,7 @@ SELECT SAMPLE(field_name, K) FROM { tb_name | stb_name } [WHERE clause] **Applicable table types**: standard tables and supertables -**More explanations**: +**More explanations**: This function cannot be used in expression calculation. - Must be used with `PARTITION BY tbname` when it's used on a STable to force the result on each single timeline @@ -1046,10 +1046,10 @@ SELECT CSUM(field_name) FROM { tb_name | stb_name } [WHERE clause] **Applicable table types**: standard tables and supertables -**More explanations**: - +**More explanations**: + - Arithmetic operation can't be performed on the result of `csum` function -- Can only be used with aggregate functions This function can be used with supertables and standard tables. +- Can only be used with aggregate functions This function can be used with supertables and standard tables. - Must be used with `PARTITION BY tbname` when it's used on a STable to force the result on each single timeline @@ -1067,8 +1067,8 @@ SELECT DERIVATIVE(field_name, time_interval, ignore_negative) FROM tb_name [WHER **Applicable table types**: standard tables and supertables -**More explanation**: - +**More explanation**: + - It can be used together with `PARTITION BY tbname` against a STable. - It can be used together with a selected column. For example: select \_rowts, DERIVATIVE() from。 @@ -1086,7 +1086,7 @@ SELECT {DIFF(field_name, ignore_negative) | DIFF(field_name)} FROM tb_name [WHER **Applicable table types**: standard tables and supertables -**More explanation**: +**More explanation**: - The number of result rows is the number of rows subtracted by one, no output for the first row - It can be used together with a selected column. For example: select \_rowts, DIFF() from。 @@ -1123,9 +1123,9 @@ SELECT MAVG(field_name, K) FROM { tb_name | stb_name } [WHERE clause] **Applicable table types**: standard tables and supertables -**More explanations**: - -- Arithmetic operation can't be performed on the result of `MAVG`. +**More explanations**: + +- Arithmetic operation can't be performed on the result of `MAVG`. - Can only be used with data columns, can't be used with tags. - Can't be used with aggregate functions. - Must be used with `PARTITION BY tbname` when it's used on a STable to force the result on each single timeline diff --git a/docs/zh/12-taos-sql/10-function.md b/docs/zh/12-taos-sql/10-function.md index 9c5b7f771e..86e9aaa80f 100644 --- a/docs/zh/12-taos-sql/10-function.md +++ b/docs/zh/12-taos-sql/10-function.md @@ -127,7 +127,7 @@ SELECT COS(field_name) FROM { tb_name | stb_name } [WHERE clause] SELECT FLOOR(field_name) FROM { tb_name | stb_name } [WHERE clause]; ``` -**功能说明**：获得指定字段的向下取整数的结果。 +**功能说明**：获得指定字段的向下取整数的结果。 其他使用说明参见 CEIL 函数描述。 #### LOG @@ -174,7 +174,7 @@ SELECT POW(field_name, power) FROM { tb_name | stb_name } [WHERE clause] SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause]; ``` -**功能说明**：获得指定字段的四舍五入的结果。 +**功能说明**：获得指定字段的四舍五入的结果。 其他使用说明参见 CEIL 函数描述。 @@ -435,7 +435,7 @@ SELECT TO_ISO8601(ts[, timezone]) FROM { tb_name | stb_name } [WHERE clause]; **使用说明**： - timezone 参数允许输入的时区格式为: [z/Z, +/-hhmm, +/-hh, +/-hh:mm]。例如，TO_ISO8601(1, "+00:00")。 -- 如果输入是表示 UNIX 时间戳的整形，返回格式精度由时间戳的位数决定; +- 如果输入是表示 UNIX 时间戳的整形，返回格式精度由时间戳的位数决定; - 如果输入是 TIMESTAMP 类型的列，返回格式的时间戳精度与当前 DATABASE 设置的时间精度一致。 @@ -770,14 +770,14 @@ SELECT HISTOGRAM(field_name，bin_type, bin_description, normalized) FROM tb_nam **详细说明**： - bin_type 用户指定的分桶类型, 有效输入类型为"user_input“, ”linear_bin", "log_bin"。 -- bin_description 描述如何生成分桶区间，针对三种桶类型，分别为以下描述格式(均为 JSON 格式字符串)： - - "user_input": "[1, 3, 5, 7]" +- bin_description 描述如何生成分桶区间，针对三种桶类型，分别为以下描述格式(均为 JSON 格式字符串)： + - "user_input": "[1, 3, 5, 7]" 用户指定 bin 的具体数值。 - + - "linear_bin": "{"start": 0.0, "width": 5.0, "count": 5, "infinity": true}" "start" 表示数据起始点，"width" 表示每次 bin 偏移量, "count" 为 bin 的总数，"infinity" 表示是否添加（-inf, inf）作为区间起点和终点， 生成区间为[-inf, 0.0, 5.0, 10.0, 15.0, 20.0, +inf]。 - + - "log_bin": "{"start":1.0, "factor": 2.0, "count": 5, "infinity": true}" "start" 表示数据起始点，"factor" 表示按指数递增的因子，"count" 为 bin 的总数，"infinity" 表示是否添加（-inf, inf）作为区间起点和终点， 生成区间为[-inf, 1.0, 2.0, 4.0, 8.0, 16.0, +inf]。 @@ -918,7 +918,7 @@ SELECT MAX(field_name) FROM { tb_name | stb_name } [WHERE clause]; **返回数据类型**：同应用的字段。 -**适用数据类型**：数值类型，时间戳类型。 +**适用数据类型**：数值类型。 **适用于**：表和超级表。 @@ -933,7 +933,7 @@ SELECT MIN(field_name) FROM {tb_name | stb_name} [WHERE clause]; **返回数据类型**：同应用的字段。 -**适用数据类型**：数值类型，时间戳类型。 +**适用数据类型**：数值类型。 **适用于**：表和超级表。 @@ -969,7 +969,7 @@ SELECT SAMPLE(field_name, K) FROM { tb_name | stb_name } [WHERE clause] **适用于**：表和超级表。 -**使用说明**： +**使用说明**： - 不能参与表达式计算；该函数可以应用在普通表和超级表上； - 使用在超级表上的时候，需要搭配 PARTITION by tbname 使用，将结果强制规约到单个时间线。 @@ -1047,10 +1047,10 @@ SELECT CSUM(field_name) FROM { tb_name | stb_name } [WHERE clause] **适用于**：表和超级表。 -**使用说明**： - +**使用说明**： + - 不支持 +、-、*、/ 运算，如 csum(col1) + csum(col2)。 -- 只能与聚合（Aggregation）函数一起使用。 该函数可以应用在普通表和超级表上。 +- 只能与聚合（Aggregation）函数一起使用。 该函数可以应用在普通表和超级表上。 - 使用在超级表上的时候，需要搭配 PARTITION BY tbname使用，将结果强制规约到单个时间线。 @@ -1068,8 +1068,8 @@ SELECT DERIVATIVE(field_name, time_interval, ignore_negative) FROM tb_name [WHER **适用于**：表和超级表。 -**使用说明**: - +**使用说明**: + - DERIVATIVE 函数可以在由 PARTITION BY 划分出单独时间线的情况下用于超级表（也即 PARTITION BY tbname）。 - 可以与选择相关联的列一起使用。 例如: select \_rowts, DERIVATIVE() from。 @@ -1087,7 +1087,7 @@ SELECT {DIFF(field_name, ignore_negative) | DIFF(field_name)} FROM tb_name [WHER **适用于**：表和超级表。 -**使用说明**: +**使用说明**: - 输出结果行数是范围内总行数减一，第一行没有结果输出。 - 可以与选择相关联的列一起使用。 例如: select \_rowts, DIFF() from。 @@ -1124,9 +1124,9 @@ SELECT MAVG(field_name, K) FROM { tb_name | stb_name } [WHERE clause] **适用于**：表和超级表。 -**使用说明**： - -- 不支持 +、-、*、/ 运算，如 mavg(col1, k1) + mavg(col2, k1); +**使用说明**： + +- 不支持 +、-、*、/ 运算，如 mavg(col1, k1) + mavg(col2, k1); - 只能与普通列，选择（Selection）、投影（Projection）函数一起使用，不能与聚合（Aggregation）函数一起使用； - 使用在超级表上的时候，需要搭配 PARTITION BY tbname使用，将结果强制规约到单个时间线。 From 65ee59fb90a6c267fffed149d68621e849041796 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Wed, 14 Sep 2022 14:01:08 +0800 Subject: [PATCH 073/138] docs: update arch --- docs/zh/21-tdinternal/01-arch.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/zh/21-tdinternal/01-arch.md b/docs/zh/21-tdinternal/01-arch.md index 704524fd21..b128b9d438 100644 --- a/docs/zh/21-tdinternal/01-arch.md +++ b/docs/zh/21-tdinternal/01-arch.md @@ -26,7 +26,7 @@ TDengine 分布式架构的逻辑结构图如下： **管理节点（mnode）：** 一个虚拟的逻辑单元，负责所有数据节点运行状态的监控和维护，以及节点之间的负载均衡（图中 M）。同时，管理节点也负责元数据（包括用户、数据库、超级表等）的存储和管理，因此也称为 Meta Node。TDengine 集群中可配置多个（最多不超过 3 个）mnode，它们自动构建成为一个虚拟管理节点组（图中 M1，M2，M3）。mnode 支持多副本，采用 RAFT 一致性协议，保证系统的高可用与高可靠，任何数据更新操作只能在 Leader 上进行。mnode 集群的第一个节点在集群部署时自动完成，其他节点的创建与删除由用户通过 SQL 命令完成。每个 dnode 上至多有一个 mnode，由所属的数据节点的 EP 来唯一标识。每个 dnode 通过内部消息交互自动获取整个集群中所有 mnode 所在的 dnode 的 EP。 -**弹性计算节点（qnode）：** 一个虚拟的逻辑单元，运行查询计算任务，也包括基于系统表来实现的 show 命令（图中 Q）。集群中可配置多个 qnode，在整个集群内部共享使用（图中 Q1，Q2，Q3）。qnode 不与具体的 DB 绑定，即一个 qnode 可以同时执行多个 DB 的查询任务。每个 dnode 上至多有一个 qnode，由所属的数据节点的 EP 来唯一标识。客户端通过与 mnode 交互，获取可用的 qnode 列表，当没有可用的 qnode 时，计算任务在 vnode 中执行。 +**计算节点（qnode）：** 一个虚拟的逻辑单元，运行查询计算任务，也包括基于系统表来实现的 show 命令（图中 Q）。集群中可配置多个 qnode，在整个集群内部共享使用（图中 Q1，Q2，Q3）。qnode 不与具体的 DB 绑定，即一个 qnode 可以同时执行多个 DB 的查询任务。每个 dnode 上至多有一个 qnode，由所属的数据节点的 EP 来唯一标识。客户端通过与 mnode 交互，获取可用的 qnode 列表，当没有可用的 qnode 时，计算任务在 vnode 中执行。当一个查询执行时，依赖执行计划，调度器会安排一个或多个 qnode 来一起执行。qnode 能从 vnode 获取数据，也可以将自己的计算结果发给其他 qnode 做进一步的处理。通过引入独立的计算节点，TDengine 实现了存储和计算分离。 **流计算节点（snode）：** 一个虚拟的逻辑单元，只运行流计算任务（图中 S）。集群中可配置多个 snode，在整个集群内部共享使用（图中 S1，S2，S3）。snode 不与具体的 stream 绑定，即一个 snode 可以同时执行多个 stream 的计算任务。每个 dnode 上至多有一个 snode，由所属的数据节点的 EP 来唯一标识。由 mnode 调度可用的 snode 完成流计算任务，当没有可用的 snode 时，流计算任务在 vnode 中执行。 From 63f02c5103cf4559ff8b9facc5c0521a6d516498 Mon Sep 17 00:00:00 2001 From: dapan1121 Date: Wed, 14 Sep 2022 14:26:21 +0800 Subject: [PATCH 074/138] fix: fix free meta rsp issue --- source/common/src/tmsg.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index f96462945f..46e29fc07b 100644 --- a/source/common/src/tmsg.c +++ b/source/common/src/tmsg.c @@ -3344,7 +3344,13 @@ int32_t tDeserializeSSTbHbRsp(void *buf, int32_t bufLen, SSTbHbRsp *pRsp) { return 0; } -void tFreeSTableMetaRsp(void *pRsp) { taosMemoryFreeClear(((STableMetaRsp *)pRsp)->pSchemas); } +void tFreeSTableMetaRsp(void *pRsp) { + if (NULL == pRsp) { + return; + } + + taosMemoryFreeClear(((STableMetaRsp *)pRsp)->pSchemas); +} void tFreeSTableIndexRsp(void *info) { if (NULL == info) { From 2c2d13d92839c362e0f0d959dcaa9dd6040cad3b Mon Sep 17 00:00:00 2001 From: Shuduo Sang Date: Wed, 14 Sep 2022 14:38:18 +0800 Subject: [PATCH 075/138] fix: detech taosadapter exist when make install (#16827) --- packaging/tools/install.sh | 20 ++++++++++++++++---- packaging/tools/make_install.sh | 20 ++++++++++++++++---- 2 files changed, 32 insertions(+), 8 deletions(-) diff --git a/packaging/tools/install.sh b/packaging/tools/install.sh index f2f72acafa..5088e9bdac 100755 --- a/packaging/tools/install.sh +++ b/packaging/tools/install.sh @@ -840,14 +840,20 @@ function updateProduct() { echo echo -e "${GREEN_DARK}To configure ${productName} ${NC}: edit ${cfg_install_dir}/${configFile}" - echo -e "${GREEN_DARK}To configure Adapter (if has) ${NC}: edit ${cfg_install_dir}/${adapterName}.toml" + [ -f ${configDir}/taosadapter.toml ] && [ -f ${installDir}/bin/taosadapter ] && \ + echo -e "${GREEN_DARK}To configure Taos Adapter ${NC}: edit ${configDir}/taosadapter.toml" if ((${service_mod} == 0)); then echo -e "${GREEN_DARK}To start ${productName} ${NC}: ${csudo}systemctl start ${serverName}${NC}" + [ -f ${service_config_dir}/taosadapter.service ] && [ -f ${installDir}/bin/taosadapter ] && \ + echo -e "${GREEN_DARK}To start Taos Adatper ${NC}: ${csudo}systemctl start taosadapter ${NC}" elif ((${service_mod} == 1)); then echo -e "${GREEN_DARK}To start ${productName} ${NC}: ${csudo}service ${serverName} start${NC}" + [ -f ${service_config_dir}/taosadapter.service ] && [ -f ${installDir}/bin/taosadapter ] && \ + echo -e "${GREEN_DARK}To start Taos Adapter ${NC}: ${csudo}service taosadapter start${NC}" else - echo -e "${GREEN_DARK}To start Adapter (if has)${NC}: ${adapterName} &${NC}" echo -e "${GREEN_DARK}To start ${productName} ${NC}: ./${serverName}${NC}" + [ -f ${installDir}/bin/taosadapter ] && \ + echo -e "${GREEN_DARK}To start Taos Adapter ${NC}: taosadapter &${NC}" fi if [ ${openresty_work} = 'true' ]; then @@ -926,14 +932,20 @@ function installProduct() { # Ask if to start the service echo echo -e "${GREEN_DARK}To configure ${productName} ${NC}: edit ${cfg_install_dir}/${configFile}" - echo -e "${GREEN_DARK}To configure ${adapterName} (if has) ${NC}: edit ${cfg_install_dir}/${adapterName}.toml" + [ -f ${configDir}/taosadapter.toml ] && [ -f ${installDir}/bin/taosadapter ] && \ + echo -e "${GREEN_DARK}To configure Taos Adapter ${NC}: edit ${configDir}/taosadapter.toml" if ((${service_mod} == 0)); then echo -e "${GREEN_DARK}To start ${productName} ${NC}: ${csudo}systemctl start ${serverName}${NC}" + [ -f ${service_config_dir}/taosadapter.service ] && [ -f ${installDir}/bin/taosadapter ] && \ + echo -e "${GREEN_DARK}To start Taos Adatper ${NC}: ${csudo}systemctl start taosadapter ${NC}" elif ((${service_mod} == 1)); then echo -e "${GREEN_DARK}To start ${productName} ${NC}: ${csudo}service ${serverName} start${NC}" + [ -f ${service_config_dir}/taosadapter.service ] && [ -f ${installDir}/bin/taosadapter ] && \ + echo -e "${GREEN_DARK}To start Taos Adapter ${NC}: ${csudo}service taosadapter start${NC}" else - echo -e "${GREEN_DARK}To start Adapter (if has)${NC}: ${adapterName} &${NC}" echo -e "${GREEN_DARK}To start ${productName} ${NC}: ${serverName}${NC}" + [ -f ${installDir}/bin/taosadapter ] && \ + echo -e "${GREEN_DARK}To start Taos Adapter ${NC}: taosadapter &${NC}" fi if [ ! -z "$firstEp" ]; then diff --git a/packaging/tools/make_install.sh b/packaging/tools/make_install.sh index a6dceeeaad..d1e7a222cc 100755 --- a/packaging/tools/make_install.sh +++ b/packaging/tools/make_install.sh @@ -609,14 +609,20 @@ function update_TDengine() { echo echo -e "${GREEN_DARK}To configure ${productName} ${NC}: edit ${configDir}/${configFile}" - echo -e "${GREEN_DARK}To configure Taos Adapter (if has) ${NC}: edit ${configDir}/taosadapter.toml" + [ -f ${configDir}/taosadapter.toml ] && [ -f ${installDir}/bin/taosadapter ] && \ + echo -e "${GREEN_DARK}To configure Taos Adapter ${NC}: edit ${configDir}/taosadapter.toml" if ((${service_mod} == 0)); then echo -e "${GREEN_DARK}To start ${productName} ${NC}: ${csudo}systemctl start ${serverName}${NC}" + [ -f ${service_config_dir}/taosadapter.service ] && [ -f ${installDir}/bin/taosadapter ] && \ + echo -e "${GREEN_DARK}To start Taos Adatper ${NC}: ${csudo}systemctl start taosadapter ${NC}" elif ((${service_mod} == 1)); then echo -e "${GREEN_DARK}To start ${productName} ${NC}: ${csudo}service ${serverName} start${NC}" + [ -f ${service_config_dir}/taosadapter.service ] && [ -f ${installDir}/bin/taosadapter ] && \ + echo -e "${GREEN_DARK}To start Taos Adapter ${NC}: ${csudo}service taosadapter start${NC}" else - echo -e "${GREEN_DARK}To start Taos Adapter (if has)${NC}: taosadapter &${NC}" echo -e "${GREEN_DARK}To start ${productName} ${NC}: ${serverName}${NC}" + [ -f ${installDir}/bin/taosadapter ] && \ + echo -e "${GREEN_DARK}To start Taos Adapter ${NC}: taosadapter &${NC}" fi echo -e "${GREEN_DARK}To access ${productName} ${NC}: use ${GREEN_UNDERLINE}${clientName}${NC} in shell${NC}" @@ -649,14 +655,20 @@ function install_TDengine() { echo -e "\033[44;32;1m${productName} is installed successfully!${NC}" echo echo -e "${GREEN_DARK}To configure ${productName} ${NC}: edit ${configDir}/${configFile}" - echo -e "${GREEN_DARK}To configure taosadapter (if has) ${NC}: edit ${configDir}/taosadapter.toml" + [ -f ${configDir}/taosadapter.toml ] && [ -f ${installDir}/bin/taosadapter ] && \ + echo -e "${GREEN_DARK}To configure Taos Adapter ${NC}: edit ${configDir}/taosadapter.toml" if ((${service_mod} == 0)); then echo -e "${GREEN_DARK}To start ${productName} ${NC}: ${csudo}systemctl start ${serverName}${NC}" + [ -f ${service_config_dir}/taosadapter.service ] && [ -f ${installDir}/bin/taosadapter ] && \ + echo -e "${GREEN_DARK}To start Taos Adapter ${NC}: ${csudo}systemctl start taosadapter ${NC}" elif ((${service_mod} == 1)); then echo -e "${GREEN_DARK}To start ${productName} ${NC}: ${csudo}service ${serverName} start${NC}" + [ -f ${service_config_dir}/taosadapter.service ] && [ -f ${installDir}/bin/taosadapter ] && \ + echo -e "${GREEN_DARK}To start Taos Adapter ${NC}: ${csudo}service taosadapter start${NC}" else - echo -e "${GREEN_DARK}To start Taos Adapter (if has)${NC}: taosadapter &${NC}" echo -e "${GREEN_DARK}To start ${productName} ${NC}: ./${serverName}${NC}" + [ -f ${installDir}/bin/taosadapter ] && \ + echo -e "${GREEN_DARK}To start Taos Adapter ${NC}: taosadapter &${NC}" fi echo -e "${GREEN_DARK}To access ${productName} ${NC}: use ${GREEN_UNDERLINE}${clientName}${NC} in shell${NC}" From 6e561a6c78954ee1dfc1c78cab98140fd64ba510 Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Wed, 14 Sep 2022 14:46:14 +0800 Subject: [PATCH 076/138] fix: fix mem leak --- source/client/src/clientImpl.c | 3 +-- source/libs/index/src/indexTfile.c | 4 ---- source/libs/scheduler/src/schTask.c | 2 ++ 3 files changed, 3 insertions(+), 6 deletions(-) diff --git a/source/client/src/clientImpl.c b/source/client/src/clientImpl.c index e7b34ab783..70d7a49208 100644 --- a/source/client/src/clientImpl.c +++ b/source/client/src/clientImpl.c @@ -1369,7 +1369,7 @@ int32_t doProcessMsgFromServer(void* param) { updateTargetEpSet(pSendInfo, pTscObj, pMsg, pEpSet); SDataBuf buf = { - .msgType = pMsg->msgType, .len = pMsg->contLen, .pData = NULL, .handle = pMsg->info.handle, .pEpSet = NULL}; + .msgType = pMsg->msgType, .len = pMsg->contLen, .pData = NULL, .handle = pMsg->info.handle, .pEpSet = pEpSet}; if (pMsg->contLen > 0) { buf.pData = taosMemoryCalloc(1, pMsg->contLen); @@ -1385,7 +1385,6 @@ int32_t doProcessMsgFromServer(void* param) { rpcFreeCont(pMsg->pCont); destroySendMsgInfo(pSendInfo); - taosMemoryFree(arg->pEpset); taosMemoryFree(arg); return TSDB_CODE_SUCCESS; } diff --git a/source/libs/index/src/indexTfile.c b/source/libs/index/src/indexTfile.c index c3be0ea6f5..1fc631e9f3 100644 --- a/source/libs/index/src/indexTfile.c +++ b/source/libs/index/src/indexTfile.c @@ -323,10 +323,6 @@ static int32_t tfSearchCompareFunc(void* reader, SIndexTerm* tem, SIdxTRslt* tr, while ((rt = stmStNextWith(st, NULL)) != NULL) { FstSlice* s = &rt->data; char* ch = (char*)fstSliceData(s, NULL); - // if (0 != strncmp(ch, tem->colName, tem->nColName)) { - // swsResultDestroy(rt); - // break; - //} TExeCond cond = cmpFn(ch, p, tem->colType); if (MATCH == cond) { diff --git a/source/libs/scheduler/src/schTask.c b/source/libs/scheduler/src/schTask.c index c5f161b66a..ee60d02ba2 100644 --- a/source/libs/scheduler/src/schTask.c +++ b/source/libs/scheduler/src/schTask.c @@ -430,12 +430,14 @@ int32_t schHandleRedirect(SSchJob *pJob, SSchTask *pTask, SDataBuf *pData, int32 code = schDoTaskRedirect(pJob, pTask, pData, rspCode); taosMemoryFree(pData->pData); + taosMemoryFree(pData->pEpSet); SCH_RET(code); _return: taosMemoryFree(pData->pData); + taosMemoryFree(pData->pEpSet); SCH_RET(schProcessOnTaskFailure(pJob, pTask, code)); } From 417571140f9b71b1f623099bbf528a8a940d9069 Mon Sep 17 00:00:00 2001 From: Pan YANG Date: Wed, 14 Sep 2022 15:00:54 +0800 Subject: [PATCH 077/138] docs: fix escape of backtick --- docs/zh/12-taos-sql/20-keywords.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/zh/12-taos-sql/20-keywords.md b/docs/zh/12-taos-sql/20-keywords.md index ee36dc44f0..57a45b0a00 100644 --- a/docs/zh/12-taos-sql/20-keywords.md +++ b/docs/zh/12-taos-sql/20-keywords.md @@ -6,7 +6,7 @@ description: TDengine 保留关键字的详细列表 ## 保留关键字 -目前 TDengine 有将近 200 个内部保留关键字，这些关键字无论大小写如果需要用作库名、表名、STable 名、数据列名及标签列名等，需要使用符合``将关键字括起来使用，例如`ADD`。 +目前 TDengine 有将近 200 个内部保留关键字，这些关键字无论大小写如果需要用作库名、表名、STable 名、数据列名及标签列名等，需要使用符号 `` ` `` 将关键字括起来使用，例如 \`ADD\`。 关键字列表如下： ### A From 64226e5e55131c39ae987f9a4553b03c8f2329d8 Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Wed, 14 Sep 2022 15:01:14 +0800 Subject: [PATCH 078/138] fix error code number --- include/util/taoserror.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/util/taoserror.h b/include/util/taoserror.h index 0058b03b30..086de593d0 100644 --- a/include/util/taoserror.h +++ b/include/util/taoserror.h @@ -577,7 +577,7 @@ int32_t* taosGetErrno(); #define TSDB_CODE_FUNC_FUNTION_PARA_TYPE TAOS_DEF_ERROR_CODE(0, 0x2802) #define TSDB_CODE_FUNC_FUNTION_PARA_VALUE TAOS_DEF_ERROR_CODE(0, 0x2803) #define TSDB_CODE_FUNC_NOT_BUILTIN_FUNTION TAOS_DEF_ERROR_CODE(0, 0x2804) -#define TSDB_CODE_FUNC_DUP_TIMESTAMP TAOS_DEF_ERROR_CODE(0, 0x012B) +#define TSDB_CODE_FUNC_DUP_TIMESTAMP TAOS_DEF_ERROR_CODE(0, 0x2805) //udf #define TSDB_CODE_UDF_STOPPING TAOS_DEF_ERROR_CODE(0, 0x2901) From 43bdaa6c1906dd660f951c5d1ad30079958a6fab Mon Sep 17 00:00:00 2001 From: dapan1121 Date: Wed, 14 Sep 2022 16:11:26 +0800 Subject: [PATCH 079/138] fix: fix invalid free issue --- source/client/src/clientRawBlockWrite.c | 6 ------ 1 file changed, 6 deletions(-) diff --git a/source/client/src/clientRawBlockWrite.c b/source/client/src/clientRawBlockWrite.c index 6e9711f57b..c135965f07 100644 --- a/source/client/src/clientRawBlockWrite.c +++ b/source/client/src/clientRawBlockWrite.c @@ -701,12 +701,6 @@ typedef struct SVgroupCreateTableBatch { static void destroyCreateTbReqBatch(void* data) { SVgroupCreateTableBatch* pTbBatch = (SVgroupCreateTableBatch*)data; - size_t size = taosArrayGetSize(pTbBatch->req.pArray); - for (int32_t i = 0; i < size; ++i) { - SVCreateTbReq* pTableReq = taosArrayGet(pTbBatch->req.pArray, i); - tdDestroySVCreateTbReq(pTableReq); - } - taosArrayDestroy(pTbBatch->req.pArray); } From 4c6a8bbc95f0e76199dd0226118a3f25bde58e12 Mon Sep 17 00:00:00 2001 From: Liu Jicong Date: Wed, 14 Sep 2022 16:50:42 +0800 Subject: [PATCH 080/138] feat(stream): stream state support tuple --- include/common/tcommon.h | 33 +++++- include/libs/function/function.h | 145 ++++++++++++------------ include/libs/stream/streamState.h | 78 +++++++++++++ include/libs/stream/tstream.h | 42 +------ source/libs/function/CMakeLists.txt | 2 +- source/libs/function/src/builtinsimpl.c | 74 +++++++----- source/libs/stream/src/streamState.c | 21 +++- 7 files changed, 251 insertions(+), 144 deletions(-) create mode 100644 include/libs/stream/streamState.h diff --git a/include/common/tcommon.h b/include/common/tcommon.h index 37db574d98..ba4baa0130 100644 --- a/include/common/tcommon.h +++ b/include/common/tcommon.h @@ -45,8 +45,8 @@ enum { // clang-format on typedef struct { - TSKEY ts; uint64_t groupId; + TSKEY ts; } SWinKey; static inline int SWinKeyCmpr(const void* pKey1, int kLen1, const void* pKey2, int kLen2) { @@ -68,6 +68,37 @@ static inline int SWinKeyCmpr(const void* pKey1, int kLen1, const void* pKey2, i return 0; } +typedef struct { + uint64_t groupId; + TSKEY ts; + int32_t exprIdx; +} STupleKey; + +static inline int STupleKeyCmpr(const void* pKey1, int kLen1, const void* pKey2, int kLen2) { + STupleKey* pTuple1 = (STupleKey*)pKey1; + STupleKey* pTuple2 = (STupleKey*)pKey2; + + if (pTuple1->groupId > pTuple2->groupId) { + return 1; + } else if (pTuple1->groupId < pTuple2->groupId) { + return -1; + } + + if (pTuple1->ts > pTuple2->ts) { + return 1; + } else if (pTuple1->ts < pTuple2->ts) { + return -1; + } + + if (pTuple1->exprIdx > pTuple2->exprIdx) { + return 1; + } else if (pTuple1->exprIdx < pTuple2->exprIdx) { + return -1; + } + + return 0; +} + enum { TMQ_MSG_TYPE__DUMMY = 0, TMQ_MSG_TYPE__POLL_RSP, diff --git a/include/libs/function/function.h b/include/libs/function/function.h index 3f26eee86a..65ddc180d6 100644 --- a/include/libs/function/function.h +++ b/include/libs/function/function.h @@ -34,66 +34,69 @@ typedef struct SFuncExecEnv { int32_t calcMemSize; } SFuncExecEnv; -typedef bool (*FExecGetEnv)(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv); -typedef bool (*FExecInit)(struct SqlFunctionCtx *pCtx, struct SResultRowEntryInfo* pResultCellInfo); +typedef bool (*FExecGetEnv)(struct SFunctionNode *pFunc, SFuncExecEnv *pEnv); +typedef bool (*FExecInit)(struct SqlFunctionCtx *pCtx, struct SResultRowEntryInfo *pResultCellInfo); typedef int32_t (*FExecProcess)(struct SqlFunctionCtx *pCtx); -typedef int32_t (*FExecFinalize)(struct SqlFunctionCtx *pCtx, SSDataBlock* pBlock); +typedef int32_t (*FExecFinalize)(struct SqlFunctionCtx *pCtx, SSDataBlock *pBlock); typedef int32_t (*FScalarExecProcess)(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput); typedef int32_t (*FExecCombine)(struct SqlFunctionCtx *pDestCtx, struct SqlFunctionCtx *pSourceCtx); typedef struct SScalarFuncExecFuncs { - FExecGetEnv getEnv; + FExecGetEnv getEnv; FScalarExecProcess process; } SScalarFuncExecFuncs; typedef struct SFuncExecFuncs { - FExecGetEnv getEnv; - FExecInit init; - FExecProcess process; + FExecGetEnv getEnv; + FExecInit init; + FExecProcess process; FExecFinalize finalize; - FExecCombine combine; + FExecCombine combine; } SFuncExecFuncs; -#define MAX_INTERVAL_TIME_WINDOW 1000000 // maximum allowed time windows in final results +#define MAX_INTERVAL_TIME_WINDOW 1000000 // maximum allowed time windows in final results #define TOP_BOTTOM_QUERY_LIMIT 100 #define FUNCTIONS_NAME_MAX_LENGTH 16 typedef struct SResultRowEntryInfo { - bool initialized:1; // output buffer has been initialized - bool complete:1; // query has completed - uint8_t isNullRes:6; // the result is null - uint16_t numOfRes; // num of output result in current buffer. NOT NULL RESULT + bool initialized : 1; // output buffer has been initialized + bool complete : 1; // query has completed + uint8_t isNullRes : 6; // the result is null + uint16_t numOfRes; // num of output result in current buffer. NOT NULL RESULT } SResultRowEntryInfo; // determine the real data need to calculated the result enum { - BLK_DATA_NOT_LOAD = 0x0, - BLK_DATA_SMA_LOAD = 0x1, + BLK_DATA_NOT_LOAD = 0x0, + BLK_DATA_SMA_LOAD = 0x1, BLK_DATA_DATA_LOAD = 0x3, - BLK_DATA_FILTEROUT = 0x4, // discard current data block since it is not qualified for filter + BLK_DATA_FILTEROUT = 0x4, // discard current data block since it is not qualified for filter }; enum { - MAIN_SCAN = 0x0u, - REVERSE_SCAN = 0x1u, // todo remove it - REPEAT_SCAN = 0x2u, //repeat scan belongs to the master scan - MERGE_STAGE = 0x20u, + MAIN_SCAN = 0x0u, + REVERSE_SCAN = 0x1u, // todo remove it + REPEAT_SCAN = 0x2u, // repeat scan belongs to the master scan + MERGE_STAGE = 0x20u, }; typedef struct SPoint1 { - int64_t key; - union{double val; char* ptr;}; + int64_t key; + union { + double val; + char *ptr; + }; } SPoint1; struct SqlFunctionCtx; struct SResultRowEntryInfo; -//for selectivity query, the corresponding tag value is assigned if the data is qualified +// for selectivity query, the corresponding tag value is assigned if the data is qualified typedef struct SSubsidiaryResInfo { - int16_t num; - int32_t rowLen; - char* buf; // serialize data buffer + int16_t num; + int32_t rowLen; + char *buf; // serialize data buffer struct SqlFunctionCtx **pCtx; } SSubsidiaryResInfo; @@ -106,69 +109,70 @@ typedef struct SResultDataInfo { } SResultDataInfo; #define GET_RES_INFO(ctx) ((ctx)->resultInfo) -#define GET_ROWCELL_INTERBUF(_c) ((void*) ((char*)(_c) + sizeof(SResultRowEntryInfo))) +#define GET_ROWCELL_INTERBUF(_c) ((void *)((char *)(_c) + sizeof(SResultRowEntryInfo))) typedef struct SInputColumnInfoData { - int32_t totalRows; // total rows in current columnar data - int32_t startRowIndex; // handle started row index - int32_t numOfRows; // the number of rows needs to be handled - int32_t numOfInputCols; // PTS is not included - bool colDataAggIsSet;// if agg is set or not - SColumnInfoData *pPTS; // primary timestamp column + int32_t totalRows; // total rows in current columnar data + int32_t startRowIndex; // handle started row index + int32_t numOfRows; // the number of rows needs to be handled + int32_t numOfInputCols; // PTS is not included + bool colDataAggIsSet; // if agg is set or not + SColumnInfoData *pPTS; // primary timestamp column SColumnInfoData **pData; SColumnDataAgg **pColumnDataAgg; - uint64_t uid; // table uid, used to set the tag value when building the final query result for selectivity functions. + uint64_t uid; // table uid, used to set the tag value when building the final query result for selectivity functions. } SInputColumnInfoData; typedef struct SSerializeDataHandle { - struct SDiskbasedBuf* pBuf; + struct SDiskbasedBuf *pBuf; int32_t currentPage; + void *pState; } SSerializeDataHandle; // sql function runtime context typedef struct SqlFunctionCtx { - SInputColumnInfoData input; - SResultDataInfo resDataInfo; - uint32_t order; // data block scanner order: asc|desc - uint8_t scanFlag; // record current running step, default: 0 - int16_t functionId; // function id - char *pOutput; // final result output buffer, point to sdata->data - int32_t numOfParams; - SFunctParam *param; // input parameter, e.g., top(k, 20), the number of results for top query is kept in param - SColumnInfoData *pTsOutput; // corresponding output buffer for timestamp of each result, e.g., top/bottom*/ - int32_t offset; - struct SResultRowEntryInfo *resultInfo; - SSubsidiaryResInfo subsidiaries; - SPoint1 start; - SPoint1 end; - SFuncExecFuncs fpSet; - SScalarFuncExecFuncs sfp; - struct SExprInfo *pExpr; - struct SSDataBlock *pSrcBlock; - struct SSDataBlock *pDstBlock; // used by indefinite rows function to set selectivity - SSerializeDataHandle saveHandle; - bool isStream; + SInputColumnInfoData input; + SResultDataInfo resDataInfo; + uint32_t order; // data block scanner order: asc|desc + uint8_t scanFlag; // record current running step, default: 0 + int16_t functionId; // function id + char *pOutput; // final result output buffer, point to sdata->data + int32_t numOfParams; + SFunctParam *param; // input parameter, e.g., top(k, 20), the number of results for top query is kept in param + SColumnInfoData *pTsOutput; // corresponding output buffer for timestamp of each result, e.g., top/bottom*/ + int32_t offset; + struct SResultRowEntryInfo *resultInfo; + SSubsidiaryResInfo subsidiaries; + SPoint1 start; + SPoint1 end; + SFuncExecFuncs fpSet; + SScalarFuncExecFuncs sfp; + struct SExprInfo *pExpr; + struct SSDataBlock *pSrcBlock; + struct SSDataBlock *pDstBlock; // used by indefinite rows function to set selectivity + SSerializeDataHandle saveHandle; + bool isStream; - char udfName[TSDB_FUNC_NAME_LEN]; + char udfName[TSDB_FUNC_NAME_LEN]; } SqlFunctionCtx; enum { - TEXPR_BINARYEXPR_NODE= 0x1, + TEXPR_BINARYEXPR_NODE = 0x1, TEXPR_UNARYEXPR_NODE = 0x2, }; typedef struct tExprNode { int32_t nodeType; union { - struct {// function node - char functionName[FUNCTIONS_NAME_MAX_LENGTH]; // todo refactor - int32_t functionId; - int32_t num; - struct SFunctionNode *pFunctNode; + struct { // function node + char functionName[FUNCTIONS_NAME_MAX_LENGTH]; // todo refactor + int32_t functionId; + int32_t num; + struct SFunctionNode *pFunctNode; } _function; struct { - struct SNode* pRootNode; + struct SNode *pRootNode; } _optrRoot; }; } tExprNode; @@ -182,17 +186,18 @@ struct SScalarParam { int32_t numOfRows; }; -void cleanupResultRowEntry(struct SResultRowEntryInfo* pCell); -int32_t getNumOfResult(SqlFunctionCtx* pCtx, int32_t num, SSDataBlock* pResBlock); -bool isRowEntryCompleted(struct SResultRowEntryInfo* pEntry); -bool isRowEntryInitialized(struct SResultRowEntryInfo* pEntry); +void cleanupResultRowEntry(struct SResultRowEntryInfo *pCell); +int32_t getNumOfResult(SqlFunctionCtx *pCtx, int32_t num, SSDataBlock *pResBlock); +bool isRowEntryCompleted(struct SResultRowEntryInfo *pEntry); +bool isRowEntryInitialized(struct SResultRowEntryInfo *pEntry); typedef struct SPoint { int64_t key; - void * val; + void *val; } SPoint; -int32_t taosGetLinearInterpolationVal(SPoint* point, int32_t outputType, SPoint* point1, SPoint* point2, int32_t inputType); +int32_t taosGetLinearInterpolationVal(SPoint *point, int32_t outputType, SPoint *point1, SPoint *point2, + int32_t inputType); /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // udf api diff --git a/include/libs/stream/streamState.h b/include/libs/stream/streamState.h new file mode 100644 index 0000000000..df19544396 --- /dev/null +++ b/include/libs/stream/streamState.h @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * This program is free software: you can use, redistribute, and/or modify + * it under the terms of the GNU Affero General Public License, version 3 + * or later ("AGPL"), as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +#include "tdatablock.h" +#include "tdbInt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _STREAM_STATE_H_ +#define _STREAM_STATE_H_ + +typedef struct SStreamTask SStreamTask; + +// incremental state storage +typedef struct { + SStreamTask* pOwner; + TDB* db; + TTB* pStateDb; + TTB* pFuncStateDb; + TXN txn; +} SStreamState; + +SStreamState* streamStateOpen(char* path, SStreamTask* pTask); +void streamStateClose(SStreamState* pState); +int32_t streamStateBegin(SStreamState* pState); +int32_t streamStateCommit(SStreamState* pState); +int32_t streamStateAbort(SStreamState* pState); + +typedef struct { + TBC* pCur; +} SStreamStateCur; + +#if 1 +int32_t streamStateFuncPut(SStreamState* pState, const STupleKey* key, const void* value, int32_t vLen); +int32_t streamStateFuncGet(SStreamState* pState, const STupleKey* key, void** pVal, int32_t* pVLen); +int32_t streamStateFuncDel(SStreamState* pState, const STupleKey* key); + +int32_t streamStatePut(SStreamState* pState, const SWinKey* key, const void* value, int32_t vLen); +int32_t streamStateGet(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen); +int32_t streamStateDel(SStreamState* pState, const SWinKey* key); +int32_t streamStateAddIfNotExist(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen); +int32_t streamStateReleaseBuf(SStreamState* pState, const SWinKey* key, void* pVal); +void streamFreeVal(void* val); + +SStreamStateCur* streamStateGetCur(SStreamState* pState, const SWinKey* key); +SStreamStateCur* streamStateSeekKeyNext(SStreamState* pState, const SWinKey* key); +SStreamStateCur* streamStateSeekKeyPrev(SStreamState* pState, const SWinKey* key); +void streamStateFreeCur(SStreamStateCur* pCur); + +int32_t streamStateGetKVByCur(SStreamStateCur* pCur, SWinKey* pKey, const void** pVal, int32_t* pVLen); + +int32_t streamStateSeekFirst(SStreamState* pState, SStreamStateCur* pCur); +int32_t streamStateSeekLast(SStreamState* pState, SStreamStateCur* pCur); + +int32_t streamStateCurNext(SStreamState* pState, SStreamStateCur* pCur); +int32_t streamStateCurPrev(SStreamState* pState, SStreamStateCur* pCur); + +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* ifndef _STREAM_STATE_H_ */ diff --git a/include/libs/stream/tstream.h b/include/libs/stream/tstream.h index afd8de6b1c..554d66d621 100644 --- a/include/libs/stream/tstream.h +++ b/include/libs/stream/tstream.h @@ -16,6 +16,7 @@ #include "executor.h" #include "os.h" #include "query.h" +#include "streamState.h" #include "tdatablock.h" #include "tdbInt.h" #include "tmsg.h" @@ -263,14 +264,6 @@ typedef struct { SArray* checkpointVer; } SStreamRecoveringState; -// incremental state storage -typedef struct { - SStreamTask* pOwner; - TDB* db; - TTB* pStateDb; - TXN txn; -} SStreamState; - typedef struct SStreamTask { int64_t streamId; int32_t taskId; @@ -540,39 +533,6 @@ int32_t streamMetaCommit(SStreamMeta* pMeta); int32_t streamMetaRollBack(SStreamMeta* pMeta); int32_t streamLoadTasks(SStreamMeta* pMeta); -SStreamState* streamStateOpen(char* path, SStreamTask* pTask); -void streamStateClose(SStreamState* pState); -int32_t streamStateBegin(SStreamState* pState); -int32_t streamStateCommit(SStreamState* pState); -int32_t streamStateAbort(SStreamState* pState); - -typedef struct { - TBC* pCur; -} SStreamStateCur; - -#if 1 -int32_t streamStatePut(SStreamState* pState, const SWinKey* key, const void* value, int32_t vLen); -int32_t streamStateGet(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen); -int32_t streamStateDel(SStreamState* pState, const SWinKey* key); -int32_t streamStateAddIfNotExist(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen); -int32_t streamStateReleaseBuf(SStreamState* pState, const SWinKey* key, void* pVal); -void streamFreeVal(void* val); - -SStreamStateCur* streamStateGetCur(SStreamState* pState, const SWinKey* key); -SStreamStateCur* streamStateSeekKeyNext(SStreamState* pState, const SWinKey* key); -SStreamStateCur* streamStateSeekKeyPrev(SStreamState* pState, const SWinKey* key); -void streamStateFreeCur(SStreamStateCur* pCur); - -int32_t streamStateGetKVByCur(SStreamStateCur* pCur, SWinKey* pKey, const void** pVal, int32_t* pVLen); - -int32_t streamStateSeekFirst(SStreamState* pState, SStreamStateCur* pCur); -int32_t streamStateSeekLast(SStreamState* pState, SStreamStateCur* pCur); - -int32_t streamStateCurNext(SStreamState* pState, SStreamStateCur* pCur); -int32_t streamStateCurPrev(SStreamState* pState, SStreamStateCur* pCur); - -#endif - #ifdef __cplusplus } #endif diff --git a/source/libs/function/CMakeLists.txt b/source/libs/function/CMakeLists.txt index ea401e56e5..dd048a047a 100644 --- a/source/libs/function/CMakeLists.txt +++ b/source/libs/function/CMakeLists.txt @@ -14,7 +14,7 @@ target_include_directories( target_link_libraries( function - PRIVATE os util common nodes scalar qcom transport + PRIVATE os util common nodes scalar qcom transport stream PUBLIC uv_a ) diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c index 0d7fd1a6da..411c898657 100644 --- a/source/libs/function/src/builtinsimpl.c +++ b/source/libs/function/src/builtinsimpl.c @@ -18,6 +18,7 @@ #include "function.h" #include "query.h" #include "querynodes.h" +#include "streamState.h" #include "tcompare.h" #include "tdatablock.h" #include "tdigest.h" @@ -56,8 +57,13 @@ typedef struct SAvgRes { } SAvgRes; typedef struct STuplePos { - int32_t pageId; - int32_t offset; + union { + struct { + int32_t pageId; + int32_t offset; + }; + STupleKey streamTupleKey; + }; } STuplePos; typedef struct SMinmaxResInfo { @@ -1146,7 +1152,8 @@ bool getMinmaxFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) { return true; } -static STuplePos saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock); +static STuplePos saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, + const STupleKey* pKey); static int32_t updateTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STuplePos* pPos); static const char* loadTupleData(SqlFunctionCtx* pCtx, const STuplePos* pPos); @@ -1201,7 +1208,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) { pBuf->v = *(int64_t*)tval; if (pCtx->subsidiaries.num > 0) { index = findRowIndex(pInput->startRowIndex, pInput->numOfRows, pCol, tval); - pBuf->tuplePos = saveTupleData(pCtx, index, pCtx->pSrcBlock); + pBuf->tuplePos = saveTupleData(pCtx, index, pCtx->pSrcBlock, NULL); } } else { if (IS_SIGNED_NUMERIC_TYPE(type) || IS_TIMESTAMP_TYPE(type)) { @@ -1213,7 +1220,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) { *(int64_t*)&pBuf->v = val; if (pCtx->subsidiaries.num > 0) { index = findRowIndex(pInput->startRowIndex, pInput->numOfRows, pCol, tval); - pBuf->tuplePos = saveTupleData(pCtx, index, pCtx->pSrcBlock); + pBuf->tuplePos = saveTupleData(pCtx, index, pCtx->pSrcBlock, NULL); } } } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) { @@ -1225,7 +1232,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) { *(uint64_t*)&pBuf->v = val; if (pCtx->subsidiaries.num > 0) { index = findRowIndex(pInput->startRowIndex, pInput->numOfRows, pCol, tval); - pBuf->tuplePos = saveTupleData(pCtx, index, pCtx->pSrcBlock); + pBuf->tuplePos = saveTupleData(pCtx, index, pCtx->pSrcBlock, NULL); } } } else if (type == TSDB_DATA_TYPE_DOUBLE) { @@ -1237,7 +1244,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) { *(double*)&pBuf->v = val; if (pCtx->subsidiaries.num > 0) { index = findRowIndex(pInput->startRowIndex, pInput->numOfRows, pCol, tval); - pBuf->tuplePos = saveTupleData(pCtx, index, pCtx->pSrcBlock); + pBuf->tuplePos = saveTupleData(pCtx, index, pCtx->pSrcBlock, NULL); } } } else if (type == TSDB_DATA_TYPE_FLOAT) { @@ -1251,7 +1258,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) { if (pCtx->subsidiaries.num > 0) { index = findRowIndex(pInput->startRowIndex, pInput->numOfRows, pCol, tval); - pBuf->tuplePos = saveTupleData(pCtx, index, pCtx->pSrcBlock); + pBuf->tuplePos = saveTupleData(pCtx, index, pCtx->pSrcBlock, NULL); } } } @@ -1276,7 +1283,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) { if (!pBuf->assign) { *val = pData[i]; if (pCtx->subsidiaries.num > 0) { - pBuf->tuplePos = saveTupleData(pCtx, i, pCtx->pSrcBlock); + pBuf->tuplePos = saveTupleData(pCtx, i, pCtx->pSrcBlock, NULL); } pBuf->assign = true; } else { @@ -1307,7 +1314,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) { if (!pBuf->assign) { *val = pData[i]; if (pCtx->subsidiaries.num > 0) { - pBuf->tuplePos = saveTupleData(pCtx, i, pCtx->pSrcBlock); + pBuf->tuplePos = saveTupleData(pCtx, i, pCtx->pSrcBlock, NULL); } pBuf->assign = true; } else { @@ -1338,7 +1345,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) { if (!pBuf->assign) { *val = pData[i]; if (pCtx->subsidiaries.num > 0) { - pBuf->tuplePos = saveTupleData(pCtx, i, pCtx->pSrcBlock); + pBuf->tuplePos = saveTupleData(pCtx, i, pCtx->pSrcBlock, NULL); } pBuf->assign = true; } else { @@ -1369,7 +1376,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) { if (!pBuf->assign) { *val = pData[i]; if (pCtx->subsidiaries.num > 0) { - pBuf->tuplePos = saveTupleData(pCtx, i, pCtx->pSrcBlock); + pBuf->tuplePos = saveTupleData(pCtx, i, pCtx->pSrcBlock, NULL); } pBuf->assign = true; } else { @@ -1402,7 +1409,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) { if (!pBuf->assign) { *val = pData[i]; if (pCtx->subsidiaries.num > 0) { - pBuf->tuplePos = saveTupleData(pCtx, i, pCtx->pSrcBlock); + pBuf->tuplePos = saveTupleData(pCtx, i, pCtx->pSrcBlock, NULL); } pBuf->assign = true; } else { @@ -1433,7 +1440,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) { if (!pBuf->assign) { *val = pData[i]; if (pCtx->subsidiaries.num > 0) { - pBuf->tuplePos = saveTupleData(pCtx, i, pCtx->pSrcBlock); + pBuf->tuplePos = saveTupleData(pCtx, i, pCtx->pSrcBlock, NULL); } pBuf->assign = true; } else { @@ -1464,7 +1471,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) { if (!pBuf->assign) { *val = pData[i]; if (pCtx->subsidiaries.num > 0) { - pBuf->tuplePos = saveTupleData(pCtx, i, pCtx->pSrcBlock); + pBuf->tuplePos = saveTupleData(pCtx, i, pCtx->pSrcBlock, NULL); } pBuf->assign = true; } else { @@ -1495,7 +1502,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) { if (!pBuf->assign) { *val = pData[i]; if (pCtx->subsidiaries.num > 0) { - pBuf->tuplePos = saveTupleData(pCtx, i, pCtx->pSrcBlock); + pBuf->tuplePos = saveTupleData(pCtx, i, pCtx->pSrcBlock, NULL); } pBuf->assign = true; } else { @@ -1527,7 +1534,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) { if (!pBuf->assign) { *val = pData[i]; if (pCtx->subsidiaries.num > 0) { - pBuf->tuplePos = saveTupleData(pCtx, i, pCtx->pSrcBlock); + pBuf->tuplePos = saveTupleData(pCtx, i, pCtx->pSrcBlock, NULL); } pBuf->assign = true; } else { @@ -1558,7 +1565,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) { if (!pBuf->assign) { *val = pData[i]; if (pCtx->subsidiaries.num > 0) { - pBuf->tuplePos = saveTupleData(pCtx, i, pCtx->pSrcBlock); + pBuf->tuplePos = saveTupleData(pCtx, i, pCtx->pSrcBlock, NULL); } pBuf->assign = true; } else { @@ -1581,7 +1588,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) { _min_max_over: if (numOfElems == 0 && pCtx->subsidiaries.num > 0 && !pBuf->nullTupleSaved) { - pBuf->nullTuplePos = saveTupleData(pCtx, pInput->startRowIndex, pCtx->pSrcBlock); + pBuf->nullTuplePos = saveTupleData(pCtx, pInput->startRowIndex, pCtx->pSrcBlock, NULL); pBuf->nullTupleSaved = true; } return numOfElems; @@ -2758,7 +2765,7 @@ static void firstlastSaveTupleData(const SSDataBlock* pSrcBlock, int32_t rowInde } if (!pInfo->hasResult) { - pInfo->pos = saveTupleData(pCtx, rowIndex, pSrcBlock); + pInfo->pos = saveTupleData(pCtx, rowIndex, pSrcBlock, NULL); } else { updateTupleData(pCtx, rowIndex, pSrcBlock, &pInfo->pos); } @@ -3426,7 +3433,7 @@ int32_t topFunction(SqlFunctionCtx* pCtx) { } if (numOfElems == 0 && pCtx->subsidiaries.num > 0 && !pRes->nullTupleSaved) { - pRes->nullTuplePos = saveTupleData(pCtx, pInput->startRowIndex, pCtx->pSrcBlock); + pRes->nullTuplePos = saveTupleData(pCtx, pInput->startRowIndex, pCtx->pSrcBlock, NULL); pRes->nullTupleSaved = true; } return TSDB_CODE_SUCCESS; @@ -3454,7 +3461,7 @@ int32_t bottomFunction(SqlFunctionCtx* pCtx) { } if (numOfElems == 0 && pCtx->subsidiaries.num > 0 && !pRes->nullTupleSaved) { - pRes->nullTuplePos = saveTupleData(pCtx, pInput->startRowIndex, pCtx->pSrcBlock); + pRes->nullTuplePos = saveTupleData(pCtx, pInput->startRowIndex, pCtx->pSrcBlock, NULL); pRes->nullTupleSaved = true; } @@ -3506,7 +3513,7 @@ void doAddIntoResult(SqlFunctionCtx* pCtx, void* pData, int32_t rowIndex, SSData // save the data of this tuple if (pCtx->subsidiaries.num > 0) { - pItem->tuplePos = saveTupleData(pCtx, rowIndex, pSrcBlock); + pItem->tuplePos = saveTupleData(pCtx, rowIndex, pSrcBlock, NULL); } #ifdef BUF_PAGE_DEBUG qDebug("page_saveTuple i:%d, item:%p,pageId:%d, offset:%d\n", pEntryInfo->numOfRes, pItem, pItem->tuplePos.pageId, @@ -3578,7 +3585,8 @@ void* serializeTupleData(const SSDataBlock* pSrcBlock, int32_t rowIndex, SSubsid return buf; } -static STuplePos doSaveTupleData(SSerializeDataHandle* pHandle, const void* pBuf, size_t length) { +static STuplePos doSaveTupleData(SSerializeDataHandle* pHandle, const void* pBuf, size_t length, + const STupleKey* pKey) { STuplePos p = {0}; if (pHandle->pBuf != NULL) { SFilePage* pPage = NULL; @@ -3604,12 +3612,16 @@ static STuplePos doSaveTupleData(SSerializeDataHandle* pHandle, const void* pBuf releaseBufPage(pHandle->pBuf, pPage); } else { // other tuple save policy + if (streamStateFuncPut(pHandle->pState, pKey, pBuf, length) < 0) { + ASSERT(0); + } + p.streamTupleKey = *pKey; } return p; } -STuplePos saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock) { +STuplePos saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, const STupleKey* pKey) { if (pCtx->subsidiaries.rowLen == 0) { int32_t rowLen = 0; for (int32_t j = 0; j < pCtx->subsidiaries.num; ++j) { @@ -3622,7 +3634,7 @@ STuplePos saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBloc } char* buf = serializeTupleData(pSrcBlock, rowIndex, &pCtx->subsidiaries, pCtx->subsidiaries.buf); - return doSaveTupleData(&pCtx->saveHandle, buf, pCtx->subsidiaries.rowLen); + return doSaveTupleData(&pCtx->saveHandle, buf, pCtx->subsidiaries.rowLen, pKey); } static int32_t doUpdateTupleData(SSerializeDataHandle* pHandle, const void* pBuf, size_t length, STuplePos* pPos) { @@ -3632,6 +3644,7 @@ static int32_t doUpdateTupleData(SSerializeDataHandle* pHandle, const void* pBuf setBufPageDirty(pPage, true); releaseBufPage(pHandle->pBuf, pPage); } else { + streamStateFuncPut(pHandle->pState, &pPos->streamTupleKey, pBuf, length); } return TSDB_CODE_SUCCESS; @@ -3650,7 +3663,10 @@ static char* doLoadTupleData(SSerializeDataHandle* pHandle, const STuplePos* pPo releaseBufPage(pHandle->pBuf, pPage); return p; } else { - return NULL; + void* value = NULL; + int32_t vLen; + streamStateFuncGet(pHandle->pState, &pPos->streamTupleKey, &value, &vLen); + return (char*)value; } } @@ -4981,7 +4997,7 @@ static void doReservoirSample(SqlFunctionCtx* pCtx, SSampleInfo* pInfo, char* da if (pInfo->numSampled < pInfo->samples) { sampleAssignResult(pInfo, data, pInfo->numSampled); if (pCtx->subsidiaries.num > 0) { - pInfo->tuplePos[pInfo->numSampled] = saveTupleData(pCtx, index, pCtx->pSrcBlock); + pInfo->tuplePos[pInfo->numSampled] = saveTupleData(pCtx, index, pCtx->pSrcBlock, NULL); } pInfo->numSampled++; } else { @@ -5012,7 +5028,7 @@ int32_t sampleFunction(SqlFunctionCtx* pCtx) { } if (pInfo->numSampled == 0 && pCtx->subsidiaries.num > 0 && !pInfo->nullTupleSaved) { - pInfo->nullTuplePos = saveTupleData(pCtx, pInput->startRowIndex, pCtx->pSrcBlock); + pInfo->nullTuplePos = saveTupleData(pCtx, pInput->startRowIndex, pCtx->pSrcBlock, NULL); pInfo->nullTupleSaved = true; } diff --git a/source/libs/stream/src/streamState.c b/source/libs/stream/src/streamState.c index 5efdbb4679..6cd5132bb9 100644 --- a/source/libs/stream/src/streamState.c +++ b/source/libs/stream/src/streamState.c @@ -35,6 +35,10 @@ SStreamState* streamStateOpen(char* path, SStreamTask* pTask) { goto _err; } + if (tdbTbOpen("func.state.db", sizeof(STupleKey), -1, STupleKeyCmpr, pState->db, &pState->pFuncStateDb) < 0) { + goto _err; + } + if (streamStateBegin(pState) < 0) { goto _err; } @@ -44,8 +48,9 @@ SStreamState* streamStateOpen(char* path, SStreamTask* pTask) { return pState; _err: - if (pState->pStateDb) tdbTbClose(pState->pStateDb); - if (pState->db) tdbClose(pState->db); + tdbTbClose(pState->pStateDb); + tdbTbClose(pState->pFuncStateDb); + tdbClose(pState->db); taosMemoryFree(pState); return NULL; } @@ -53,6 +58,7 @@ _err: void streamStateClose(SStreamState* pState) { tdbCommit(pState->db, &pState->txn); tdbTbClose(pState->pStateDb); + tdbTbClose(pState->pFuncStateDb); tdbClose(pState->db); taosMemoryFree(pState); @@ -101,6 +107,17 @@ int32_t streamStateAbort(SStreamState* pState) { return 0; } +int32_t streamStateFuncPut(SStreamState* pState, const STupleKey* key, const void* value, int32_t vLen) { + return tdbTbUpsert(pState->pFuncStateDb, key, sizeof(STupleKey), value, vLen, &pState->txn); +} +int32_t streamStateFuncGet(SStreamState* pState, const STupleKey* key, void** pVal, int32_t* pVLen) { + return tdbTbGet(pState->pFuncStateDb, key, sizeof(STupleKey), pVal, pVLen); +} + +int32_t streamStateFuncDel(SStreamState* pState, const STupleKey* key) { + return tdbTbDelete(pState->pFuncStateDb, key, sizeof(STupleKey), &pState->txn); +} + int32_t streamStatePut(SStreamState* pState, const SWinKey* key, const void* value, int32_t vLen) { return tdbTbUpsert(pState->pStateDb, key, sizeof(SWinKey), value, vLen, &pState->txn); } From c7f986a656c4ba73e09bec2b338a9c0557a177bc Mon Sep 17 00:00:00 2001 From: Liu Jicong Date: Wed, 14 Sep 2022 17:11:50 +0800 Subject: [PATCH 081/138] refactor(tmq): add error code --- include/util/taoserror.h | 1 + source/dnode/mnode/impl/src/mndSubscribe.c | 1 + source/dnode/mnode/impl/src/mndTopic.c | 1 - source/util/src/terror.c | 1 + 4 files changed, 3 insertions(+), 1 deletion(-) diff --git a/include/util/taoserror.h b/include/util/taoserror.h index d16a599811..d3e1416b85 100644 --- a/include/util/taoserror.h +++ b/include/util/taoserror.h @@ -285,6 +285,7 @@ int32_t* taosGetErrno(); #define TSDB_CODE_MND_TOPIC_SUBSCRIBED TAOS_DEF_ERROR_CODE(0, 0x03EB) #define TSDB_CODE_MND_CGROUP_USED TAOS_DEF_ERROR_CODE(0, 0x03EC) #define TSDB_CODE_MND_TOPIC_MUST_BE_DELETED TAOS_DEF_ERROR_CODE(0, 0x03ED) +#define TSDB_CODE_MND_IN_REBALANCE TAOS_DEF_ERROR_CODE(0, 0x03EF) // mnode-stream #define TSDB_CODE_MND_STREAM_ALREADY_EXIST TAOS_DEF_ERROR_CODE(0, 0x03F0) diff --git a/source/dnode/mnode/impl/src/mndSubscribe.c b/source/dnode/mnode/impl/src/mndSubscribe.c index 1452c5ae2f..8a968712e0 100644 --- a/source/dnode/mnode/impl/src/mndSubscribe.c +++ b/source/dnode/mnode/impl/src/mndSubscribe.c @@ -900,6 +900,7 @@ int32_t mndDropSubByTopic(SMnode *pMnode, STrans *pTrans, const char *topicName) // iter all vnode to delete handle if (taosHashGetSize(pSub->consumerHash) != 0) { sdbRelease(pSdb, pSub); + terrno = TSDB_CODE_MND_IN_REBALANCE; return -1; } int32_t sz = taosArrayGetSize(pSub->unassignedVgs); diff --git a/source/dnode/mnode/impl/src/mndTopic.c b/source/dnode/mnode/impl/src/mndTopic.c index eb072d013d..7b36966d6c 100644 --- a/source/dnode/mnode/impl/src/mndTopic.c +++ b/source/dnode/mnode/impl/src/mndTopic.c @@ -713,7 +713,6 @@ static int32_t mndProcessDropTopicReq(SRpcMsg *pReq) { mndReleaseTopic(pMnode, pTopic); if (code != 0) { - terrno = code; mError("topic:%s, failed to drop since %s", dropReq.name, terrstr()); return -1; } diff --git a/source/util/src/terror.c b/source/util/src/terror.c index 044cdc86b4..dbe8be6a81 100644 --- a/source/util/src/terror.c +++ b/source/util/src/terror.c @@ -288,6 +288,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_CONSUMER_NOT_READY, "Consumer not ready") TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOPIC_SUBSCRIBED, "Topic subscribed cannot be dropped") TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOPIC_MUST_BE_DELETED, "Topic must be dropped first") TAOS_DEFINE_ERROR(TSDB_CODE_MND_CGROUP_USED, "Consumer group being used by some consumer") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_IN_REBALANCE, "Topic being rebalanced") // mnode-stream TAOS_DEFINE_ERROR(TSDB_CODE_MND_STREAM_ALREADY_EXIST, "Stream already exists") From e2586979eb501887432930d53a20d24614bf5410 Mon Sep 17 00:00:00 2001 From: Xiaoyu Wang Date: Wed, 14 Sep 2022 17:51:21 +0800 Subject: [PATCH 082/138] enh: the delete physical plan increases the timestamp interval of the actual deleted data --- include/libs/nodes/plannodes.h | 4 ++++ include/libs/nodes/querynodes.h | 2 ++ source/libs/nodes/src/nodesCloneFuncs.c | 2 ++ source/libs/nodes/src/nodesCodeFuncs.c | 14 ++++++++++++++ source/libs/nodes/src/nodesMsgFuncs.c | 16 +++++++++++++++- source/libs/nodes/src/nodesUtilFuncs.c | 6 ++++++ source/libs/parser/src/parAstCreater.c | 10 ++++++---- source/libs/parser/src/parTranslater.c | 8 +++++++- source/libs/planner/src/planLogicCreater.c | 16 +++++++++++++++- source/libs/planner/src/planPhysiCreater.c | 12 +++++++++--- 10 files changed, 80 insertions(+), 10 deletions(-) diff --git a/include/libs/nodes/plannodes.h b/include/libs/nodes/plannodes.h index 8aeb86102a..1e86a04775 100644 --- a/include/libs/nodes/plannodes.h +++ b/include/libs/nodes/plannodes.h @@ -151,6 +151,8 @@ typedef struct SVnodeModifyLogicNode { SArray* pDataBlocks; SVgDataBlocks* pVgDataBlocks; SNode* pAffectedRows; // SColumnNode + SNode* pStartTs; // SColumnNode + SNode* pEndTs; // SColumnNode uint64_t tableId; uint64_t stableId; int8_t tableType; // table type @@ -525,6 +527,8 @@ typedef struct SDataDeleterNode { char tsColName[TSDB_COL_NAME_LEN]; STimeWindow deleteTimeRange; SNode* pAffectedRows; + SNode* pStartTs; + SNode* pEndTs; } SDataDeleterNode; typedef struct SSubplan { diff --git a/include/libs/nodes/querynodes.h b/include/libs/nodes/querynodes.h index 3a1eaf289e..e90c994e8f 100644 --- a/include/libs/nodes/querynodes.h +++ b/include/libs/nodes/querynodes.h @@ -315,6 +315,8 @@ typedef struct SDeleteStmt { SNode* pFromTable; // FROM clause SNode* pWhere; // WHERE clause SNode* pCountFunc; // count the number of rows affected + SNode* pFirstFunc; // the start timestamp when the data was actually deleted + SNode* pLastFunc; // the end timestamp when the data was actually deleted SNode* pTagCond; // pWhere divided into pTagCond and timeRange STimeWindow timeRange; uint8_t precision; diff --git a/source/libs/nodes/src/nodesCloneFuncs.c b/source/libs/nodes/src/nodesCloneFuncs.c index eb0b604d37..48e21e137f 100644 --- a/source/libs/nodes/src/nodesCloneFuncs.c +++ b/source/libs/nodes/src/nodesCloneFuncs.c @@ -399,6 +399,8 @@ static int32_t logicVnodeModifCopy(const SVnodeModifyLogicNode* pSrc, SVnodeModi COPY_SCALAR_FIELD(modifyType); COPY_SCALAR_FIELD(msgType); CLONE_NODE_FIELD(pAffectedRows); + CLONE_NODE_FIELD(pStartTs); + CLONE_NODE_FIELD(pEndTs); COPY_SCALAR_FIELD(tableId); COPY_SCALAR_FIELD(stableId); COPY_SCALAR_FIELD(tableType); diff --git a/source/libs/nodes/src/nodesCodeFuncs.c b/source/libs/nodes/src/nodesCodeFuncs.c index a41462e3fd..afd05eff1d 100644 --- a/source/libs/nodes/src/nodesCodeFuncs.c +++ b/source/libs/nodes/src/nodesCodeFuncs.c @@ -2431,6 +2431,8 @@ static const char* jkDeletePhysiPlanTsColName = "TsColName"; static const char* jkDeletePhysiPlanDeleteTimeRangeStartKey = "DeleteTimeRangeStartKey"; static const char* jkDeletePhysiPlanDeleteTimeRangeEndKey = "DeleteTimeRangeEndKey"; static const char* jkDeletePhysiPlanAffectedRows = "AffectedRows"; +static const char* jkDeletePhysiPlanStartTs = "StartTs"; +static const char* jkDeletePhysiPlanEndTs = "EndTs"; static int32_t physiDeleteNodeToJson(const void* pObj, SJson* pJson) { const SDataDeleterNode* pNode = (const SDataDeleterNode*)pObj; @@ -2457,6 +2459,12 @@ static int32_t physiDeleteNodeToJson(const void* pObj, SJson* pJson) { if (TSDB_CODE_SUCCESS == code) { code = tjsonAddObject(pJson, jkDeletePhysiPlanAffectedRows, nodeToJson, pNode->pAffectedRows); } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddObject(pJson, jkDeletePhysiPlanStartTs, nodeToJson, pNode->pStartTs); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddObject(pJson, jkDeletePhysiPlanEndTs, nodeToJson, pNode->pEndTs); + } return code; } @@ -2486,6 +2494,12 @@ static int32_t jsonToPhysiDeleteNode(const SJson* pJson, void* pObj) { if (TSDB_CODE_SUCCESS == code) { code = jsonToNodeObject(pJson, jkDeletePhysiPlanAffectedRows, &pNode->pAffectedRows); } + if (TSDB_CODE_SUCCESS == code) { + code = jsonToNodeObject(pJson, jkDeletePhysiPlanStartTs, &pNode->pStartTs); + } + if (TSDB_CODE_SUCCESS == code) { + code = jsonToNodeObject(pJson, jkDeletePhysiPlanEndTs, &pNode->pEndTs); + } return code; } diff --git a/source/libs/nodes/src/nodesMsgFuncs.c b/source/libs/nodes/src/nodesMsgFuncs.c index efe820fee2..202ee6717a 100644 --- a/source/libs/nodes/src/nodesMsgFuncs.c +++ b/source/libs/nodes/src/nodesMsgFuncs.c @@ -2665,7 +2665,9 @@ enum { PHY_DELETER_CODE_TABLE_FNAME, PHY_DELETER_CODE_TS_COL_NAME, PHY_DELETER_CODE_DELETE_TIME_RANGE, - PHY_DELETER_CODE_AFFECTED_ROWS + PHY_DELETER_CODE_AFFECTED_ROWS, + PHY_DELETER_CODE_START_TS, + PHY_DELETER_CODE_END_TS }; static int32_t physiDeleteNodeToMsg(const void* pObj, STlvEncoder* pEncoder) { @@ -2690,6 +2692,12 @@ static int32_t physiDeleteNodeToMsg(const void* pObj, STlvEncoder* pEncoder) { if (TSDB_CODE_SUCCESS == code) { code = tlvEncodeObj(pEncoder, PHY_DELETER_CODE_AFFECTED_ROWS, nodeToMsg, pNode->pAffectedRows); } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeObj(pEncoder, PHY_DELETER_CODE_START_TS, nodeToMsg, pNode->pStartTs); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeObj(pEncoder, PHY_DELETER_CODE_END_TS, nodeToMsg, pNode->pEndTs); + } return code; } @@ -2722,6 +2730,12 @@ static int32_t msgToPhysiDeleteNode(STlvDecoder* pDecoder, void* pObj) { case PHY_DELETER_CODE_AFFECTED_ROWS: code = msgToNodeFromTlv(pTlv, (void**)&pNode->pAffectedRows); break; + case PHY_DELETER_CODE_START_TS: + code = msgToNodeFromTlv(pTlv, (void**)&pNode->pStartTs); + break; + case PHY_DELETER_CODE_END_TS: + code = msgToNodeFromTlv(pTlv, (void**)&pNode->pEndTs); + break; default: break; } diff --git a/source/libs/nodes/src/nodesUtilFuncs.c b/source/libs/nodes/src/nodesUtilFuncs.c index 61b2ad954f..805ddb9e42 100644 --- a/source/libs/nodes/src/nodesUtilFuncs.c +++ b/source/libs/nodes/src/nodesUtilFuncs.c @@ -727,6 +727,8 @@ void nodesDestroyNode(SNode* pNode) { nodesDestroyNode(pStmt->pFromTable); nodesDestroyNode(pStmt->pWhere); nodesDestroyNode(pStmt->pCountFunc); + nodesDestroyNode(pStmt->pFirstFunc); + nodesDestroyNode(pStmt->pLastFunc); nodesDestroyNode(pStmt->pTagCond); break; } @@ -791,6 +793,8 @@ void nodesDestroyNode(SNode* pNode) { destroyVgDataBlockArray(pLogicNode->pDataBlocks); // pVgDataBlocks is weak reference nodesDestroyNode(pLogicNode->pAffectedRows); + nodesDestroyNode(pLogicNode->pStartTs); + nodesDestroyNode(pLogicNode->pEndTs); taosMemoryFreeClear(pLogicNode->pVgroupList); nodesDestroyList(pLogicNode->pInsertCols); break; @@ -997,6 +1001,8 @@ void nodesDestroyNode(SNode* pNode) { SDataDeleterNode* pSink = (SDataDeleterNode*)pNode; destroyDataSinkNode((SDataSinkNode*)pSink); nodesDestroyNode(pSink->pAffectedRows); + nodesDestroyNode(pSink->pStartTs); + nodesDestroyNode(pSink->pEndTs); break; } case QUERY_NODE_PHYSICAL_SUBPLAN: { diff --git a/source/libs/parser/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c index 511ae25810..6f11c653a4 100644 --- a/source/libs/parser/src/parAstCreater.c +++ b/source/libs/parser/src/parAstCreater.c @@ -1787,10 +1787,10 @@ SNode* createRevokeStmt(SAstCreateContext* pCxt, int64_t privileges, SToken* pDb return (SNode*)pStmt; } -SNode* createCountFuncForDelete(SAstCreateContext* pCxt) { +SNode* createFuncForDelete(SAstCreateContext* pCxt, const char* pFuncName) { SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); CHECK_OUT_OF_MEM(pFunc); - strcpy(pFunc->functionName, "count"); + strcpy(pFunc->functionName, pFuncName); if (TSDB_CODE_SUCCESS != nodesListMakeStrictAppend(&pFunc->pParameterList, createPrimaryKeyCol(pCxt, NULL))) { nodesDestroyNode((SNode*)pFunc); CHECK_OUT_OF_MEM(NULL); @@ -1804,8 +1804,10 @@ SNode* createDeleteStmt(SAstCreateContext* pCxt, SNode* pTable, SNode* pWhere) { CHECK_OUT_OF_MEM(pStmt); pStmt->pFromTable = pTable; pStmt->pWhere = pWhere; - pStmt->pCountFunc = createCountFuncForDelete(pCxt); - if (NULL == pStmt->pCountFunc) { + pStmt->pCountFunc = createFuncForDelete(pCxt, "count"); + pStmt->pFirstFunc = createFuncForDelete(pCxt, "first"); + pStmt->pLastFunc = createFuncForDelete(pCxt, "last"); + if (NULL == pStmt->pCountFunc || NULL == pStmt->pFirstFunc || NULL == pStmt->pLastFunc) { nodesDestroyNode((SNode*)pStmt); CHECK_OUT_OF_MEM(NULL); } diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index f1a59ebf51..888d3b6848 100644 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -3347,10 +3347,16 @@ static int32_t translateDelete(STranslateContext* pCxt, SDeleteStmt* pDelete) { if (TSDB_CODE_SUCCESS == code) { code = translateDeleteWhere(pCxt, pDelete); } + pCxt->currClause = SQL_CLAUSE_SELECT; if (TSDB_CODE_SUCCESS == code) { - pCxt->currClause = SQL_CLAUSE_SELECT; code = translateExpr(pCxt, &pDelete->pCountFunc); } + if (TSDB_CODE_SUCCESS == code) { + code = translateExpr(pCxt, &pDelete->pFirstFunc); + } + if (TSDB_CODE_SUCCESS == code) { + code = translateExpr(pCxt, &pDelete->pLastFunc); + } return code; } diff --git a/source/libs/planner/src/planLogicCreater.c b/source/libs/planner/src/planLogicCreater.c index bf72f52105..fea2be55f9 100644 --- a/source/libs/planner/src/planLogicCreater.c +++ b/source/libs/planner/src/planLogicCreater.c @@ -1372,9 +1372,21 @@ static int32_t createDeleteAggLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* pD } int32_t code = nodesListMakeStrictAppend(&pAgg->pAggFuncs, nodesCloneNode(pDelete->pCountFunc)); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(pAgg->pAggFuncs, nodesCloneNode(pDelete->pFirstFunc)); + } + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(pAgg->pAggFuncs, nodesCloneNode(pDelete->pLastFunc)); + } if (TSDB_CODE_SUCCESS == code) { code = rewriteExpr(pAgg->pAggFuncs, &pDelete->pCountFunc); } + if (TSDB_CODE_SUCCESS == code) { + code = rewriteExpr(pAgg->pAggFuncs, &pDelete->pFirstFunc); + } + if (TSDB_CODE_SUCCESS == code) { + code = rewriteExpr(pAgg->pAggFuncs, &pDelete->pLastFunc); + } // set the output if (TSDB_CODE_SUCCESS == code) { code = createColumnByRewriteExprs(pAgg->pAggFuncs, &pAgg->node.pTargets); @@ -1405,7 +1417,9 @@ static int32_t createVnodeModifLogicNodeByDelete(SLogicPlanContext* pCxt, SDelet strcpy(pModify->tsColName, pRealTable->pMeta->schema->name); pModify->deleteTimeRange = pDelete->timeRange; pModify->pAffectedRows = nodesCloneNode(pDelete->pCountFunc); - if (NULL == pModify->pAffectedRows) { + pModify->pStartTs = nodesCloneNode(pDelete->pFirstFunc); + pModify->pEndTs = nodesCloneNode(pDelete->pLastFunc); + if (NULL == pModify->pAffectedRows || NULL == pModify->pStartTs || NULL == pModify->pEndTs) { nodesDestroyNode((SNode*)pModify); return TSDB_CODE_OUT_OF_MEMORY; } diff --git a/source/libs/planner/src/planPhysiCreater.c b/source/libs/planner/src/planPhysiCreater.c index 0cbb833a4d..b0177e61ed 100644 --- a/source/libs/planner/src/planPhysiCreater.c +++ b/source/libs/planner/src/planPhysiCreater.c @@ -1323,9 +1323,9 @@ static int32_t createSortPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildren static int32_t createPartitionPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildren, SPartitionLogicNode* pPartLogicNode, SPhysiNode** pPhyNode) { - SPartitionPhysiNode* pPart = - (SPartitionPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pPartLogicNode, - pCxt->pPlanCxt->streamQuery ? QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION : QUERY_NODE_PHYSICAL_PLAN_PARTITION); + SPartitionPhysiNode* pPart = (SPartitionPhysiNode*)makePhysiNode( + pCxt, (SLogicNode*)pPartLogicNode, + pCxt->pPlanCxt->streamQuery ? QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION : QUERY_NODE_PHYSICAL_PLAN_PARTITION); if (NULL == pPart) { return TSDB_CODE_OUT_OF_MEMORY; } @@ -1670,6 +1670,12 @@ static int32_t createDataDeleter(SPhysiPlanContext* pCxt, SVnodeModifyLogicNode* int32_t code = setNodeSlotId(pCxt, pRoot->pOutputDataBlockDesc->dataBlockId, -1, pModify->pAffectedRows, &pDeleter->pAffectedRows); + if (TSDB_CODE_SUCCESS == code) { + code = setNodeSlotId(pCxt, pRoot->pOutputDataBlockDesc->dataBlockId, -1, pModify->pStartTs, &pDeleter->pStartTs); + } + if (TSDB_CODE_SUCCESS == code) { + code = setNodeSlotId(pCxt, pRoot->pOutputDataBlockDesc->dataBlockId, -1, pModify->pEndTs, &pDeleter->pEndTs); + } if (TSDB_CODE_SUCCESS == code) { pDeleter->sink.pInputDataBlockDesc = (SDataBlockDescNode*)nodesCloneNode((SNode*)pRoot->pOutputDataBlockDesc); if (NULL == pDeleter->sink.pInputDataBlockDesc) { From 45acc3420bfc337d2af03bd5f6bcd6ec72f4a4b6 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Wed, 14 Sep 2022 18:05:57 +0800 Subject: [PATCH 083/138] more code --- include/common/tdataformat.h | 4 +- source/common/src/tdataformat.c | 104 +++++++++++++++++++++----------- 2 files changed, 70 insertions(+), 38 deletions(-) diff --git a/include/common/tdataformat.h b/include/common/tdataformat.h index c51eff6a48..159279329b 100644 --- a/include/common/tdataformat.h +++ b/include/common/tdataformat.h @@ -106,14 +106,12 @@ void debugPrintSTag(STag *pTag, const char *tag, int32_t ln); // TODO: remov int32_t parseJsontoTagData(const char *json, SArray *pTagVals, STag **ppTag, void *pMsgBuf); // SColData ================================ +void tColDataDestroy(void *ph); void tColDataInit(SColData *pColData, int16_t cid, int8_t type, int8_t smaOn); void tColDataClear(SColData *pColData); -void tColDataDestroy(void *ph); int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal); void tColDataGetValue(SColData *pColData, int32_t iRow, SColVal *pColVal); int32_t tColDataCopy(SColData *pColDataSrc, SColData *pColDataDest); -int32_t tPutColData(uint8_t *p, SColData *pColData); -int32_t tGetColData(uint8_t *p, SColData *pColData); // STRUCT ================================ struct STColumn { diff --git a/source/common/src/tdataformat.c b/source/common/src/tdataformat.c index ed2d68961f..dd2667b302 100644 --- a/source/common/src/tdataformat.c +++ b/source/common/src/tdataformat.c @@ -1203,8 +1203,7 @@ static FORCE_INLINE int32_t tColDataPutValue(SColData *pColData, SColVal *pColVa if (code) goto _exit; pColData->aOffset[pColData->nVal] = pColData->nData; - // value - if ((!pColVal->isNone) && (!pColVal->isNull)) { + if (pColVal->value.nData) { code = tRealloc(&pColData->pData, pColData->nData + pColVal->value.nData); if (code) goto _exit; memcpy(pColData->pData + pColData->nData, pColVal->value.pData, pColVal->value.nData); @@ -1240,18 +1239,33 @@ static FORCE_INLINE int32_t tColDataAppendValue1(SColData *pColData, SColVal *pC int32_t code = 0; if (!pColVal->isNone) { - code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1)); + int32_t nBit = BIT1_SIZE(pColData->nVal + 1); + + code = tRealloc(&pColData->pBitMap, nBit); if (code) goto _exit; - for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) { - SET_BIT1(pColData->pBitMap, iVal, 0); - } + memset(pColData->pBitMap, 0, nBit); SET_BIT1(pColData->pBitMap, pColData->nVal, 1); if (pColVal->isNull) { pColData->flag |= HAS_NULL; } else { pColData->flag |= HAS_VALUE; + + if (pColData->nVal) { + if (IS_VAR_DATA_TYPE(pColData->type)) { + int32_t nOffset = sizeof(int32_t) * pColData->nVal; + code = tRealloc((uint8_t **)(&pColData->aOffset), nOffset); + if (code) goto _exit; + memset(pColData->aOffset, 0, nOffset); + } else { + pColData->nData = tDataTypes[pColData->type].bytes * pColData->nVal; + code = tRealloc(&pColData->pData, pColData->nData); + if (code) goto _exit; + memset(pColData->pData, 0, pColData->nData); + } + } + code = tColDataPutValue(pColData, pColVal); if (code) goto _exit; } @@ -1265,24 +1279,35 @@ static FORCE_INLINE int32_t tColDataAppendValue2(SColData *pColData, SColVal *pC int32_t code = 0; if (!pColVal->isNull) { - code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1)); + int32_t nBit = BIT1_SIZE(pColData->nVal + 1); + code = tRealloc(&pColData->pBitMap, nBit); if (code) goto _exit; if (pColVal->isNone) { pColData->flag |= HAS_NONE; - for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) { - SET_BIT1(pColData->pBitMap, iVal, 1); - } + memset(pColData->pBitMap, 255, nBit); SET_BIT1(pColData->pBitMap, pColData->nVal, 0); } else { pColData->flag |= HAS_VALUE; - for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) { - SET_BIT1(pColData->pBitMap, iVal, 0); - } + memset(pColData->pBitMap, 0, nBit); SET_BIT1(pColData->pBitMap, pColData->nVal, 1); + if (pColData->nVal) { + if (IS_VAR_DATA_TYPE(pColData->type)) { + int32_t nOffset = sizeof(int32_t) * pColData->nVal; + code = tRealloc((uint8_t **)(&pColData->aOffset), nOffset); + if (code) goto _exit; + memset(pColData->aOffset, 0, nOffset); + } else { + pColData->nData = tDataTypes[pColData->type].bytes * pColData->nVal; + code = tRealloc(&pColData->pData, pColData->nData); + if (code) goto _exit; + memset(pColData->pData, 0, pColData->nData); + } + } + code = tColDataPutValue(pColData, pColVal); if (code) goto _exit; } @@ -1320,6 +1345,20 @@ static FORCE_INLINE int32_t tColDataAppendValue3(SColData *pColData, SColVal *pC tFree(pColData->pBitMap); pColData->pBitMap = pBitMap; + if (pColData->nVal) { + if (IS_VAR_DATA_TYPE(pColData->type)) { + int32_t nOffset = sizeof(int32_t) * pColData->nVal; + code = tRealloc((uint8_t **)(&pColData->aOffset), nOffset); + if (code) goto _exit; + memset(pColData->aOffset, 0, nOffset); + } else { + pColData->nData = tDataTypes[pColData->type].bytes * pColData->nVal; + code = tRealloc(&pColData->pData, pColData->nData); + if (code) goto _exit; + memset(pColData->pData, 0, pColData->nData); + } + } + code = tColDataPutValue(pColData, pColVal); if (code) goto _exit; } @@ -1341,6 +1380,9 @@ static FORCE_INLINE int32_t tColDataAppendValue4(SColData *pColData, SColVal *pC SET_BIT1(pColData->pBitMap, iVal, 1); } SET_BIT1(pColData->pBitMap, pColData->nVal, 0); + + code = tColDataPutValue(pColData, &COL_VAL_VALUE(pColData->cid, pColData->type, (SValue){0})); + if (code) goto _exit; } else if (pColVal->isNull) { pColData->flag |= HAS_NULL; @@ -1351,6 +1393,9 @@ static FORCE_INLINE int32_t tColDataAppendValue4(SColData *pColData, SColVal *pC SET_BIT1(pColData->pBitMap, iVal, 1); } SET_BIT1(pColData->pBitMap, pColData->nVal, 0); + + code = tColDataPutValue(pColData, &COL_VAL_VALUE(pColData->cid, pColData->type, (SValue){0})); + if (code) goto _exit; } else { code = tColDataPutValue(pColData, pColVal); if (code) goto _exit; @@ -1385,11 +1430,10 @@ static FORCE_INLINE int32_t tColDataAppendValue5(SColData *pColData, SColVal *pC SET_BIT1(pColData->pBitMap, pColData->nVal, 0); } else { SET_BIT1(pColData->pBitMap, pColData->nVal, 1); - - code = tColDataPutValue(pColData, pColVal); - if (code) goto _exit; } } + code = tColDataPutValue(pColData, pColVal); + if (code) goto _exit; pColData->nVal++; @@ -1421,11 +1465,11 @@ static FORCE_INLINE int32_t tColDataAppendValue6(SColData *pColData, SColVal *pC SET_BIT1(pColData->pBitMap, pColData->nVal, 0); } else { SET_BIT1(pColData->pBitMap, pColData->nVal, 1); - - code = tColDataPutValue(pColData, pColVal); - if (code) goto _exit; } } + code = tColDataPutValue(pColData, pColVal); + if (code) goto _exit; + pColData->nVal++; _exit: @@ -1444,10 +1488,10 @@ static FORCE_INLINE int32_t tColDataAppendValue7(SColData *pColData, SET_BIT2(pColData->pBitMap, pColData->nVal, 1); } else { SET_BIT2(pColData->pBitMap, pColData->nVal, 2); - - code = tColDataPutValue(pColData, pColVal); - if (code) goto _exit; } + code = tColDataPutValue(pColData, pColVal); + if (code) goto _exit; + pColData->nVal++; _exit: @@ -1464,16 +1508,8 @@ static int32_t (*tColDataAppendValueImpl[])(SColData *pColData, SColVal *pColVal tColDataAppendValue7 // HAS_VALUE|HAS_NULL|HAS_NONE }; int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal) { - int32_t code = 0; - - ASSERT(pColData->cid == pColVal->cid); - ASSERT(pColData->type == pColVal->type); - - code = tColDataAppendValueImpl[pColData->flag](pColData, pColVal); - if (code) goto _exit; - -_exit: - return code; + ASSERT(pColData->cid == pColVal->cid && pColData->type == pColVal->type); + return tColDataAppendValueImpl[pColData->flag](pColData, pColVal); } static FORCE_INLINE void tColDataGetValue1(SColData *pColData, int32_t iVal, SColVal *pColVal) { // HAS_NONE @@ -1561,9 +1597,7 @@ static void (*tColDataGetValueImpl[])(SColData *pColData, int32_t iVal, SColVal tColDataGetValue7 // HAS_VALUE | HAS_NULL | HAS_NONE }; void tColDataGetValue(SColData *pColData, int32_t iVal, SColVal *pColVal) { - ASSERT(iVal >= 0 && iVal < pColData->nVal); - ASSERT(pColData->flag); - + ASSERT(iVal >= 0 && iVal < pColData->nVal && pColData->flag); tColDataGetValueImpl[pColData->flag](pColData, iVal, pColVal); } From c7efe171775eaf9bee631c22ce9e25ddf8573acf Mon Sep 17 00:00:00 2001 From: dapan1121 Date: Wed, 14 Sep 2022 18:08:29 +0800 Subject: [PATCH 084/138] fix: fix task retry and qnode fetch thread num issue --- source/common/src/tglobal.c | 14 ++++++---- source/libs/scheduler/inc/schInt.h | 3 ++- source/libs/scheduler/src/schRemote.c | 2 +- source/libs/scheduler/src/schTask.c | 37 +++++++++++++++++---------- 4 files changed, 35 insertions(+), 21 deletions(-) diff --git a/source/common/src/tglobal.c b/source/common/src/tglobal.c index c436e4ffd2..ddda8f8c9a 100644 --- a/source/common/src/tglobal.c +++ b/source/common/src/tglobal.c @@ -63,7 +63,7 @@ int32_t tsNumOfVnodeWriteThreads = 2; int32_t tsNumOfVnodeSyncThreads = 2; int32_t tsNumOfVnodeRsmaThreads = 2; int32_t tsNumOfQnodeQueryThreads = 4; -int32_t tsNumOfQnodeFetchThreads = 4; +int32_t tsNumOfQnodeFetchThreads = 1; int32_t tsNumOfSnodeSharedThreads = 2; int32_t tsNumOfSnodeUniqueThreads = 2; @@ -385,9 +385,9 @@ static int32_t taosAddServerCfg(SConfig *pCfg) { tsNumOfQnodeQueryThreads = TMAX(tsNumOfQnodeQueryThreads, 4); if (cfgAddInt32(pCfg, "numOfQnodeQueryThreads", tsNumOfQnodeQueryThreads, 1, 1024, 0) != 0) return -1; - tsNumOfQnodeFetchThreads = tsNumOfCores / 2; - tsNumOfQnodeFetchThreads = TMAX(tsNumOfQnodeFetchThreads, 4); - if (cfgAddInt32(pCfg, "numOfQnodeFetchThreads", tsNumOfQnodeFetchThreads, 1, 1024, 0) != 0) return -1; +// tsNumOfQnodeFetchThreads = tsNumOfCores / 2; +// tsNumOfQnodeFetchThreads = TMAX(tsNumOfQnodeFetchThreads, 4); +// if (cfgAddInt32(pCfg, "numOfQnodeFetchThreads", tsNumOfQnodeFetchThreads, 1, 1024, 0) != 0) return -1; tsNumOfSnodeSharedThreads = tsNumOfCores / 4; tsNumOfSnodeSharedThreads = TRANGE(tsNumOfSnodeSharedThreads, 2, 4); @@ -527,6 +527,7 @@ static int32_t taosUpdateServerCfg(SConfig *pCfg) { pItem->stype = stype; } +/* pItem = cfgGetItem(tsCfg, "numOfQnodeFetchThreads"); if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) { tsNumOfQnodeFetchThreads = numOfCores / 2; @@ -534,6 +535,7 @@ static int32_t taosUpdateServerCfg(SConfig *pCfg) { pItem->i32 = tsNumOfQnodeFetchThreads; pItem->stype = stype; } +*/ pItem = cfgGetItem(tsCfg, "numOfSnodeSharedThreads"); if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) { @@ -691,7 +693,7 @@ static int32_t taosSetServerCfg(SConfig *pCfg) { tsNumOfVnodeSyncThreads = cfgGetItem(pCfg, "numOfVnodeSyncThreads")->i32; tsNumOfVnodeRsmaThreads = cfgGetItem(pCfg, "numOfVnodeRsmaThreads")->i32; tsNumOfQnodeQueryThreads = cfgGetItem(pCfg, "numOfQnodeQueryThreads")->i32; - tsNumOfQnodeFetchThreads = cfgGetItem(pCfg, "numOfQnodeFetchThreads")->i32; +// tsNumOfQnodeFetchThreads = cfgGetItem(pCfg, "numOfQnodeFetchThreads")->i32; tsNumOfSnodeSharedThreads = cfgGetItem(pCfg, "numOfSnodeSharedThreads")->i32; tsNumOfSnodeUniqueThreads = cfgGetItem(pCfg, "numOfSnodeUniqueThreads")->i32; tsRpcQueueMemoryAllowed = cfgGetItem(pCfg, "rpcQueueMemoryAllowed")->i64; @@ -939,8 +941,10 @@ int32_t taosSetCfg(SConfig *pCfg, char *name) { tsNumOfVnodeRsmaThreads = cfgGetItem(pCfg, "numOfVnodeRsmaThreads")->i32; } else if (strcasecmp("numOfQnodeQueryThreads", name) == 0) { tsNumOfQnodeQueryThreads = cfgGetItem(pCfg, "numOfQnodeQueryThreads")->i32; +/* } else if (strcasecmp("numOfQnodeFetchThreads", name) == 0) { tsNumOfQnodeFetchThreads = cfgGetItem(pCfg, "numOfQnodeFetchThreads")->i32; +*/ } else if (strcasecmp("numOfSnodeSharedThreads", name) == 0) { tsNumOfSnodeSharedThreads = cfgGetItem(pCfg, "numOfSnodeSharedThreads")->i32; } else if (strcasecmp("numOfSnodeUniqueThreads", name) == 0) { diff --git a/source/libs/scheduler/inc/schInt.h b/source/libs/scheduler/inc/schInt.h index 957fd46ba5..7fea286732 100644 --- a/source/libs/scheduler/inc/schInt.h +++ b/source/libs/scheduler/inc/schInt.h @@ -283,8 +283,9 @@ typedef struct SSchJob { } SSchJob; typedef struct SSchTaskCtx { - int64_t jobRid; + int64_t jobRid; SSchTask *pTask; + bool asyncLaunch; } SSchTaskCtx; extern SSchedulerMgmt schMgmt; diff --git a/source/libs/scheduler/src/schRemote.c b/source/libs/scheduler/src/schRemote.c index 5a64aaaebb..275fbb8016 100644 --- a/source/libs/scheduler/src/schRemote.c +++ b/source/libs/scheduler/src/schRemote.c @@ -396,7 +396,7 @@ int32_t schHandleCallback(void *param, SDataBuf *pMsg, int32_t rspCode) { tstrerror(rspCode)); SCH_ERR_JRET(schProcessOnCbBegin(&pJob, &pTask, pParam->queryId, pParam->refId, pParam->taskId)); - + code = schHandleResponseMsg(pJob, pTask, pParam->execId, pMsg, rspCode); pMsg->pData = NULL; diff --git a/source/libs/scheduler/src/schTask.c b/source/libs/scheduler/src/schTask.c index 9cab39c301..7ce426e18d 100644 --- a/source/libs/scheduler/src/schTask.c +++ b/source/libs/scheduler/src/schTask.c @@ -138,11 +138,6 @@ int32_t schUpdateTaskExecNode(SSchJob *pJob, SSchTask *pTask, void *handle, int3 return TSDB_CODE_SUCCESS; } - if ((execId != pTask->execId) || pTask->waitRetry) { // ignore it - SCH_TASK_DLOG("handle not updated since execId %d is already not current execId %d, waitRetry %d", execId, pTask->execId, pTask->waitRetry); - return TSDB_CODE_SUCCESS; - } - SSchNodeInfo *nodeInfo = taosHashGet(pTask->execNodes, &execId, sizeof(execId)); if (NULL == nodeInfo) { // ignore it SCH_TASK_DLOG("handle not updated since execId %d already not exist, current execId %d, waitRetry %d", execId, pTask->execId, pTask->waitRetry); @@ -160,11 +155,16 @@ int32_t schUpdateTaskHandle(SSchJob *pJob, SSchTask *pTask, bool dropExecNode, v if (dropExecNode) { SCH_RET(schDropTaskExecNode(pJob, pTask, handle, execId)); } - - SCH_SET_TASK_HANDLE(pTask, handle); - + schUpdateTaskExecNode(pJob, pTask, handle, execId); + if ((execId != pTask->execId) || pTask->waitRetry) { // ignore it + SCH_TASK_DLOG("handle not updated since execId %d is already not current execId %d, waitRetry %d", execId, pTask->execId, pTask->waitRetry); + SCH_ERR_RET(TSDB_CODE_SCH_IGNORE_ERROR); + } + + SCH_SET_TASK_HANDLE(pTask, handle); + return TSDB_CODE_SUCCESS; } @@ -349,7 +349,7 @@ int32_t schDoTaskRedirect(SSchJob *pJob, SSchTask *pTask, SDataBuf *pData, int32 pTask->waitRetry = true; schDropTaskOnExecNode(pJob, pTask); taosHashClear(pTask->execNodes); - SCH_ERR_JRET(schRemoveTaskFromExecList(pJob, pTask)); + schRemoveTaskFromExecList(pJob, pTask); schDeregisterTaskHb(pJob, pTask); atomic_sub_fetch_32(&pTask->level->taskLaunchedNum, 1); taosMemoryFreeClear(pTask->msg); @@ -593,7 +593,7 @@ int32_t schTaskCheckSetRetry(SSchJob *pJob, SSchTask *pTask, int32_t errCode, bo int32_t schHandleTaskRetry(SSchJob *pJob, SSchTask *pTask) { atomic_sub_fetch_32(&pTask->level->taskLaunchedNum, 1); - SCH_ERR_RET(schRemoveTaskFromExecList(pJob, pTask)); + schRemoveTaskFromExecList(pJob, pTask); SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_INIT); if (SCH_TASK_NEED_FLOW_CTRL(pJob, pTask)) { @@ -739,8 +739,7 @@ _return: int32_t schRemoveTaskFromExecList(SSchJob *pJob, SSchTask *pTask) { int32_t code = taosHashRemove(pJob->execTasks, &pTask->taskId, sizeof(pTask->taskId)); if (code) { - SCH_TASK_ELOG("task failed to rm from execTask list, code:%x", code); - SCH_ERR_RET(TSDB_CODE_SCH_INTERNAL_ERROR); + SCH_TASK_WLOG("task already not in execTask list, code:%x", code); } return TSDB_CODE_SUCCESS; @@ -829,6 +828,11 @@ int32_t schLaunchTaskImpl(void *param) { } SSchTask *pTask = pCtx->pTask; + + if (pCtx->asyncLaunch) { + SCH_LOCK_TASK(pTask); + } + int8_t status = 0; int32_t code = 0; @@ -875,8 +879,6 @@ int32_t schLaunchTaskImpl(void *param) { _return: - taosMemoryFree(param); - if (pJob->taskNum >= SCH_MIN_AYSNC_EXEC_NUM) { if (code) { code = schProcessOnTaskFailure(pJob, pTask, code); @@ -886,8 +888,14 @@ _return: } } + if (pCtx->asyncLaunch) { + SCH_UNLOCK_TASK(pTask); + } + schReleaseJob(pJob->refId); + taosMemoryFree(param); + SCH_RET(code); } @@ -902,6 +910,7 @@ int32_t schAsyncLaunchTaskImpl(SSchJob *pJob, SSchTask *pTask) { param->pTask = pTask; if (pJob->taskNum >= SCH_MIN_AYSNC_EXEC_NUM) { + param->asyncLaunch = true; taosAsyncExec(schLaunchTaskImpl, param, NULL); } else { SCH_ERR_RET(schLaunchTaskImpl(param)); From dc8fb900620fe55184f8bef49502dbf40a991cf1 Mon Sep 17 00:00:00 2001 From: Pan YANG Date: Wed, 14 Sep 2022 18:09:20 +0800 Subject: [PATCH 085/138] docs: update latest reserved SQL keywords --- docs/en/12-taos-sql/20-keywords.md | 144 ++++++++++++++++++++++------- docs/zh/12-taos-sql/20-keywords.md | 143 +++++++++++++++++++++------- 2 files changed, 217 insertions(+), 70 deletions(-) diff --git a/docs/en/12-taos-sql/20-keywords.md b/docs/en/12-taos-sql/20-keywords.md index d7b9c73c4f..f7eb067c96 100644 --- a/docs/en/12-taos-sql/20-keywords.md +++ b/docs/en/12-taos-sql/20-keywords.md @@ -5,7 +5,9 @@ title: Reserved Keywords ## Keyword List -There are about 200 keywords reserved by TDengine, they can't be used as the name of database, STable or table with either upper case, lower case or mixed case. The following list shows all reserved keywords: +There are more than 200 keywords reserved by TDengine, they can't be used as the name of database, table, STable, subtable, column or tag with either upper case, lower case or mixed case. If you need to use these keywords, use the symbol `` ` `` to enclose the keywords, e.g. \`ADD\`. + +The following list shows all reserved keywords: ### A @@ -14,15 +16,20 @@ There are about 200 keywords reserved by TDengine, they can't be used as the nam - ACCOUNTS - ADD - AFTER +- AGGREGATE - ALL - ALTER +- ANALYZE - AND +- APPS - AS - ASC +- AT_ONCE - ATTACH ### B +- BALANCE - BEFORE - BEGIN - BETWEEN @@ -32,19 +39,27 @@ There are about 200 keywords reserved by TDengine, they can't be used as the nam - BITNOT - BITOR - BLOCKS +- BNODE +- BNODES - BOOL +- BUFFER +- BUFSIZE - BY ### C - CACHE -- CACHELAST +- CACHEMODEL +- CACHESIZE - CASCADE +- CAST - CHANGE +- CLIENT_VERSION - CLUSTER - COLON - COLUMN - COMMA +- COMMENT - COMP - COMPACT - CONCAT @@ -52,15 +67,18 @@ There are about 200 keywords reserved by TDengine, they can't be used as the nam - CONNECTION - CONNECTIONS - CONNS +- CONSUMER +- CONSUMERS +- CONTAINS - COPY +- COUNT - CREATE -- CTIME +- CURRENT_USER ### D - DATABASE - DATABASES -- DAYS - DBS - DEFERRED - DELETE @@ -69,18 +87,23 @@ There are about 200 keywords reserved by TDengine, they can't be used as the nam - DESCRIBE - DETACH - DISTINCT +- DISTRIBUTED - DIVIDE - DNODE - DNODES - DOT - DOUBLE - DROP +- DURATION ### E +- EACH +- ENABLE - END -- EQ +- EVERY - EXISTS +- EXPIRED - EXPLAIN ### F @@ -88,18 +111,20 @@ There are about 200 keywords reserved by TDengine, they can't be used as the nam - FAIL - FILE - FILL +- FIRST - FLOAT +- FLUSH - FOR - FROM -- FSYNC +- FUNCTION +- FUNCTIONS ### G -- GE - GLOB +- GRANT - GRANTS - GROUP -- GT ### H @@ -110,15 +135,18 @@ There are about 200 keywords reserved by TDengine, they can't be used as the nam - ID - IF - IGNORE -- IMMEDIA +- IMMEDIATE - IMPORT - IN -- INITIAL +- INDEX +- INDEXES +- INITIALLY +- INNER - INSERT - INSTEAD - INT - INTEGER -- INTERVA +- INTERVAL - INTO - IS - ISNULL @@ -126,6 +154,7 @@ There are about 200 keywords reserved by TDengine, they can't be used as the nam ### J - JOIN +- JSON ### K @@ -135,46 +164,57 @@ There are about 200 keywords reserved by TDengine, they can't be used as the nam ### L -- LE +- LAST +- LAST_ROW +- LICENCES - LIKE - LIMIT - LINEAR - LOCAL -- LP -- LSHIFT -- LT ### M - MATCH +- MAX_DELAY - MAXROWS +- MERGE +- META - MINROWS - MINUS +- MNODE - MNODES - MODIFY - MODULES ### N -- NE +- NCHAR +- NEXT +- NMATCH - NONE - NOT - NOTNULL - NOW - NULL +- NULLS ### O - OF - OFFSET +- ON - OR - ORDER +- OUTPUTTYPE ### P -- PARTITION +- PAGES +- PAGESIZE +- PARTITIONS - PASS - PLUS +- PORT - PPS - PRECISION - PREV @@ -182,47 +222,63 @@ There are about 200 keywords reserved by TDengine, they can't be used as the nam ### Q +- QNODE +- QNODES - QTIME -- QUERIE +- QUERIES - QUERY -- QUORUM ### R - RAISE -- REM +- RANGE +- RATIO +- READ +- REDISTRIBUTE +- RENAME - REPLACE - REPLICA - RESET -- RESTRIC +- RESTRICT +- RETENTIONS +- REVOKE +- ROLLUP - ROW -- RP -- RSHIFT ### S +- SCHEMALESS - SCORES - SELECT - SEMI +- SERVER_STATUS +- SERVER_VERSION - SESSION - SET - SHOW -- SLASH +- SINGLE_STABLE - SLIDING - SLIMIT -- SMALLIN +- SMA +- SMALLINT +- SNODE +- SNODES - SOFFSET -- STable -- STableS +- SPLIT +- STABLE +- STABLES - STAR - STATE -- STATEMEN -- STATE_WI +- STATE_WINDOW +- STATEMENT - STORAGE - STREAM - STREAMS +- STRICT - STRING +- SUBSCRIPTIONS - SYNCDB +- SYSINFO ### T @@ -233,20 +289,24 @@ There are about 200 keywords reserved by TDengine, they can't be used as the nam - TBNAME - TIMES - TIMESTAMP +- TIMEZONE - TINYINT +- TO +- TODAY - TOPIC - TOPICS +- TRANSACTION +- TRANSACTIONS - TRIGGER +- TRIM - TSERIES - TTL ### U -- UMINUS - UNION - UNSIGNED - UPDATE -- UPLUS - USE - USER - USERS @@ -256,8 +316,11 @@ There are about 200 keywords reserved by TDengine, they can't be used as the nam - VALUE - VALUES +- VARCHAR - VARIABLE - VARIABLES +- VERBOSE +- VGROUP - VGROUPS - VIEW - VNODES @@ -265,14 +328,25 @@ There are about 200 keywords reserved by TDengine, they can't be used as the nam ### W - WAL +- WAL_FSYNC_PERIOD +- WAL_LEVEL +- WAL_RETENTION_PERIOD +- WAL_RETENTION_SIZE +- WAL_ROLL_PERIOD +- WAL_SEGMENT_SIZE +- WATERMARK - WHERE +- WINDOW_CLOSE +- WITH +- WRITE ### \_ - \_C0 -- \_QSTART -- \_QSTOP - \_QDURATION -- \_WSTART -- \_WSTOP +- \_QEND +- \_QSTART +- \_ROWTS - \_WDURATION +- \_WEND +- \_WSTART diff --git a/docs/zh/12-taos-sql/20-keywords.md b/docs/zh/12-taos-sql/20-keywords.md index 57a45b0a00..7530e803db 100644 --- a/docs/zh/12-taos-sql/20-keywords.md +++ b/docs/zh/12-taos-sql/20-keywords.md @@ -6,7 +6,8 @@ description: TDengine 保留关键字的详细列表 ## 保留关键字 -目前 TDengine 有将近 200 个内部保留关键字，这些关键字无论大小写如果需要用作库名、表名、STable 名、数据列名及标签列名等，需要使用符号 `` ` `` 将关键字括起来使用，例如 \`ADD\`。 +目前 TDengine 有 200 多个内部保留关键字，这些关键字如果需要用作库名、表名、超级表名、子表名、数据列名及标签列名等，无论大小写，需要使用符号 `` ` `` 将关键字括起来使用，例如 \`ADD\`。 + 关键字列表如下： ### A @@ -16,15 +17,20 @@ description: TDengine 保留关键字的详细列表 - ACCOUNTS - ADD - AFTER +- AGGREGATE - ALL - ALTER +- ANALYZE - AND +- APPS - AS - ASC +- AT_ONCE - ATTACH ### B +- BALANCE - BEFORE - BEGIN - BETWEEN @@ -34,19 +40,27 @@ description: TDengine 保留关键字的详细列表 - BITNOT - BITOR - BLOCKS +- BNODE +- BNODES - BOOL +- BUFFER +- BUFSIZE - BY ### C - CACHE -- CACHELAST +- CACHEMODEL +- CACHESIZE - CASCADE +- CAST - CHANGE +- CLIENT_VERSION - CLUSTER - COLON - COLUMN - COMMA +- COMMENT - COMP - COMPACT - CONCAT @@ -54,15 +68,18 @@ description: TDengine 保留关键字的详细列表 - CONNECTION - CONNECTIONS - CONNS +- CONSUMER +- CONSUMERS +- CONTAINS - COPY +- COUNT - CREATE -- CTIME +- CURRENT_USER ### D - DATABASE - DATABASES -- DAYS - DBS - DEFERRED - DELETE @@ -71,18 +88,23 @@ description: TDengine 保留关键字的详细列表 - DESCRIBE - DETACH - DISTINCT +- DISTRIBUTED - DIVIDE - DNODE - DNODES - DOT - DOUBLE - DROP +- DURATION ### E +- EACH +- ENABLE - END -- EQ +- EVERY - EXISTS +- EXPIRED - EXPLAIN ### F @@ -90,18 +112,20 @@ description: TDengine 保留关键字的详细列表 - FAIL - FILE - FILL +- FIRST - FLOAT +- FLUSH - FOR - FROM -- FSYNC +- FUNCTION +- FUNCTIONS ### G -- GE - GLOB +- GRANT - GRANTS - GROUP -- GT ### H @@ -112,15 +136,18 @@ description: TDengine 保留关键字的详细列表 - ID - IF - IGNORE -- IMMEDIA +- IMMEDIATE - IMPORT - IN -- INITIAL +- INDEX +- INDEXES +- INITIALLY +- INNER - INSERT - INSTEAD - INT - INTEGER -- INTERVA +- INTERVAL - INTO - IS - ISNULL @@ -128,6 +155,7 @@ description: TDengine 保留关键字的详细列表 ### J - JOIN +- JSON ### K @@ -137,46 +165,57 @@ description: TDengine 保留关键字的详细列表 ### L -- LE +- LAST +- LAST_ROW +- LICENCES - LIKE - LIMIT - LINEAR - LOCAL -- LP -- LSHIFT -- LT ### M - MATCH +- MAX_DELAY - MAXROWS +- MERGE +- META - MINROWS - MINUS +- MNODE - MNODES - MODIFY - MODULES ### N -- NE +- NCHAR +- NEXT +- NMATCH - NONE - NOT - NOTNULL - NOW - NULL +- NULLS ### O - OF - OFFSET +- ON - OR - ORDER +- OUTPUTTYPE ### P -- PARTITION +- PAGES +- PAGESIZE +- PARTITIONS - PASS - PLUS +- PORT - PPS - PRECISION - PREV @@ -184,47 +223,63 @@ description: TDengine 保留关键字的详细列表 ### Q +- QNODE +- QNODES - QTIME -- QUERIE +- QUERIES - QUERY -- QUORUM ### R - RAISE -- REM +- RANGE +- RATIO +- READ +- REDISTRIBUTE +- RENAME - REPLACE - REPLICA - RESET -- RESTRIC +- RESTRICT +- RETENTIONS +- REVOKE +- ROLLUP - ROW -- RP -- RSHIFT ### S +- SCHEMALESS - SCORES - SELECT - SEMI +- SERVER_STATUS +- SERVER_VERSION - SESSION - SET - SHOW -- SLASH +- SINGLE_STABLE - SLIDING - SLIMIT -- SMALLIN +- SMA +- SMALLINT +- SNODE +- SNODES - SOFFSET -- STable -- STableS +- SPLIT +- STABLE +- STABLES - STAR - STATE -- STATEMEN -- STATE_WI +- STATE_WINDOW +- STATEMENT - STORAGE - STREAM - STREAMS +- STRICT - STRING +- SUBSCRIPTIONS - SYNCDB +- SYSINFO ### T @@ -235,20 +290,24 @@ description: TDengine 保留关键字的详细列表 - TBNAME - TIMES - TIMESTAMP +- TIMEZONE - TINYINT +- TO +- TODAY - TOPIC - TOPICS +- TRANSACTION +- TRANSACTIONS - TRIGGER +- TRIM - TSERIES - TTL ### U -- UMINUS - UNION - UNSIGNED - UPDATE -- UPLUS - USE - USER - USERS @@ -258,8 +317,11 @@ description: TDengine 保留关键字的详细列表 - VALUE - VALUES +- VARCHAR - VARIABLE - VARIABLES +- VERBOSE +- VGROUP - VGROUPS - VIEW - VNODES @@ -267,14 +329,25 @@ description: TDengine 保留关键字的详细列表 ### W - WAL +- WAL_FSYNC_PERIOD +- WAL_LEVEL +- WAL_RETENTION_PERIOD +- WAL_RETENTION_SIZE +- WAL_ROLL_PERIOD +- WAL_SEGMENT_SIZE +- WATERMARK - WHERE +- WINDOW_CLOSE +- WITH +- WRITE ### \_ - \_C0 -- \_QSTART -- \_QSTOP - \_QDURATION -- \_WSTART -- \_WSTOP +- \_QEND +- \_QSTART +- \_ROWTS - \_WDURATION +- \_WEND +- \_WSTART From aa43876665e468f27c81e81331458bfc1304d804 Mon Sep 17 00:00:00 2001 From: Cary Xu Date: Wed, 14 Sep 2022 18:10:51 +0800 Subject: [PATCH 086/138] enh: tsdb retention and fs optimization --- include/libs/tfs/tfs.h | 8 ++++++++ source/dnode/vnode/src/tsdb/tsdbFS.c | 4 ++-- source/dnode/vnode/src/tsdb/tsdbRetention.c | 15 +++++++++++++-- source/libs/tfs/src/tfs.c | 2 ++ 4 files changed, 25 insertions(+), 4 deletions(-) diff --git a/include/libs/tfs/tfs.h b/include/libs/tfs/tfs.h index 1dc154ce48..6f71fd4cd0 100644 --- a/include/libs/tfs/tfs.h +++ b/include/libs/tfs/tfs.h @@ -69,6 +69,14 @@ void tfsUpdateSize(STfs *pTfs); */ SDiskSize tfsGetSize(STfs *pTfs); +/** + * @brief Get level of multi-tier storage. + * + * @param pTfs + * @return int32_t + */ +int32_t tfsGetLevel(STfs *pTfs); + /** * @brief Allocate an existing available tier level from fs. * diff --git a/source/dnode/vnode/src/tsdb/tsdbFS.c b/source/dnode/vnode/src/tsdb/tsdbFS.c index 31bdb784dd..f02bf2871c 100644 --- a/source/dnode/vnode/src/tsdb/tsdbFS.c +++ b/source/dnode/vnode/src/tsdb/tsdbFS.c @@ -58,7 +58,7 @@ static int32_t tsdbGnrtCurrent(STsdb *pTsdb, STsdbFS *pFS, char *fname) { taosCalcChecksumAppend(0, pData, size); // create and write - pFD = taosOpenFile(fname, TD_FILE_WRITE | TD_FILE_CREATE); + pFD = taosOpenFile(fname, TD_FILE_WRITE | TD_FILE_CREATE | TD_FILE_TRUNC); if (pFD == NULL) { code = TAOS_SYSTEM_ERROR(errno); goto _err; @@ -1033,7 +1033,7 @@ int32_t tsdbFSCommit2(STsdb *pTsdb, STsdbFS *pFSNew) { code = TSDB_CODE_OUT_OF_MEMORY; goto _err; } - iOld++; + iNew++; continue; } diff --git a/source/dnode/vnode/src/tsdb/tsdbRetention.c b/source/dnode/vnode/src/tsdb/tsdbRetention.c index d99bf2aa5c..eb4151079b 100644 --- a/source/dnode/vnode/src/tsdb/tsdbRetention.c +++ b/source/dnode/vnode/src/tsdb/tsdbRetention.c @@ -16,9 +16,19 @@ #include "tsdb.h" static bool tsdbShouldDoRetention(STsdb *pTsdb, int64_t now) { + STsdbKeepCfg *keepCfg = &pTsdb->keepCfg; + + if ((keepCfg->keep0 == keepCfg->keep1) && (keepCfg->keep1 == keepCfg->keep2)) { + return false; + } + + if (tfsGetLevel(pTsdb->pVnode->pTfs) <= 1) { + return false; + } + for (int32_t iSet = 0; iSet < taosArrayGetSize(pTsdb->fs.aDFileSet); iSet++) { SDFileSet *pSet = (SDFileSet *)taosArrayGet(pTsdb->fs.aDFileSet, iSet); - int32_t expLevel = tsdbFidLevel(pSet->fid, &pTsdb->keepCfg, now); + int32_t expLevel = tsdbFidLevel(pSet->fid, keepCfg, now); SDiskID did; if (expLevel == pSet->diskId.level) continue; @@ -53,7 +63,7 @@ int32_t tsdbDoRetention(STsdb *pTsdb, int64_t now) { if (code) goto _err; for (int32_t iSet = 0; iSet < taosArrayGetSize(fs.aDFileSet); iSet++) { - SDFileSet *pSet = (SDFileSet *)taosArrayGet(pTsdb->fs.aDFileSet, iSet); + SDFileSet *pSet = (SDFileSet *)taosArrayGet(fs.aDFileSet, iSet); int32_t expLevel = tsdbFidLevel(pSet->fid, &pTsdb->keepCfg, now); SDiskID did; @@ -65,6 +75,7 @@ int32_t tsdbDoRetention(STsdb *pTsdb, int64_t now) { taosArrayRemove(fs.aDFileSet, iSet); iSet--; } else { + if (expLevel == 0) continue; if (tfsAllocDisk(pTsdb->pVnode->pTfs, expLevel, &did) < 0) { code = terrno; goto _exit; diff --git a/source/libs/tfs/src/tfs.c b/source/libs/tfs/src/tfs.c index 62aec219df..4600e5e568 100644 --- a/source/libs/tfs/src/tfs.c +++ b/source/libs/tfs/src/tfs.c @@ -113,6 +113,8 @@ SDiskSize tfsGetSize(STfs *pTfs) { return size; } +int32_t tfsGetLevel(STfs *pTfs) { return pTfs->nlevel; } + int32_t tfsAllocDisk(STfs *pTfs, int32_t expLevel, SDiskID *pDiskId) { pDiskId->level = expLevel; pDiskId->id = -1; From 760babe7db64bb479f9f327842e219d043eee838 Mon Sep 17 00:00:00 2001 From: afwerar <1296468573@qq.com> Date: Wed, 14 Sep 2022 18:44:58 +0800 Subject: [PATCH 087/138] os: mac exit error --- source/os/src/osSemaphore.c | 11 +++--- source/os/src/osSysinfo.c | 35 +++++++++---------- tests/system-test/0-others/taosShellNetChk.py | 2 +- tests/system-test/1-insert/mutil_stage.py | 3 ++ 4 files changed, 24 insertions(+), 27 deletions(-) diff --git a/source/os/src/osSemaphore.c b/source/os/src/osSemaphore.c index 8cc6f0ef2e..5baba5af1e 100644 --- a/source/os/src/osSemaphore.c +++ b/source/os/src/osSemaphore.c @@ -400,6 +400,9 @@ int tsem_init(tsem_t *psem, int flags, unsigned int count) { } int tsem_destroy(tsem_t *psem) { + if (psem == NULL || *psem == NULL) return -1; + dispatch_release(*psem); + *psem = NULL; return 0; } @@ -421,13 +424,7 @@ int tsem_timewait(tsem_t *psem, int64_t nanosecs) { return 0; } -bool taosCheckPthreadValid(TdThread thread) { - int32_t ret = taosThreadKill(thread, 0); - if (ret == ESRCH) return false; - if (ret == EINVAL) return false; - // alive - return true; -} +bool taosCheckPthreadValid(TdThread thread) { return thread != 0; } int64_t taosGetSelfPthreadId() { TdThread thread = taosThreadSelf(); diff --git a/source/os/src/osSysinfo.c b/source/os/src/osSysinfo.c index 19e9568bbe..6867c1373b 100644 --- a/source/os/src/osSysinfo.c +++ b/source/os/src/osSysinfo.c @@ -344,30 +344,27 @@ int32_t taosGetCpuInfo(char *cpuModel, int32_t maxLen, float *numOfCores) { *numOfCores = si.dwNumberOfProcessors; return 0; #elif defined(_TD_DARWIN_64) - char *line = NULL; - size_t size = 0; + char buf[16]; int32_t done = 0; int32_t code = -1; - TdFilePtr pFile = taosOpenFile("/proc/cpuinfo", TD_FILE_READ | TD_FILE_STREAM); - if (pFile == NULL) return false; - - while (done != 3 && (size = taosGetLineFile(pFile, &line)) != -1) { - line[size - 1] = '\0'; - if (((done & 1) == 0) && strncmp(line, "model name", 10) == 0) { - const char *v = strchr(line, ':') + 2; - tstrncpy(cpuModel, v, maxLen); - code = 0; - done |= 1; - } else if (((done & 2) == 0) && strncmp(line, "cpu cores", 9) == 0) { - const char *v = strchr(line, ':') + 2; - *numOfCores = atof(v); - done |= 2; - } + TdCmdPtr pCmd = taosOpenCmd("sysctl -n machdep.cpu.brand_string"); + if (pCmd == NULL) return code; + if (taosGetsCmd(pCmd, maxLen, cpuModel) > 0) { + code = 0; + done |= 1; } + taosCloseCmd(&pCmd); - if (line != NULL) taosMemoryFree(line); - taosCloseFile(&pFile); + pCmd = taosOpenCmd("sysctl -n machdep.cpu.core_count"); + if (pCmd == NULL) return code; + memset(buf, 0, sizeof(buf)); + if (taosGetsCmd(pCmd, maxLen, cpuModel) > 0) { + code = 0; + done |= 2; + *numOfCores = atof(buf); + } + taosCloseCmd(&pCmd); return code; #else diff --git a/tests/system-test/0-others/taosShellNetChk.py b/tests/system-test/0-others/taosShellNetChk.py index dd44852d49..80f6a6bc30 100644 --- a/tests/system-test/0-others/taosShellNetChk.py +++ b/tests/system-test/0-others/taosShellNetChk.py @@ -231,7 +231,7 @@ class TDTestCase: if platform.system().lower() == 'windows': os.system('ps -a | grep taos | awk \'{print $2}\' | xargs kill -9') else: - os.system('pkill taos') + os.system('pkill -9 taos') def stop(self): tdSql.close() diff --git a/tests/system-test/1-insert/mutil_stage.py b/tests/system-test/1-insert/mutil_stage.py index 764da1f166..63317e8036 100644 --- a/tests/system-test/1-insert/mutil_stage.py +++ b/tests/system-test/1-insert/mutil_stage.py @@ -1,4 +1,5 @@ from datetime import datetime +from platform import platform import time from typing import List, Any, Tuple @@ -83,6 +84,8 @@ class TDTestCase: def del_old_datadir(self, filename): cmd = f"sed -i '/^dataDir/d' {filename}" + if platform.system().lower() == 'darwin': + cmd = f"sed -i '' '/^dataDir/d' {filename}" if os.system(cmd) != 0: tdLog.exit(cmd) From cd015bae8384ebce3e875fbf83dc6e27e5613470 Mon Sep 17 00:00:00 2001 From: dapan1121 Date: Wed, 14 Sep 2022 19:02:26 +0800 Subject: [PATCH 088/138] fix: fix stateduration result error --- source/libs/function/src/builtinsimpl.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c index 470fa8fcd7..9b502eded7 100644 --- a/source/libs/function/src/builtinsimpl.c +++ b/source/libs/function/src/builtinsimpl.c @@ -4780,7 +4780,7 @@ int32_t stateDurationFunction(SqlFunctionCtx* pCtx) { colDataAppendNULL(pOutput, i); // handle selectivity if (pCtx->subsidiaries.num > 0) { - appendSelectivityValue(pCtx, i, i); + appendSelectivityValue(pCtx, i, pCtx->offset + numOfElems - 1); } continue; } @@ -4797,11 +4797,11 @@ int32_t stateDurationFunction(SqlFunctionCtx* pCtx) { } else { pInfo->durationStart = 0; } - colDataAppend(pOutput, i, (char*)&output, false); + colDataAppend(pOutput, pCtx->offset + numOfElems - 1, (char*)&output, false); // handle selectivity if (pCtx->subsidiaries.num > 0) { - appendSelectivityValue(pCtx, i, i); + appendSelectivityValue(pCtx, i, pCtx->offset + numOfElems - 1); } } From f7fe7a4afb56370b8a872f95598f43c4fc2f244a Mon Sep 17 00:00:00 2001 From: Cary Xu Date: Wed, 14 Sep 2022 19:18:51 +0800 Subject: [PATCH 089/138] fix: remove the code change for commit --- source/dnode/vnode/src/tsdb/tsdbFS.c | 1 + 1 file changed, 1 insertion(+) diff --git a/source/dnode/vnode/src/tsdb/tsdbFS.c b/source/dnode/vnode/src/tsdb/tsdbFS.c index f02bf2871c..d80ce9c899 100644 --- a/source/dnode/vnode/src/tsdb/tsdbFS.c +++ b/source/dnode/vnode/src/tsdb/tsdbFS.c @@ -1034,6 +1034,7 @@ int32_t tsdbFSCommit2(STsdb *pTsdb, STsdbFS *pFSNew) { goto _err; } + iOld++; iNew++; continue; } From e05fd1615b2793798eb73ce4b67614bb297fb1be Mon Sep 17 00:00:00 2001 From: Cary Xu Date: Wed, 14 Sep 2022 19:19:25 +0800 Subject: [PATCH 090/138] fix: remove the code change for commit --- source/dnode/vnode/src/tsdb/tsdbFS.c | 1 - 1 file changed, 1 deletion(-) diff --git a/source/dnode/vnode/src/tsdb/tsdbFS.c b/source/dnode/vnode/src/tsdb/tsdbFS.c index d80ce9c899..10926ae6ad 100644 --- a/source/dnode/vnode/src/tsdb/tsdbFS.c +++ b/source/dnode/vnode/src/tsdb/tsdbFS.c @@ -1033,7 +1033,6 @@ int32_t tsdbFSCommit2(STsdb *pTsdb, STsdbFS *pFSNew) { code = TSDB_CODE_OUT_OF_MEMORY; goto _err; } - iOld++; iNew++; continue; From 66bcf1fad695fd4665a58a0d995e6097d6a7efcb Mon Sep 17 00:00:00 2001 From: Minglei Jin Date: Wed, 14 Sep 2022 15:08:33 +0800 Subject: [PATCH 091/138] fix: deep copy ovfl cells to avoid double free --- source/libs/tdb/src/db/tdbBtree.c | 6 +++--- source/libs/tdb/src/db/tdbPage.c | 11 +++++++++-- source/libs/tdb/src/inc/tdbInt.h | 2 +- 3 files changed, 13 insertions(+), 6 deletions(-) diff --git a/source/libs/tdb/src/db/tdbBtree.c b/source/libs/tdb/src/db/tdbBtree.c index 1480920f90..c6ecd37680 100644 --- a/source/libs/tdb/src/db/tdbBtree.c +++ b/source/libs/tdb/src/db/tdbBtree.c @@ -489,7 +489,7 @@ static int tdbBtreeBalanceDeeper(SBTree *pBt, SPage *pRoot, SPage **ppChild, TXN } // Copy the root page content to the child page - tdbPageCopy(pRoot, pChild); + tdbPageCopy(pRoot, pChild, 0); // Reinitialize the root page zArg.flags = TDB_BTREE_ROOT; @@ -742,7 +742,7 @@ static int tdbBtreeBalanceNonRoot(SBTree *pBt, SPage *pParent, int idx, TXN *pTx for (int i = 0; i < nOlds; i++) { tdbPageCreate(pOlds[0]->pageSize, &pOldsCopy[i], tdbDefaultMalloc, NULL); tdbBtreeInitPage(pOldsCopy[i], &iarg, 0); - tdbPageCopy(pOlds[i], pOldsCopy[i]); + tdbPageCopy(pOlds[i], pOldsCopy[i], 0); } iNew = 0; nNewCells = 0; @@ -840,7 +840,7 @@ static int tdbBtreeBalanceNonRoot(SBTree *pBt, SPage *pParent, int idx, TXN *pTx i8 flags = TDB_BTREE_ROOT | TDB_BTREE_PAGE_IS_LEAF(pNews[0]); // copy content to the parent page tdbBtreeInitPage(pParent, &(SBtreeInitPageArg){.flags = flags, .pBt = pBt}, 0); - tdbPageCopy(pNews[0], pParent); + tdbPageCopy(pNews[0], pParent, 1); } for (int i = 0; i < 3; i++) { diff --git a/source/libs/tdb/src/db/tdbPage.c b/source/libs/tdb/src/db/tdbPage.c index a3f376b929..1e2eefabf4 100644 --- a/source/libs/tdb/src/db/tdbPage.c +++ b/source/libs/tdb/src/db/tdbPage.c @@ -229,7 +229,7 @@ int tdbPageDropCell(SPage *pPage, int idx, TXN *pTxn, SBTree *pBt) { return 0; } -void tdbPageCopy(SPage *pFromPage, SPage *pToPage) { +void tdbPageCopy(SPage *pFromPage, SPage *pToPage, int deepCopyOvfl) { int delta, nFree; pToPage->pFreeStart = pToPage->pPageHdr + (pFromPage->pFreeStart - pFromPage->pPageHdr); @@ -250,8 +250,15 @@ void tdbPageCopy(SPage *pFromPage, SPage *pToPage) { // Copy the overflow cells for (int iOvfl = 0; iOvfl < pFromPage->nOverflow; iOvfl++) { + SCell *pNewCell = pFromPage->apOvfl[iOvfl]; + if (deepCopyOvfl) { + int szCell = (*pFromPage->xCellSize)(pFromPage, pFromPage->apOvfl[iOvfl], 0, NULL, NULL); + pNewCell = (SCell *)tdbOsMalloc(szCell); + memcpy(pNewCell, pFromPage->apOvfl[iOvfl], szCell); + } + + pToPage->apOvfl[iOvfl] = pNewCell; pToPage->aiOvfl[iOvfl] = pFromPage->aiOvfl[iOvfl]; - pToPage->apOvfl[iOvfl] = pFromPage->apOvfl[iOvfl]; } pToPage->nOverflow = pFromPage->nOverflow; } diff --git a/source/libs/tdb/src/inc/tdbInt.h b/source/libs/tdb/src/inc/tdbInt.h index df6ba8b35f..29a9665c15 100644 --- a/source/libs/tdb/src/inc/tdbInt.h +++ b/source/libs/tdb/src/inc/tdbInt.h @@ -333,7 +333,7 @@ void tdbPageInit(SPage *pPage, u8 szAmHdr, int (*xCellSize)(const SPage *, SCell int tdbPageInsertCell(SPage *pPage, int idx, SCell *pCell, int szCell, u8 asOvfl); int tdbPageDropCell(SPage *pPage, int idx, TXN *pTxn, SBTree *pBt); int tdbPageUpdateCell(SPage *pPage, int idx, SCell *pCell, int szCell, TXN *pTxn, SBTree *pBt); -void tdbPageCopy(SPage *pFromPage, SPage *pToPage); +void tdbPageCopy(SPage *pFromPage, SPage *pToPage, int copyOvflCells); int tdbPageCapacity(int pageSize, int amHdrSize); static inline SCell *tdbPageGetCell(SPage *pPage, int idx) { From dcbdc43ff5a22cecad48cded12b6b0668d60cc82 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Wed, 14 Sep 2022 22:38:29 +0800 Subject: [PATCH 092/138] fix some code --- source/common/src/tdataformat.c | 39 +++++++++++++-------------------- 1 file changed, 15 insertions(+), 24 deletions(-) diff --git a/source/common/src/tdataformat.c b/source/common/src/tdataformat.c index dd2667b302..fc7d211ab3 100644 --- a/source/common/src/tdataformat.c +++ b/source/common/src/tdataformat.c @@ -1210,6 +1210,7 @@ static FORCE_INLINE int32_t tColDataPutValue(SColData *pColData, SColVal *pColVa pColData->nData += pColVal->value.nData; } } else { + ASSERT(pColData->nData == tDataTypes[pColData->type].bytes * pColData->nVal); code = tRealloc(&pColData->pData, pColData->nData + tDataTypes[pColData->type].bytes); if (code) goto _exit; pColData->nData += tPutValue(pColData->pData + pColData->nData, &pColVal->value, pColVal->type); @@ -1331,6 +1332,8 @@ static FORCE_INLINE int32_t tColDataAppendValue3(SColData *pColData, SColVal *pC SET_BIT1(pColData->pBitMap, pColData->nVal, 1); } else { + pColData->flag |= HAS_VALUE; + uint8_t *pBitMap = NULL; code = tRealloc(&pBitMap, BIT2_SIZE(pColData->nVal + 1)); if (code) goto _exit; @@ -1340,8 +1343,6 @@ static FORCE_INLINE int32_t tColDataAppendValue3(SColData *pColData, SColVal *pC } SET_BIT2(pBitMap, pColData->nVal, 2); - pColData->flag |= HAS_VALUE; - tFree(pColData->pBitMap); pColData->pBitMap = pBitMap; @@ -1370,31 +1371,21 @@ _exit: static FORCE_INLINE int32_t tColDataAppendValue4(SColData *pColData, SColVal *pColVal) { // HAS_VALUE int32_t code = 0; - if (pColVal->isNone) { - pColData->flag |= HAS_NONE; + if (pColVal->isNone || pColVal->isNull) { + if (pColVal->isNone) { + pColData->flag |= HAS_NONE; + } else { + pColData->flag |= HAS_NULL; + } - code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1)); + int32_t nBit = BIT1_SIZE(pColData->nVal + 1); + code = tRealloc(&pColData->pBitMap, nBit); if (code) goto _exit; - for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) { - SET_BIT1(pColData->pBitMap, iVal, 1); - } + memset(pColData->pBitMap, 255, nBit); SET_BIT1(pColData->pBitMap, pColData->nVal, 0); - code = tColDataPutValue(pColData, &COL_VAL_VALUE(pColData->cid, pColData->type, (SValue){0})); - if (code) goto _exit; - } else if (pColVal->isNull) { - pColData->flag |= HAS_NULL; - - code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1)); - if (code) goto _exit; - - for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) { - SET_BIT1(pColData->pBitMap, iVal, 1); - } - SET_BIT1(pColData->pBitMap, pColData->nVal, 0); - - code = tColDataPutValue(pColData, &COL_VAL_VALUE(pColData->cid, pColData->type, (SValue){0})); + code = tColDataPutValue(pColData, pColVal); if (code) goto _exit; } else { code = tColDataPutValue(pColData, pColVal); @@ -1415,7 +1406,7 @@ static FORCE_INLINE int32_t tColDataAppendValue5(SColData *pColData, SColVal *pC code = tRealloc(&pBitMap, BIT2_SIZE(pColData->nVal + 1)); if (code) goto _exit; - for (int32_t iVal = 0; iVal < pColData->nData; iVal++) { + for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) { SET_BIT2(pBitMap, iVal, GET_BIT1(pColData->pBitMap, iVal) ? 2 : 0); } SET_BIT2(pBitMap, pColData->nVal, 1); @@ -1450,7 +1441,7 @@ static FORCE_INLINE int32_t tColDataAppendValue6(SColData *pColData, SColVal *pC code = tRealloc(&pBitMap, BIT2_SIZE(pColData->nVal + 1)); if (code) goto _exit; - for (int32_t iVal = 0; iVal < pColData->nData; iVal++) { + for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) { SET_BIT2(pBitMap, iVal, GET_BIT1(pColData->pBitMap, iVal) ? 2 : 1); } SET_BIT2(pBitMap, pColData->nVal, 0); From 3b947f17adcaab5f2b77b06a12eccb3ce2c1d7b2 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Wed, 14 Sep 2022 22:47:44 +0800 Subject: [PATCH 093/138] more code --- source/dnode/vnode/src/tsdb/tsdbUtil.c | 88 ++++---------------------- 1 file changed, 13 insertions(+), 75 deletions(-) diff --git a/source/dnode/vnode/src/tsdb/tsdbUtil.c b/source/dnode/vnode/src/tsdb/tsdbUtil.c index 32fc7b82a1..64c150484b 100644 --- a/source/dnode/vnode/src/tsdb/tsdbUtil.c +++ b/source/dnode/vnode/src/tsdb/tsdbUtil.c @@ -1744,47 +1744,16 @@ int32_t tsdbCmprColData(SColData *pColData, int8_t cmprAlg, SBlockCol *pBlockCol int32_t size = 0; // bitmap if (pColData->flag != HAS_VALUE) { - uint8_t *pBitMap = pColData->pBitMap; - int32_t szBitMap = BIT2_SIZE(pColData->nVal); - - // BIT2 to BIT1 - if (pColData->flag != (HAS_VALUE | HAS_NULL | HAS_NONE)) { + int32_t szBitMap; + if (pColData->flag == (HAS_VALUE | HAS_NULL | HAS_NONE)) { + szBitMap = BIT2_SIZE(pColData->nVal); + } else { szBitMap = BIT1_SIZE(pColData->nVal); - pBitMap = taosMemoryCalloc(1, szBitMap); - if (pBitMap == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _exit; - } - - for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) { - uint8_t v = GET_BIT2(pColData->pBitMap, iVal); - switch (pColData->flag) { - case (HAS_NULL | HAS_NONE): - SET_BIT1(pBitMap, iVal, v); - break; - case (HAS_VALUE | HAS_NONE): - if (v) { - SET_BIT1(pBitMap, iVal, 1); - } else { - SET_BIT1(pBitMap, iVal, 0); - } - break; - case (HAS_VALUE | HAS_NULL): - SET_BIT1(pBitMap, iVal, v - 1); - break; - default: - ASSERT(0); - } - } } - code = tsdbCmprData(pBitMap, szBitMap, TSDB_DATA_TYPE_TINYINT, cmprAlg, ppOut, nOut + size, &pBlockCol->szBitmap, - ppBuf); + code = tsdbCmprData(pColData->pBitMap, szBitMap, TSDB_DATA_TYPE_TINYINT, cmprAlg, ppOut, nOut + size, + &pBlockCol->szBitmap, ppBuf); if (code) goto _exit; - - if (pColData->flag != (HAS_VALUE | HAS_NULL | HAS_NONE)) { - taosMemoryFree(pBitMap); - } } size += pBlockCol->szBitmap; @@ -1822,46 +1791,15 @@ int32_t tsdbDecmprColData(uint8_t *pIn, SBlockCol *pBlockCol, int8_t cmprAlg, in uint8_t *p = pIn; // bitmap if (pBlockCol->szBitmap) { - if (pBlockCol->flag != (HAS_VALUE | HAS_NULL | HAS_NONE)) { - uint8_t *pBitMap = NULL; - code = tsdbDecmprData(p, pBlockCol->szBitmap, TSDB_DATA_TYPE_TINYINT, cmprAlg, &pBitMap, - BIT1_SIZE(pColData->nVal), ppBuf); - if (code) goto _exit; - - code = tRealloc(&pColData->pBitMap, BIT2_SIZE(pColData->nVal)); - if (code) { - tFree(pBitMap); - goto _exit; - } - - // BIT1 to BIT2 - for (int32_t iVal = 0; iVal < nVal; iVal++) { - uint8_t v = GET_BIT1(pBitMap, iVal); - switch (pBlockCol->flag) { - case (HAS_NULL | HAS_NONE): - SET_BIT2(pColData->pBitMap, iVal, v); - break; - case (HAS_VALUE | HAS_NONE): - if (v) { - SET_BIT2(pColData->pBitMap, iVal, 2); - } else { - SET_BIT2(pColData->pBitMap, iVal, 0); - } - break; - case (HAS_VALUE | HAS_NULL): - SET_BIT2(pColData->pBitMap, iVal, v + 1); - break; - default: - ASSERT(0); - } - } - - tFree(pBitMap); + int32_t szBitMap; + if (pColData->flag == (HAS_VALUE | HAS_NULL | HAS_NONE)) { + szBitMap = BIT2_SIZE(pColData->nVal); } else { - code = tsdbDecmprData(p, pBlockCol->szBitmap, TSDB_DATA_TYPE_TINYINT, cmprAlg, &pColData->pBitMap, - BIT2_SIZE(pColData->nVal), ppBuf); - if (code) goto _exit; + szBitMap = BIT1_SIZE(pColData->nVal); } + + code = tsdbDecmprData(p, pBlockCol->szBitmap, TSDB_DATA_TYPE_TINYINT, cmprAlg, &pColData->pBitMap, szBitMap, ppBuf); + if (code) goto _exit; } p += pBlockCol->szBitmap; From ab3f6619b979e01144c8692d984f3c90baabe2e9 Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Wed, 14 Sep 2022 23:29:38 +0800 Subject: [PATCH 094/138] enh(tsc): handle deadlock --- source/client/src/clientHb.c | 33 +++++++++++++++++++++++++++------ 1 file changed, 27 insertions(+), 6 deletions(-) diff --git a/source/client/src/clientHb.c b/source/client/src/clientHb.c index 84a827ed78..fc03a66655 100644 --- a/source/client/src/clientHb.c +++ b/source/client/src/clientHb.c @@ -173,7 +173,8 @@ static int32_t hbQueryHbRspHandle(SAppHbMgr *pAppHbMgr, SClientHbRsp *pRsp) { pTscObj->pAppInfo->totalDnodes = pRsp->query->totalDnodes; pTscObj->pAppInfo->onlineDnodes = pRsp->query->onlineDnodes; pTscObj->connId = pRsp->query->connId; - tscTrace("conn %p hb rsp, dnodes %d/%d", pTscObj->connId, pTscObj->pAppInfo->onlineDnodes, pTscObj->pAppInfo->totalDnodes); + tscTrace("conn %p hb rsp, dnodes %d/%d", pTscObj->connId, pTscObj->pAppInfo->onlineDnodes, + pTscObj->pAppInfo->totalDnodes); if (pRsp->query->killRid) { tscDebug("request rid %" PRIx64 " need to be killed now", pRsp->query->killRid); @@ -297,7 +298,8 @@ static int32_t hbAsyncCallBack(void *param, SDataBuf *pMsg, int32_t code) { if (code != 0) { (*pInst)->onlineDnodes = ((*pInst)->totalDnodes ? 0 : -1); - tscDebug("hb rsp error %s, update server status %d/%d", tstrerror(code), (*pInst)->onlineDnodes, (*pInst)->totalDnodes); + tscDebug("hb rsp error %s, update server status %d/%d", tstrerror(code), (*pInst)->onlineDnodes, + (*pInst)->totalDnodes); } if (rspNum) { @@ -654,6 +656,8 @@ int32_t hbGatherAppInfo(void) { for (int32_t i = 0; i < sz; ++i) { SAppHbMgr *pAppHbMgr = taosArrayGetP(clientHbMgr.appHbMgrs, i); + if (pAppHbMgr == NULL) continue; + uint64_t clusterId = pAppHbMgr->pAppInstInfo->clusterId; SAppHbReq *pApp = taosHashGet(clientHbMgr.appSummary, &clusterId, sizeof(clusterId)); if (NULL == pApp) { @@ -691,15 +695,20 @@ static void *hbThreadFunc(void *param) { hbGatherAppInfo(); } + SArray *mgr = taosArrayInit(sz, sizeof(void *)); for (int i = 0; i < sz; i++) { SAppHbMgr *pAppHbMgr = taosArrayGetP(clientHbMgr.appHbMgrs, i); + if (pAppHbMgr == NULL) { + continue; + } int32_t connCnt = atomic_load_32(&pAppHbMgr->connKeyCnt); if (connCnt == 0) { continue; } SClientHbBatchReq *pReq = hbGatherAllInfo(pAppHbMgr); - if (pReq == NULL) { + if (pReq == NULL || taosArrayGetP(clientHbMgr.appHbMgrs, i) == NULL) { + tFreeClientHbBatchReq(pReq); continue; } int tlen = tSerializeSClientHbBatchReq(NULL, 0, pReq); @@ -726,7 +735,7 @@ static void *hbThreadFunc(void *param) { pInfo->msgInfo.len = tlen; pInfo->msgType = TDMT_MND_HEARTBEAT; pInfo->param = strdup(pAppHbMgr->key); - pInfo->paramFreeFp = taosMemoryFree; + pInfo->paramFreeFp = taosMemoryFree; pInfo->requestId = generateRequestId(); pInfo->requestObjRefId = 0; @@ -738,8 +747,12 @@ static void *hbThreadFunc(void *param) { // hbClearReqInfo(pAppHbMgr); atomic_add_fetch_32(&pAppHbMgr->reportCnt, 1); + taosArrayPush(mgr, &pAppHbMgr); } + taosArrayDestroy(clientHbMgr.appHbMgrs); + clientHbMgr.appHbMgrs = mgr; + taosThreadMutexUnlock(&clientHbMgr.lock); taosMsleep(HEARTBEAT_INTERVAL); @@ -831,7 +844,7 @@ void hbRemoveAppHbMrg(SAppHbMgr **pAppHbMgr) { if (pItem == *pAppHbMgr) { hbFreeAppHbMgr(*pAppHbMgr); *pAppHbMgr = NULL; - taosArrayRemove(clientHbMgr.appHbMgrs, i); + taosArraySet(clientHbMgr.appHbMgrs, i, NULL); break; } } @@ -856,7 +869,15 @@ int hbMgrInit() { clientHbMgr.appSummary = taosHashInit(10, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK); clientHbMgr.appHbMgrs = taosArrayInit(0, sizeof(void *)); - taosThreadMutexInit(&clientHbMgr.lock, NULL); + + TdThreadMutexAttr attr = {0}; + taosThreadMutexAttrSetType(&attr, PTHREAD_MUTEX_RECURSIVE); + + int ret = taosThreadMutexAttrInit(&attr); + assert(ret == 0); + + taosThreadMutexInit(&clientHbMgr.lock, &attr); + taosThreadMutexAttrDestroy(&attr); // init handle funcs hbMgrInitHandle(); From ef18966fa95ffbe23dcff2a1c520ad8517b89dae Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Thu, 15 Sep 2022 09:53:32 +0800 Subject: [PATCH 095/138] enh(tsc): handle deadlock --- source/client/src/clientHb.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/client/src/clientHb.c b/source/client/src/clientHb.c index fc03a66655..cf968937ac 100644 --- a/source/client/src/clientHb.c +++ b/source/client/src/clientHb.c @@ -844,7 +844,7 @@ void hbRemoveAppHbMrg(SAppHbMgr **pAppHbMgr) { if (pItem == *pAppHbMgr) { hbFreeAppHbMgr(*pAppHbMgr); *pAppHbMgr = NULL; - taosArraySet(clientHbMgr.appHbMgrs, i, NULL); + taosArraySet(clientHbMgr.appHbMgrs, i, pAppHbMgr); break; } } From 26f740f26b544fde7a2f12235c07b5c0c11282a0 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Thu, 15 Sep 2022 09:56:56 +0800 Subject: [PATCH 096/138] fix more --- include/common/tdataformat.h | 3 ++- source/common/src/tdataformat.c | 32 ++++++++++++++++++++++++++ source/dnode/vnode/src/tsdb/tsdbRead.c | 4 ++-- 3 files changed, 36 insertions(+), 3 deletions(-) diff --git a/include/common/tdataformat.h b/include/common/tdataformat.h index 159279329b..5b49560175 100644 --- a/include/common/tdataformat.h +++ b/include/common/tdataformat.h @@ -110,7 +110,8 @@ void tColDataDestroy(void *ph); void tColDataInit(SColData *pColData, int16_t cid, int8_t type, int8_t smaOn); void tColDataClear(SColData *pColData); int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal); -void tColDataGetValue(SColData *pColData, int32_t iRow, SColVal *pColVal); +void tColDataGetValue(SColData *pColData, int32_t iVal, SColVal *pColVal); +uint8_t tColDataGetBitValue(SColData *pColData, int32_t iVal); int32_t tColDataCopy(SColData *pColDataSrc, SColData *pColDataDest); // STRUCT ================================ diff --git a/source/common/src/tdataformat.c b/source/common/src/tdataformat.c index fc7d211ab3..15a369fe40 100644 --- a/source/common/src/tdataformat.c +++ b/source/common/src/tdataformat.c @@ -1592,6 +1592,38 @@ void tColDataGetValue(SColData *pColData, int32_t iVal, SColVal *pColVal) { tColDataGetValueImpl[pColData->flag](pColData, iVal, pColVal); } +uint8_t tColDataGetBitValue(SColData *pColData, int32_t iVal) { + uint8_t v; + switch (pColData->flag) { + case HAS_NONE: + v = 0; + break; + case HAS_NULL: + v = 1; + break; + case (HAS_NULL | HAS_NONE): + v = GET_BIT1(pColData->pBitMap, iVal); + break; + case HAS_VALUE: + v = 2; + break; + case (HAS_VALUE | HAS_NONE): + v = GET_BIT1(pColData->pBitMap, iVal); + if (v) v = 2; + break; + case (HAS_VALUE | HAS_NULL): + v = GET_BIT1(pColData->pBitMap, iVal) + 1; + break; + case (HAS_VALUE | HAS_NULL | HAS_NONE): + v = GET_BIT2(pColData->pBitMap, iVal); + break; + default: + ASSERT(0); + break; + } + return v; +} + int32_t tColDataCopy(SColData *pColDataSrc, SColData *pColDataDest) { int32_t code = 0; int32_t size; diff --git a/source/dnode/vnode/src/tsdb/tsdbRead.c b/source/dnode/vnode/src/tsdb/tsdbRead.c index 60d967681b..baa985fb24 100644 --- a/source/dnode/vnode/src/tsdb/tsdbRead.c +++ b/source/dnode/vnode/src/tsdb/tsdbRead.c @@ -903,7 +903,7 @@ static int32_t copyBlockDataToSDataBlock(STsdbReader* pReader, STableBlockScanIn // null value exists, check one-by-one if (pData->flag != HAS_VALUE) { for (int32_t j = pDumpInfo->rowIndex; rowIndex < remain; j += step, rowIndex++) { - uint8_t v = GET_BIT2(pData->pBitMap, j); + uint8_t v = tColDataGetBitValue(pData, j); if (v == 0 || v == 1) { colDataSetNull_f(pColData->nullbitmap, rowIndex); } @@ -4078,4 +4078,4 @@ void tsdbUntakeReadSnap(STsdb* pTsdb, STsdbReadSnap* pSnap) { } tsdbTrace("vgId:%d, untake read snapshot", TD_VID(pTsdb->pVnode)); -} \ No newline at end of file +} From f4be9a60c348a7d17771d36a9cb5ecc53bb705b0 Mon Sep 17 00:00:00 2001 From: afwerar <1296468573@qq.com> Date: Thu, 15 Sep 2022 10:04:30 +0800 Subject: [PATCH 097/138] os: mac exit error --- source/os/src/osSemaphore.c | 11 +++--- source/os/src/osSysinfo.c | 35 +++++++++---------- tests/system-test/0-others/taosShellNetChk.py | 2 +- tests/system-test/1-insert/mutil_stage.py | 3 ++ 4 files changed, 24 insertions(+), 27 deletions(-) diff --git a/source/os/src/osSemaphore.c b/source/os/src/osSemaphore.c index 8cc6f0ef2e..5baba5af1e 100644 --- a/source/os/src/osSemaphore.c +++ b/source/os/src/osSemaphore.c @@ -400,6 +400,9 @@ int tsem_init(tsem_t *psem, int flags, unsigned int count) { } int tsem_destroy(tsem_t *psem) { + if (psem == NULL || *psem == NULL) return -1; + dispatch_release(*psem); + *psem = NULL; return 0; } @@ -421,13 +424,7 @@ int tsem_timewait(tsem_t *psem, int64_t nanosecs) { return 0; } -bool taosCheckPthreadValid(TdThread thread) { - int32_t ret = taosThreadKill(thread, 0); - if (ret == ESRCH) return false; - if (ret == EINVAL) return false; - // alive - return true; -} +bool taosCheckPthreadValid(TdThread thread) { return thread != 0; } int64_t taosGetSelfPthreadId() { TdThread thread = taosThreadSelf(); diff --git a/source/os/src/osSysinfo.c b/source/os/src/osSysinfo.c index 19e9568bbe..0614b2a4c3 100644 --- a/source/os/src/osSysinfo.c +++ b/source/os/src/osSysinfo.c @@ -344,30 +344,27 @@ int32_t taosGetCpuInfo(char *cpuModel, int32_t maxLen, float *numOfCores) { *numOfCores = si.dwNumberOfProcessors; return 0; #elif defined(_TD_DARWIN_64) - char *line = NULL; - size_t size = 0; + char buf[16]; int32_t done = 0; int32_t code = -1; - TdFilePtr pFile = taosOpenFile("/proc/cpuinfo", TD_FILE_READ | TD_FILE_STREAM); - if (pFile == NULL) return false; - - while (done != 3 && (size = taosGetLineFile(pFile, &line)) != -1) { - line[size - 1] = '\0'; - if (((done & 1) == 0) && strncmp(line, "model name", 10) == 0) { - const char *v = strchr(line, ':') + 2; - tstrncpy(cpuModel, v, maxLen); - code = 0; - done |= 1; - } else if (((done & 2) == 0) && strncmp(line, "cpu cores", 9) == 0) { - const char *v = strchr(line, ':') + 2; - *numOfCores = atof(v); - done |= 2; - } + TdCmdPtr pCmd = taosOpenCmd("sysctl -n machdep.cpu.brand_string"); + if (pCmd == NULL) return code; + if (taosGetsCmd(pCmd, maxLen, cpuModel) > 0) { + code = 0; + done |= 1; } + taosCloseCmd(&pCmd); - if (line != NULL) taosMemoryFree(line); - taosCloseFile(&pFile); + pCmd = taosOpenCmd("sysctl -n machdep.cpu.core_count"); + if (pCmd == NULL) return code; + memset(buf, 0, sizeof(buf)); + if (taosGetsCmd(pCmd, maxLen, cpuModel) > 0) { + code = 0; + done |= 2; + *numOfCores = atof(buf); + } + taosCloseCmd(&pCmd); return code; #else diff --git a/tests/system-test/0-others/taosShellNetChk.py b/tests/system-test/0-others/taosShellNetChk.py index dd44852d49..80f6a6bc30 100644 --- a/tests/system-test/0-others/taosShellNetChk.py +++ b/tests/system-test/0-others/taosShellNetChk.py @@ -231,7 +231,7 @@ class TDTestCase: if platform.system().lower() == 'windows': os.system('ps -a | grep taos | awk \'{print $2}\' | xargs kill -9') else: - os.system('pkill taos') + os.system('pkill -9 taos') def stop(self): tdSql.close() diff --git a/tests/system-test/1-insert/mutil_stage.py b/tests/system-test/1-insert/mutil_stage.py index 764da1f166..63317e8036 100644 --- a/tests/system-test/1-insert/mutil_stage.py +++ b/tests/system-test/1-insert/mutil_stage.py @@ -1,4 +1,5 @@ from datetime import datetime +from platform import platform import time from typing import List, Any, Tuple @@ -83,6 +84,8 @@ class TDTestCase: def del_old_datadir(self, filename): cmd = f"sed -i '/^dataDir/d' {filename}" + if platform.system().lower() == 'darwin': + cmd = f"sed -i '' '/^dataDir/d' {filename}" if os.system(cmd) != 0: tdLog.exit(cmd) From 367552b9146d8d8053baea29d44d24a6480bc940 Mon Sep 17 00:00:00 2001 From: Liu Jicong Date: Thu, 15 Sep 2022 10:08:48 +0800 Subject: [PATCH 098/138] fix delete --- source/dnode/vnode/src/tq/tq.c | 2 +- source/libs/executor/src/dataDeleter.c | 38 ++++++++++++++++---------- 2 files changed, 25 insertions(+), 15 deletions(-) diff --git a/source/dnode/vnode/src/tq/tq.c b/source/dnode/vnode/src/tq/tq.c index f9c2757c37..c8841e5e16 100644 --- a/source/dnode/vnode/src/tq/tq.c +++ b/source/dnode/vnode/src/tq/tq.c @@ -832,7 +832,7 @@ int32_t tqProcessDelReq(STQ* pTq, void* pReq, int32_t len, int64_t ver) { tDecoderClear(pCoder); int32_t sz = taosArrayGetSize(pRes->uidList); - if (sz == 0) { + if (sz == 0 || pRes->affectedRows == 0) { taosArrayDestroy(pRes->uidList); return 0; } diff --git a/source/libs/executor/src/dataDeleter.c b/source/libs/executor/src/dataDeleter.c index 40198615ea..55a1a1fdb9 100644 --- a/source/libs/executor/src/dataDeleter.c +++ b/source/libs/executor/src/dataDeleter.c @@ -79,25 +79,33 @@ static void toDataCacheEntry(SDataDeleterHandle* pHandle, const SInputData* pInp pEntry->dataLen = sizeof(SDeleterRes); ASSERT(1 == pEntry->numOfRows); - ASSERT(1 == pEntry->numOfCols); + ASSERT(3 == pEntry->numOfCols); pBuf->useSize = sizeof(SDataCacheEntry); SColumnInfoData* pColRes = (SColumnInfoData*)taosArrayGet(pInput->pData->pDataBlock, 0); + SColumnInfoData* pColSKey = (SColumnInfoData*)taosArrayGet(pInput->pData->pDataBlock, 1); + SColumnInfoData* pColEKey = (SColumnInfoData*)taosArrayGet(pInput->pData->pDataBlock, 2); SDeleterRes* pRes = (SDeleterRes*)pEntry->data; pRes->suid = pHandle->pParam->suid; pRes->uidList = pHandle->pParam->pUidList; - pRes->skey = pHandle->pDeleter->deleteTimeRange.skey; - pRes->ekey = pHandle->pDeleter->deleteTimeRange.ekey; strcpy(pRes->tableName, pHandle->pDeleter->tableFName); strcpy(pRes->tsColName, pHandle->pDeleter->tsColName); pRes->affectedRows = *(int64_t*)pColRes->pData; + if (pRes->affectedRows) { + pRes->skey = *(int64_t*)pColSKey->pData; + pRes->ekey = *(int64_t*)pColEKey->pData; + ASSERT(pRes->skey <= pRes->ekey); + } else { + pRes->skey = pHandle->pDeleter->deleteTimeRange.skey; + pRes->ekey = pHandle->pDeleter->deleteTimeRange.ekey; + } pBuf->useSize += pEntry->dataLen; - - atomic_add_fetch_64(&pHandle->cachedSize, pEntry->dataLen); - atomic_add_fetch_64(&gDataSinkStat.cachedSize, pEntry->dataLen); + + atomic_add_fetch_64(&pHandle->cachedSize, pEntry->dataLen); + atomic_add_fetch_64(&gDataSinkStat.cachedSize, pEntry->dataLen); } static bool allocBuf(SDataDeleterHandle* pDeleter, const SInputData* pInput, SDataDeleterBuf* pBuf) { @@ -172,7 +180,8 @@ static void getDataLength(SDataSinkHandle* pHandle, int64_t* pLen, bool* pQueryE SDataCacheEntry* pEntry = (SDataCacheEntry*)pDeleter->nextOutput.pData; *pLen = pEntry->dataLen; *pQueryEnd = pDeleter->queryEnd; - qDebug("got data len %" PRId64 ", row num %d in sink", *pLen, ((SDataCacheEntry*)(pDeleter->nextOutput.pData))->numOfRows); + qDebug("got data len %" PRId64 ", row num %d in sink", *pLen, + ((SDataCacheEntry*)(pDeleter->nextOutput.pData))->numOfRows); } static int32_t getDataBlock(SDataSinkHandle* pHandle, SOutputData* pOutput) { @@ -186,14 +195,14 @@ static int32_t getDataBlock(SDataSinkHandle* pHandle, SOutputData* pOutput) { return TSDB_CODE_SUCCESS; } SDataCacheEntry* pEntry = (SDataCacheEntry*)(pDeleter->nextOutput.pData); - memcpy(pOutput->pData, pEntry->data, pEntry->dataLen); + memcpy(pOutput->pData, pEntry->data, pEntry->dataLen); pDeleter->pParam->pUidList = NULL; pOutput->numOfRows = pEntry->numOfRows; pOutput->numOfCols = pEntry->numOfCols; pOutput->compressed = pEntry->compressed; - atomic_sub_fetch_64(&pDeleter->cachedSize, pEntry->dataLen); - atomic_sub_fetch_64(&gDataSinkStat.cachedSize, pEntry->dataLen); + atomic_sub_fetch_64(&pDeleter->cachedSize, pEntry->dataLen); + atomic_sub_fetch_64(&gDataSinkStat.cachedSize, pEntry->dataLen); taosMemoryFreeClear(pDeleter->nextOutput.pData); // todo persistent pOutput->bufStatus = updateStatus(pDeleter); @@ -202,7 +211,7 @@ static int32_t getDataBlock(SDataSinkHandle* pHandle, SOutputData* pOutput) { pOutput->useconds = pDeleter->useconds; pOutput->precision = pDeleter->pSchema->precision; taosThreadMutexUnlock(&pDeleter->mutex); - + return TSDB_CODE_SUCCESS; } @@ -211,7 +220,7 @@ static int32_t destroyDataSinker(SDataSinkHandle* pHandle) { atomic_sub_fetch_64(&gDataSinkStat.cachedSize, pDeleter->cachedSize); taosMemoryFreeClear(pDeleter->nextOutput.pData); taosArrayDestroy(pDeleter->pParam->pUidList); - taosMemoryFree(pDeleter->pParam); + taosMemoryFree(pDeleter->pParam); while (!taosQueueEmpty(pDeleter->pDataBlocks)) { SDataDeleterBuf* pBuf = NULL; taosReadQitem(pDeleter->pDataBlocks, (void**)&pBuf); @@ -230,14 +239,15 @@ static int32_t getCacheSize(struct SDataSinkHandle* pHandle, uint64_t* size) { return TSDB_CODE_SUCCESS; } -int32_t createDataDeleter(SDataSinkManager* pManager, const SDataSinkNode* pDataSink, DataSinkHandle* pHandle, void *pParam) { +int32_t createDataDeleter(SDataSinkManager* pManager, const SDataSinkNode* pDataSink, DataSinkHandle* pHandle, + void* pParam) { SDataDeleterHandle* deleter = taosMemoryCalloc(1, sizeof(SDataDeleterHandle)); if (NULL == deleter) { terrno = TSDB_CODE_QRY_OUT_OF_MEMORY; return TSDB_CODE_QRY_OUT_OF_MEMORY; } - SDataDeleterNode* pDeleterNode = (SDataDeleterNode *)pDataSink; + SDataDeleterNode* pDeleterNode = (SDataDeleterNode*)pDataSink; deleter->sink.fPut = putDataBlock; deleter->sink.fEndPut = endPut; deleter->sink.fGetLen = getDataLength; From 18924f9a7dac22fc178e0b8063a6dab653607a09 Mon Sep 17 00:00:00 2001 From: Haojun Liao Date: Thu, 15 Sep 2022 10:26:45 +0800 Subject: [PATCH 099/138] refactor(query): do some internal refactor. --- source/dnode/vnode/src/tsdb/tsdbRead.c | 160 +------------------------ 1 file changed, 4 insertions(+), 156 deletions(-) diff --git a/source/dnode/vnode/src/tsdb/tsdbRead.c b/source/dnode/vnode/src/tsdb/tsdbRead.c index 60d967681b..eafc5b3213 100644 --- a/source/dnode/vnode/src/tsdb/tsdbRead.c +++ b/source/dnode/vnode/src/tsdb/tsdbRead.c @@ -1362,15 +1362,10 @@ static void getBlockToLoadInfo(SDataBlockToLoadInfo* pInfo, SFileDataBlockInfo* pInfo->hasDupTs = (pBlock->nSubBlock == 1) ? pBlock->hasDup : true; pInfo->overlapWithDelInfo = overlapWithDelSkyline(pScanInfo, pBlock, pReader->order); - // todo here we need to each key in the last files to identify if it is really overlapped with last block - // todo - bool overlapWithlastBlock = false; -#if 0 - if (taosArrayGetSize(pLastBlockReader->pSstBlk) > 0 && (pLastBlockReader->currentBlockIndex != -1)) { - SSttBlk* pSstBlk = taosArrayGet(pLastBlockReader->pSstBlk, pLastBlockReader->currentBlockIndex); - overlapWithlastBlock = !(pBlock->maxKey.ts < pSstBlk->minKey || pBlock->minKey.ts > pSstBlk->maxKey); + if (hasDataInLastBlock(pLastBlockReader)) { + int64_t tsLast = getCurrentKeyInLastBlock(pLastBlockReader); + pInfo->overlapWithLastBlock = !(pBlock->maxKey.ts < tsLast || pBlock->minKey.ts > tsLast); } -#endif pInfo->moreThanCapcity = pBlock->nRow > pReader->capacity; pInfo->partiallyRequired = dataBlockPartiallyRequired(&pReader->window, &pReader->verRange, pBlock); @@ -1896,151 +1891,6 @@ static int32_t doMergeMultiLevelRows(STsdbReader* pReader, STableBlockScanInfo* return code; } -#if 0 -static int32_t doMergeThreeLevelRows(STsdbReader* pReader, STableBlockScanInfo* pBlockScanInfo, SBlockData* pBlockData) { - SRowMerger merge = {0}; - STSRow* pTSRow = NULL; - - SFileBlockDumpInfo* pDumpInfo = &pReader->status.fBlockDumpInfo; - SArray* pDelList = pBlockScanInfo->delSkyline; - - TSDBROW* pRow = getValidMemRow(&pBlockScanInfo->iter, pDelList, pReader); - TSDBROW* piRow = getValidMemRow(&pBlockScanInfo->iiter, pDelList, pReader); - ASSERT(pRow != NULL && piRow != NULL); - - int64_t key = pBlockData->aTSKEY[pDumpInfo->rowIndex]; - bool freeTSRow = false; - - uint64_t uid = pBlockScanInfo->uid; - - TSDBKEY k = TSDBROW_KEY(pRow); - TSDBKEY ik = TSDBROW_KEY(piRow); - if (ASCENDING_TRAVERSE(pReader->order)) { - // [1&2] key <= [k.ts && ik.ts] - if (key <= k.ts && key <= ik.ts) { - TSDBROW fRow = tsdbRowFromBlockData(pBlockData, pDumpInfo->rowIndex); - tRowMergerInit(&merge, &fRow, pReader->pSchema); - - doMergeRowsInFileBlocks(pBlockData, pBlockScanInfo, pReader, &merge); - - if (ik.ts == key) { - tRowMerge(&merge, piRow); - doMergeRowsInBuf(&pBlockScanInfo->iiter, uid, key, pBlockScanInfo->delSkyline, &merge, pReader); - } - - if (k.ts == key) { - tRowMerge(&merge, pRow); - doMergeRowsInBuf(&pBlockScanInfo->iter, uid, key, pBlockScanInfo->delSkyline, &merge, pReader); - } - - tRowMergerGetRow(&merge, &pTSRow); - doAppendRowFromTSRow(pReader->pResBlock, pReader, pTSRow, uid); - return TSDB_CODE_SUCCESS; - } else { // key > ik.ts || key > k.ts - ASSERT(key != ik.ts); - - // [3] ik.ts < key <= k.ts - // [4] ik.ts < k.ts <= key - if (ik.ts < k.ts) { - doMergeMemTableMultiRows(piRow, uid, &pBlockScanInfo->iiter, pDelList, &pTSRow, pReader, &freeTSRow); - doAppendRowFromTSRow(pReader->pResBlock, pReader, pTSRow, uid); - if (freeTSRow) { - taosMemoryFree(pTSRow); - } - return TSDB_CODE_SUCCESS; - } - - // [5] k.ts < key <= ik.ts - // [6] k.ts < ik.ts <= key - if (k.ts < ik.ts) { - doMergeMemTableMultiRows(pRow, uid, &pBlockScanInfo->iter, pDelList, &pTSRow, pReader, &freeTSRow); - doAppendRowFromTSRow(pReader->pResBlock, pReader, pTSRow, uid); - if (freeTSRow) { - taosMemoryFree(pTSRow); - } - return TSDB_CODE_SUCCESS; - } - - // [7] k.ts == ik.ts < key - if (k.ts == ik.ts) { - ASSERT(key > ik.ts && key > k.ts); - - doMergeMemIMemRows(pRow, piRow, pBlockScanInfo, pReader, &pTSRow); - doAppendRowFromTSRow(pReader->pResBlock, pReader, pTSRow, uid); - taosMemoryFree(pTSRow); - return TSDB_CODE_SUCCESS; - } - } - } else { // descending order scan - // [1/2] k.ts >= ik.ts && k.ts >= key - if (k.ts >= ik.ts && k.ts >= key) { - STSchema* pSchema = doGetSchemaForTSRow(TSDBROW_SVERSION(pRow), pReader, pBlockScanInfo->uid); - - tRowMergerInit(&merge, pRow, pSchema); - doMergeRowsInBuf(&pBlockScanInfo->iter, uid, key, pBlockScanInfo->delSkyline, &merge, pReader); - - if (ik.ts == k.ts) { - tRowMerge(&merge, piRow); - doMergeRowsInBuf(&pBlockScanInfo->iiter, uid, key, pBlockScanInfo->delSkyline, &merge, pReader); - } - - if (k.ts == key) { - TSDBROW fRow = tsdbRowFromBlockData(pBlockData, pDumpInfo->rowIndex); - tRowMerge(&merge, &fRow); - doMergeRowsInFileBlocks(pBlockData, pBlockScanInfo, pReader, &merge); - } - - tRowMergerGetRow(&merge, &pTSRow); - doAppendRowFromTSRow(pReader->pResBlock, pReader, pTSRow, uid); - return TSDB_CODE_SUCCESS; - } else { - ASSERT(ik.ts != k.ts); // this case has been included in the previous if branch - - // [3] ik.ts > k.ts >= Key - // [4] ik.ts > key >= k.ts - if (ik.ts > key) { - doMergeMemTableMultiRows(piRow, uid, &pBlockScanInfo->iiter, pDelList, &pTSRow, pReader, &freeTSRow); - doAppendRowFromTSRow(pReader->pResBlock, pReader, pTSRow, uid); - if (freeTSRow) { - taosMemoryFree(pTSRow); - } - return TSDB_CODE_SUCCESS; - } - - // [5] key > ik.ts > k.ts - // [6] key > k.ts > ik.ts - if (key > ik.ts) { - TSDBROW fRow = tsdbRowFromBlockData(pBlockData, pDumpInfo->rowIndex); - tRowMergerInit(&merge, &fRow, pReader->pSchema); - - doMergeRowsInFileBlocks(pBlockData, pBlockScanInfo, pReader, &merge); - tRowMergerGetRow(&merge, &pTSRow); - doAppendRowFromTSRow(pReader->pResBlock, pReader, pTSRow, uid); - taosMemoryFree(pTSRow); - return TSDB_CODE_SUCCESS; - } - - //[7] key = ik.ts > k.ts - if (key == ik.ts) { - doMergeMemTableMultiRows(piRow, uid, &pBlockScanInfo->iiter, pDelList, &pTSRow, pReader, &freeTSRow); - - TSDBROW fRow = tsdbRowFromBlockData(pBlockData, pDumpInfo->rowIndex); - tRowMerge(&merge, &fRow); - doMergeRowsInFileBlocks(pBlockData, pBlockScanInfo, pReader, &merge); - tRowMergerGetRow(&merge, &pTSRow); - doAppendRowFromTSRow(pReader->pResBlock, pReader, pTSRow, uid); - - taosMemoryFree(pTSRow); - return TSDB_CODE_SUCCESS; - } - } - } - - ASSERT(0); - return -1; -} -#endif - static int32_t initMemDataIterator(STableBlockScanInfo* pBlockScanInfo, STsdbReader* pReader) { if (pBlockScanInfo->iterInit) { return TSDB_CODE_SUCCESS; @@ -2257,9 +2107,7 @@ static int32_t buildComposedDataBlock(STsdbReader* pReader) { SBlockData* pBlockData = &pReader->status.fileBlockData; int32_t step = ASCENDING_TRAVERSE(pReader->order) ? 1 : -1; - while (1) { - // todo check the validate of row in file block bool hasBlockData = false; { while (pBlockData->nRow > 0) { // find the first qualified row in data block @@ -2620,7 +2468,7 @@ static int32_t doBuildDataBlock(STsdbReader* pReader) { code = buildComposedDataBlock(pReader); } else if (bufferDataInFileBlockGap(pReader->order, keyInBuf, pBlock)) { // data in memory that are earlier than current file block - // todo rows in buffer should be less than the file block in asc, greater than file block in desc + // rows in buffer should be less than the file block in asc, greater than file block in desc int64_t endKey = (ASCENDING_TRAVERSE(pReader->order)) ? pBlock->minKey.ts : pBlock->maxKey.ts; code = buildDataBlockFromBuf(pReader, pScanInfo, endKey); } else { From 1091302e8d948737c101d1cd1e0d4e2062d23ab3 Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Thu, 15 Sep 2022 10:30:17 +0800 Subject: [PATCH 100/138] fix: fix mem leak --- source/client/src/clientHb.c | 1 + 1 file changed, 1 insertion(+) diff --git a/source/client/src/clientHb.c b/source/client/src/clientHb.c index cf968937ac..9b85d403be 100644 --- a/source/client/src/clientHb.c +++ b/source/client/src/clientHb.c @@ -855,6 +855,7 @@ void appHbMgrCleanup(void) { int sz = taosArrayGetSize(clientHbMgr.appHbMgrs); for (int i = 0; i < sz; i++) { SAppHbMgr *pTarget = taosArrayGetP(clientHbMgr.appHbMgrs, i); + if (pTarget == NULL) continue; hbFreeAppHbMgr(pTarget); } } From cdd46c532e533e5a1de0d461b6ba7e39e0a5efb6 Mon Sep 17 00:00:00 2001 From: Kyno Date: Thu, 15 Sep 2022 10:35:57 +0800 Subject: [PATCH 101/138] fix: spelling error. --- docs/zh/12-taos-sql/06-select.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/zh/12-taos-sql/06-select.md b/docs/zh/12-taos-sql/06-select.md index b0a7d88efe..0d38cb0635 100644 --- a/docs/zh/12-taos-sql/06-select.md +++ b/docs/zh/12-taos-sql/06-select.md @@ -104,7 +104,7 @@ SELECT location, groupid, current FROM d1001 LIMIT 2; ### 结果去重 -`DISINTCT` 关键字可以对结果集中的一列或多列进行去重，去除的列既可以是标签列也可以是数据列。 +`DISTINCT` 关键字可以对结果集中的一列或多列进行去重，去除的列既可以是标签列也可以是数据列。 对标签列去重： From 091c8ecfcd07f716873ecbcad3d5970c438cdfef Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Thu, 15 Sep 2022 11:30:27 +0800 Subject: [PATCH 102/138] enh(tsc): handle deadlock --- source/client/src/clientHb.c | 1 - 1 file changed, 1 deletion(-) diff --git a/source/client/src/clientHb.c b/source/client/src/clientHb.c index 9b85d403be..1cf53881a8 100644 --- a/source/client/src/clientHb.c +++ b/source/client/src/clientHb.c @@ -873,7 +873,6 @@ int hbMgrInit() { TdThreadMutexAttr attr = {0}; taosThreadMutexAttrSetType(&attr, PTHREAD_MUTEX_RECURSIVE); - int ret = taosThreadMutexAttrInit(&attr); assert(ret == 0); From 1530d75f9fa4a9fdb0c8a554de8938eb8f6e08f8 Mon Sep 17 00:00:00 2001 From: huolibo Date: Thu, 15 Sep 2022 13:11:34 +0800 Subject: [PATCH 103/138] Update 14-taosKeeper.md --- docs/zh/14-reference/14-taosKeeper.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/zh/14-reference/14-taosKeeper.md b/docs/zh/14-reference/14-taosKeeper.md index ae0a496f03..7780dc2fe9 100644 --- a/docs/zh/14-reference/14-taosKeeper.md +++ b/docs/zh/14-reference/14-taosKeeper.md @@ -79,7 +79,7 @@ password = "taosdata" # 需要被监控的 taosAdapter [taosAdapter] -address = ["127.0.0.1:6041","192.168.1.95:6041"] +address = ["127.0.0.1:6041"] [metrics] # 监控指标前缀 @@ -92,7 +92,7 @@ cluster = "production" database = "log" # 指定需要监控的普通表 -tables = ["normal_table"] +tables = [] ``` ### 获取监控指标 @@ -141,4 +141,4 @@ taos_cluster_info_dnodes_total{cluster_id="5981392874047724755"} 1 # HELP taos_cluster_info_first_ep # TYPE taos_cluster_info_first_ep gauge taos_cluster_info_first_ep{cluster_id="5981392874047724755",value="hlb:6030"} 1 -``` \ No newline at end of file +``` From 5003725d7ea5c6f1338eed2479449989275ba0be Mon Sep 17 00:00:00 2001 From: Shuduo Sang Date: Thu, 15 Sep 2022 14:37:40 +0800 Subject: [PATCH 104/138] feat: update taostools e7270c9 for3.0 (#16858) * feat: update taos-tools 9f4c01e for 3.0 * feat: update taos-tools e7270c9 for 3.0 --- cmake/taostools_CMakeLists.txt.in | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/taostools_CMakeLists.txt.in b/cmake/taostools_CMakeLists.txt.in index 0f7a450920..6fb2a69847 100644 --- a/cmake/taostools_CMakeLists.txt.in +++ b/cmake/taostools_CMakeLists.txt.in @@ -2,7 +2,7 @@ # taos-tools ExternalProject_Add(taos-tools GIT_REPOSITORY https://github.com/taosdata/taos-tools.git - GIT_TAG 3588b3d + GIT_TAG e7270c9 SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools" BINARY_DIR "" #BUILD_IN_SOURCE TRUE From 79b0d1fcbdb6735f52de0dc1fb037a5df17e4e3b Mon Sep 17 00:00:00 2001 From: Haojun Liao Date: Thu, 15 Sep 2022 15:02:23 +0800 Subject: [PATCH 105/138] fix(query): fix memory leak. --- source/libs/executor/src/executor.c | 3 ++- source/libs/qworker/src/qworker.c | 20 +++++++++++++------- 2 files changed, 15 insertions(+), 8 deletions(-) diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c index 95415e1113..ea2180124a 100644 --- a/source/libs/executor/src/executor.c +++ b/source/libs/executor/src/executor.c @@ -480,6 +480,7 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds) { if (ret != TSDB_CODE_SUCCESS) { pTaskInfo->code = ret; cleanUpUdfs(); + qDebug("%s task abort due to error/cancel occurs, code:%s", GET_TASKID(pTaskInfo), tstrerror(pTaskInfo->code)); atomic_store_64(&pTaskInfo->owner, 0); @@ -512,8 +513,8 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds) { } cleanUpUdfs(); - uint64_t total = pTaskInfo->pRoot->resultInfo.totalRows; + uint64_t total = pTaskInfo->pRoot->resultInfo.totalRows; qDebug("%s task suspended, %d rows in %d blocks returned, total:%" PRId64 " rows, in sinkNode:%d, elapsed:%.2f ms", GET_TASKID(pTaskInfo), current, (int32_t)taosArrayGetSize(pResList), total, 0, el / 1000.0); diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c index 61c38f59db..fbda8ee37f 100644 --- a/source/libs/qworker/src/qworker.c +++ b/source/libs/qworker/src/qworker.c @@ -9,6 +9,7 @@ #include "tcommon.h" #include "tmsg.h" #include "tname.h" +#include "tdatablock.h" SQWorkerMgmt gQwMgmt = { .lock = 0, @@ -16,6 +17,11 @@ SQWorkerMgmt gQwMgmt = { .qwNum = 0, }; +static void freeBlock(void* param) { + SSDataBlock* pBlock = *(SSDataBlock**)param; + blockDataDestroy(pBlock); +} + int32_t qwProcessHbLinkBroken(SQWorker *mgmt, SQWMsg *qwMsg, SSchedulerHbReq *req) { int32_t code = 0; SSchedulerHbRsp rsp = {0}; @@ -71,7 +77,7 @@ int32_t qwHandleTaskComplete(QW_FPARAMS_DEF, SQWTaskCtx *ctx) { return TSDB_CODE_SUCCESS; } - +\ int32_t qwExecTask(QW_FPARAMS_DEF, SQWTaskCtx *ctx, bool *queryStop) { int32_t code = 0; bool qcontinue = true; @@ -88,6 +94,7 @@ int32_t qwExecTask(QW_FPARAMS_DEF, SQWTaskCtx *ctx, bool *queryStop) { // if *taskHandle is NULL, it's killed right now if (taskHandle) { qwDbgSimulateSleep(); + code = qExecTaskOpt(taskHandle, pResList, &useconds); if (code) { if (code != TSDB_CODE_OPS_NOT_SUPPORT) { @@ -150,8 +157,7 @@ int32_t qwExecTask(QW_FPARAMS_DEF, SQWTaskCtx *ctx, bool *queryStop) { } _return: - - taosArrayDestroy(pResList); + taosArrayDestroyEx(pResList, freeBlock); QW_RET(code); } @@ -915,13 +921,13 @@ void qwProcessHbTimerEvent(void *param, void *tmrId) { void *pIter = taosHashIterate(mgmt->schHash, NULL); while (pIter) { - SQWSchStatus *sch = (SQWSchStatus *)pIter; - if (NULL == sch->hbConnInfo.handle) { + SQWSchStatus *sch1 = (SQWSchStatus *)pIter; + if (NULL == sch1->hbConnInfo.handle) { uint64_t *sId = taosHashGetKey(pIter, NULL); QW_TLOG("cancel send hb to sch %" PRIx64 " cause of no connection handle", *sId); - if (sch->hbBrokenTs > 0 && ((currentMs - sch->hbBrokenTs) > QW_SCH_TIMEOUT_MSEC) && - taosHashGetSize(sch->tasksHash) <= 0) { + if (sch1->hbBrokenTs > 0 && ((currentMs - sch1->hbBrokenTs) > QW_SCH_TIMEOUT_MSEC) && + taosHashGetSize(sch1->tasksHash) <= 0) { taosArrayPush(pExpiredSch, sId); } From 49f3e3c2c55b785c093adb2da51a02ecdc6ef717 Mon Sep 17 00:00:00 2001 From: Yiqing Liu Date: Thu, 15 Sep 2022 15:26:19 +0800 Subject: [PATCH 106/138] Update 07-tmq.mdx --- docs/zh/07-develop/07-tmq.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/zh/07-develop/07-tmq.mdx b/docs/zh/07-develop/07-tmq.mdx index 2f5c13d9b0..d9a35ab4eb 100644 --- a/docs/zh/07-develop/07-tmq.mdx +++ b/docs/zh/07-develop/07-tmq.mdx @@ -218,7 +218,7 @@ void Close() ```sql DROP DATABASE IF EXISTS tmqdb; CREATE DATABASE tmqdb; -CREATE TABLE tmqdb.stb (ts TIMESTAMP, c1 INT, c2 FLOAT, c3 VARCHAR(16) TAGS(t1 INT, t3 VARCHAR(16)); +CREATE TABLE tmqdb.stb (ts TIMESTAMP, c1 INT, c2 FLOAT, c3 VARCHAR(16)) TAGS(t1 INT, t3 VARCHAR(16)); CREATE TABLE tmqdb.ctb0 USING tmqdb.stb TAGS(0, "subtable0"); CREATE TABLE tmqdb.ctb1 USING tmqdb.stb TAGS(1, "subtable1"); INSERT INTO tmqdb.ctb0 VALUES(now, 0, 0, 'a0')(now+1s, 0, 0, 'a00'); From 4ff617ae357499563f4559b0402091daaa914111 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Thu, 15 Sep 2022 15:34:29 +0800 Subject: [PATCH 107/138] docs: remove wrong description --- docs/zh/10-deployment/01-deploy.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/zh/10-deployment/01-deploy.md b/docs/zh/10-deployment/01-deploy.md index 03b4ce30f9..5857b9acd3 100644 --- a/docs/zh/10-deployment/01-deploy.md +++ b/docs/zh/10-deployment/01-deploy.md @@ -168,7 +168,7 @@ Query OK, 8 row(s) in set (0.001154s) ## 删除数据节点 -先停止要删除的数据节点的 taosd 进程，然后启动 CLI 程序 taos，执行： +然后启动 CLI 程序 taos，执行： ```sql DROP DNODE "fqdn:port"; From df8d708255012b24ed6bdefe29f79747341a839f Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Thu, 15 Sep 2022 15:50:47 +0800 Subject: [PATCH 108/138] docs: remove wrong description --- docs/zh/10-deployment/01-deploy.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/zh/10-deployment/01-deploy.md b/docs/zh/10-deployment/01-deploy.md index 5857b9acd3..eecb86ce41 100644 --- a/docs/zh/10-deployment/01-deploy.md +++ b/docs/zh/10-deployment/01-deploy.md @@ -168,7 +168,7 @@ Query OK, 8 row(s) in set (0.001154s) ## 删除数据节点 -然后启动 CLI 程序 taos，执行： +启动 CLI 程序 taos，执行： ```sql DROP DNODE "fqdn:port"; From 5ba41111b4466a04f4a5edf898382dc17331bc93 Mon Sep 17 00:00:00 2001 From: Haojun Liao Date: Thu, 15 Sep 2022 16:17:39 +0800 Subject: [PATCH 109/138] refactor: add some logs. --- source/dnode/vnode/src/inc/tsdb.h | 4 ++-- source/dnode/vnode/src/tsdb/tsdbCache.c | 4 ++-- source/dnode/vnode/src/tsdb/tsdbRead.c | 14 +++++++------- 3 files changed, 11 insertions(+), 11 deletions(-) diff --git a/source/dnode/vnode/src/inc/tsdb.h b/source/dnode/vnode/src/inc/tsdb.h index a836fa2bc5..4264a3232b 100644 --- a/source/dnode/vnode/src/inc/tsdb.h +++ b/source/dnode/vnode/src/inc/tsdb.h @@ -299,8 +299,8 @@ int32_t tsdbDelFReaderClose(SDelFReader **ppReader); int32_t tsdbReadDelData(SDelFReader *pReader, SDelIdx *pDelIdx, SArray *aDelData); int32_t tsdbReadDelIdx(SDelFReader *pReader, SArray *aDelIdx); // tsdbRead.c ============================================================================================== -int32_t tsdbTakeReadSnap(STsdb *pTsdb, STsdbReadSnap **ppSnap); -void tsdbUntakeReadSnap(STsdb *pTsdb, STsdbReadSnap *pSnap); +int32_t tsdbTakeReadSnap(STsdb *pTsdb, STsdbReadSnap **ppSnap, const char* id); +void tsdbUntakeReadSnap(STsdb *pTsdb, STsdbReadSnap *pSnap, const char* id); // tsdbMerge.c ============================================================================================== int32_t tsdbMerge(STsdb *pTsdb); diff --git a/source/dnode/vnode/src/tsdb/tsdbCache.c b/source/dnode/vnode/src/tsdb/tsdbCache.c index 8da783a5bd..8452d14c86 100644 --- a/source/dnode/vnode/src/tsdb/tsdbCache.c +++ b/source/dnode/vnode/src/tsdb/tsdbCache.c @@ -847,7 +847,7 @@ static int32_t nextRowIterOpen(CacheNextRowIter *pIter, tb_uid_t uid, STsdb *pTs tb_uid_t suid = getTableSuidByUid(uid, pTsdb); - tsdbTakeReadSnap(pTsdb, &pIter->pReadSnap); + tsdbTakeReadSnap(pTsdb, &pIter->pReadSnap, NULL); STbData *pMem = NULL; if (pIter->pReadSnap->pMem) { @@ -941,7 +941,7 @@ static int32_t nextRowIterClose(CacheNextRowIter *pIter) { taosArrayDestroy(pIter->pSkyline); } - tsdbUntakeReadSnap(pIter->pTsdb, pIter->pReadSnap); + tsdbUntakeReadSnap(pIter->pTsdb, pIter->pReadSnap, NULL); _err: return code; diff --git a/source/dnode/vnode/src/tsdb/tsdbRead.c b/source/dnode/vnode/src/tsdb/tsdbRead.c index eafc5b3213..34737bb7fd 100644 --- a/source/dnode/vnode/src/tsdb/tsdbRead.c +++ b/source/dnode/vnode/src/tsdb/tsdbRead.c @@ -3360,7 +3360,7 @@ int32_t tsdbReaderOpen(SVnode* pVnode, SQueryTableDataCond* pCond, SArray* pTabl goto _err; } - code = tsdbTakeReadSnap(pReader->pTsdb, &pReader->pReadSnap); + code = tsdbTakeReadSnap(pReader->pTsdb, &pReader->pReadSnap, pReader->idStr); if (code != TSDB_CODE_SUCCESS) { goto _err; } @@ -3384,7 +3384,7 @@ int32_t tsdbReaderOpen(SVnode* pVnode, SQueryTableDataCond* pCond, SArray* pTabl STsdbReader* pPrevReader = pReader->innerReader[0]; SDataBlockIter* pBlockIter = &pPrevReader->status.blockIter; - code = tsdbTakeReadSnap(pPrevReader->pTsdb, &pPrevReader->pReadSnap); + code = tsdbTakeReadSnap(pPrevReader->pTsdb, &pPrevReader->pReadSnap, pReader->idStr); if (code != TSDB_CODE_SUCCESS) { goto _err; } @@ -3441,7 +3441,7 @@ void tsdbReaderClose(STsdbReader* pReader) { tsdbDataFReaderClose(&pReader->pFileReader); } - tsdbUntakeReadSnap(pReader->pTsdb, pReader->pReadSnap); + tsdbUntakeReadSnap(pReader->pTsdb, pReader->pReadSnap, pReader->idStr); taosMemoryFree(pReader->status.uidCheckInfo.tableUidList); SIOCostSummary* pCost = &pReader->cost; @@ -3863,7 +3863,7 @@ int32_t tsdbGetTableSchema(SVnode* pVnode, int64_t uid, STSchema** pSchema, int6 return TSDB_CODE_SUCCESS; } -int32_t tsdbTakeReadSnap(STsdb* pTsdb, STsdbReadSnap** ppSnap) { +int32_t tsdbTakeReadSnap(STsdb* pTsdb, STsdbReadSnap** ppSnap, const char* idStr) { int32_t code = 0; // alloc @@ -3906,12 +3906,12 @@ int32_t tsdbTakeReadSnap(STsdb* pTsdb, STsdbReadSnap** ppSnap) { goto _exit; } - tsdbTrace("vgId:%d, take read snapshot", TD_VID(pTsdb->pVnode)); + tsdbTrace("vgId:%d, take read snapshot, %s", TD_VID(pTsdb->pVnode), idStr); _exit: return code; } -void tsdbUntakeReadSnap(STsdb* pTsdb, STsdbReadSnap* pSnap) { +void tsdbUntakeReadSnap(STsdb* pTsdb, STsdbReadSnap* pSnap, const char* idStr) { if (pSnap) { if (pSnap->pMem) { tsdbUnrefMemTable(pSnap->pMem); @@ -3925,5 +3925,5 @@ void tsdbUntakeReadSnap(STsdb* pTsdb, STsdbReadSnap* pSnap) { taosMemoryFree(pSnap); } - tsdbTrace("vgId:%d, untake read snapshot", TD_VID(pTsdb->pVnode)); + tsdbTrace("vgId:%d, untake read snapshot, %s", TD_VID(pTsdb->pVnode), idStr); } \ No newline at end of file From 8e62ebab64e87eaeef1a54a52326652c801ff41c Mon Sep 17 00:00:00 2001 From: Haojun Liao Date: Thu, 15 Sep 2022 16:18:44 +0800 Subject: [PATCH 110/138] other: remove a typo. --- source/libs/qworker/src/qworker.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c index fbda8ee37f..4dcc06b470 100644 --- a/source/libs/qworker/src/qworker.c +++ b/source/libs/qworker/src/qworker.c @@ -77,7 +77,7 @@ int32_t qwHandleTaskComplete(QW_FPARAMS_DEF, SQWTaskCtx *ctx) { return TSDB_CODE_SUCCESS; } -\ + int32_t qwExecTask(QW_FPARAMS_DEF, SQWTaskCtx *ctx, bool *queryStop) { int32_t code = 0; bool qcontinue = true; From 83b40713bd786ec9907261e0fa5f60efaf3a64c2 Mon Sep 17 00:00:00 2001 From: gccgdb1234 Date: Thu, 15 Sep 2022 16:33:41 +0800 Subject: [PATCH 111/138] doc: tdinsight english version change --- .../15146-tdengine-monitor-dashboard.json | 8 +- .../assets/TDinsight-1-cluster-status.webp | Bin 27958 -> 19366 bytes .../assets/TDinsight-2-dnodes.webp | Bin 13838 -> 5582 bytes .../assets/TDinsight-3-mnodes.webp | Bin 8256 -> 7056 bytes .../assets/TDinsight-4-requests.webp | Bin 96252 -> 16572 bytes .../assets/TDinsight-5-database.webp | Bin 7674 -> 7244 bytes .../assets/TDinsight-8-taosadapter.webp | Bin 16890 -> 10766 bytes .../assets/howto-add-datasource.webp | Bin 11140 -> 15976 bytes .../07-tdinsight/assets/import_dashboard.webp | Bin 16692 -> 6342 bytes .../assets/import_dashboard_view.webp | Bin 0 -> 5452 bytes .../assets/select_dashboard_db.webp | Bin 0 -> 23862 bytes .../assets/tdengine-grafana-7.x.json | 8 +- docs/en/14-reference/07-tdinsight/index.md | 93 +++++------------- 13 files changed, 35 insertions(+), 74 deletions(-) create mode 100644 docs/en/14-reference/07-tdinsight/assets/import_dashboard_view.webp create mode 100644 docs/en/14-reference/07-tdinsight/assets/select_dashboard_db.webp diff --git a/docs/en/14-reference/07-tdinsight/assets/15146-tdengine-monitor-dashboard.json b/docs/en/14-reference/07-tdinsight/assets/15146-tdengine-monitor-dashboard.json index 54dc1062d6..f651983528 100644 --- a/docs/en/14-reference/07-tdinsight/assets/15146-tdengine-monitor-dashboard.json +++ b/docs/en/14-reference/07-tdinsight/assets/15146-tdengine-monitor-dashboard.json @@ -211,7 +211,7 @@ ], "timeFrom": null, "timeShift": null, - "title": "Leader MNode", + "title": "Master MNode", "transformations": [ { "id": "filterByValue", @@ -221,7 +221,7 @@ "config": { "id": "regex", "options": { - "value": "leader" + "value": "master" } }, "fieldName": "role" @@ -300,7 +300,7 @@ ], "timeFrom": null, "timeShift": null, - "title": "Leader MNode Create Time", + "title": "Master MNode Create Time", "transformations": [ { "id": "filterByValue", @@ -310,7 +310,7 @@ "config": { "id": "regex", "options": { - "value": "leader" + "value": "master" } }, "fieldName": "role" diff --git a/docs/en/14-reference/07-tdinsight/assets/TDinsight-1-cluster-status.webp b/docs/en/14-reference/07-tdinsight/assets/TDinsight-1-cluster-status.webp index a78e18028a94c2f6a783b08d992a25c791527407..3bc0d960f1db45ee8d2adcee26de89334e681956 100644 GIT binary patch literal 19366 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

Wrk4l=@EjCcKKX8lu1N!^)`&CU zPIU7+o5~)%b9b-66QdF<{5in;EtANKlouQ>1SFRQM#?9qlZ`psSury-t|-IP+{cw# z>sFNCj4{Xua=*g~L)(yC0vcj6z&^D>7VR~4N&U64)&MRC9Yy(4o1=_hKu(~?sa%Zy# z%ue;i!PqVS6b;h90^jaKvtTEGTwlhoX4vB9M*t^`)LzMgIHyPe5dNfaf+)oQm~bA;{b*D@5n|B@tgyAB90M; z%{#m#^{vf@Nz@XyB^FapuzJj5s_lAIW#bNny|hWW+vH-NtAI|8D>lUr%ClP0bcHq# z_4HJOTJYuE7OSuc#>&9TtIsYTL|(*l^TN~8>_e`SLp}u@WM!7)D5=fRBU*f^*xu#} z@PVAFn7I$D>ixfr`_zj4gx7dEN4|W$Q9&!j_|$-G9_?$jQ0>$d`0Ks*k@Xr6!2kdN z0}LE1=kXBu{fUJ!GNk0msL@eoF(6^0G#mc)i$iSiYREL`ZOs2q_3oCO7UG*670$`|_mL3_Xe0000)Qr7eU literal 8256 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 literal 96252 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 T@2InULr)yonW*P~T*Utabt@^k literal 7674 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 H4gmZQX{eNy diff --git a/docs/en/14-reference/07-tdinsight/assets/TDinsight-8-taosadapter.webp b/docs/en/14-reference/07-tdinsight/assets/TDinsight-8-taosadapter.webp index 8666193f59497180574fd2786266e5baabbe9761..942130d4fabf7944c7add10acb3bb42ca7f51e0f 100644 GIT binary patch literal 10766 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 W;6L~e{)7MEKll&+ga6<^r6C44JBOD5 diff --git a/docs/en/14-reference/07-tdinsight/assets/import_dashboard.webp b/docs/en/14-reference/07-tdinsight/assets/import_dashboard.webp index fb7958f1b9fbd43c8f63136024842790e711c490..ae2a1e8e9b7b63a68d56dfcd2187eca614da9a3d 100644 GIT binary patch literal 6342 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 literal 16692 zcmZU3V{~spuXk;`J+*Dywr$%s|Fx}C+qP{Rr?%bG_C3$N_xbdGm_5nbYtQWbl9gm8 zQI--HrxgMM(hw6?R9EDbCHzM-_>DRN-9mB!k%~#HJ;U5EJP;{56UVz`@173^2a*6K z5tmeYBX~r}iu4Ztu*_^@@6ffk*j1^w^1lBRp(8B>$PAkzyiRcWe20Nak)9&}U7sB; ze^#vREFzXoe5g8KO=e$R8(C*Yl-M@fr!`JAPVgS><wH-xOsS``1xsJZoVZr z?GuRDBRI57?^NPBcGdo{!U|JK5JUn71GwfzBkw2$I-?B&@kAL$AVaT1yYpWw#<}n` zpx&xU<_%)8$yZ0Lb2|BX$+Y5R^@W9n)^wk|X^eE=jZz zD*4QTaFAFQMe09;lvoTUk&>89m{`_`h$xbDBAgX_i8d+hAD09N6D)~6h$ajpg^Ym` z2FH}0hB0J}k@RmlsA$Fs;!w0mNn+@j*BJ`}8HRQoZCLt!ds=mm68~X=1A?lbjE9RP z9fp~(oJcil3A1~G<+2_Bp`C@58UB_%4~8{`-4{C_{mqTaTZK_N;Pdd~ET=K|D)uft z8uM^05@S5F9or2%(T3eGKTeyPmuNX}0S|1XT=X41V_&;(rtx)i zPOAt`no?-cz=hbNkiURO(Z<#c#~_rzk_@x!oVK^z%U(NsZfF0RtIpe{G_gEpFZf#c z_r1%D{!j_EqPM1gkTEbJKRiYaBBU{YG%fVleQve3q%8ea8oZ$CxjpE4b(L#QJ5H=S zzURbkkR+ta6bmbal1>qYCZ*ewDkhzso;)&KlP$$G$wpt z4!k9~h!+(7Arnk8B~xdMsc+=0_vC#+!xFe9rj^;+ZEa9(E>0EUiAp-&mP(_l%DuL) znmgi6XP)BS(kfG%T|3CO?jR2`OxQ%xDpW`$47j5JMu|D=Bb7`#YONSR2t>xTZ6s;# z2A&u@q?y9{vD^w!_?h)pTcKg7@-_kynL5w6{UrF-FUXR@#l469l~MjDpUgl%dt2xx znk7giDjSs(iKC@9WBgCc1lof+;x=ydDdf+0Zm(Gv=`?=JG#Kq=>XS6$@+Vd`N^vmgxj_HP1kafM*4d}${haJDW z%zHquGfws`Z~DF4#6TfEukcV5s;jo|nA3rOnuqG(*$rqn?{;rA$9{g2z| z`lTp1w&QB%{9e*%tlnam-`i?-TO-NWzTRsOp=ZXkBStrY*n*XLOioxETXj1@0ji~@ z9Y~o&ReVH}MyC6v^8oJFxM2VO!r0Hm&m5oM(MTWp^X?mW2_-dRjIf+>Rp%xF$M~&B ziLUb#qh4iqJe7ZL6xRylhP@=LX7+VDY#-FPt48Ckxy@%{OIEu>iPrb9H=kI??}ADG z>k5AN9y*BR-oK=oHajXe7FyL2Z^lGM7$P>^D=(Qz5P_cCUmUBvG(b5ur%9ytQ+3`06 zxB&UhY_)uTdjSZgORji5@g+qNj8Fjd;JUl zPdaIb^=_NTiD>0rBrUHdou~xLTcdO`= zWHtUG!IZZ|UD-OwI)u9Sbw&<|-rom5W_K9>w{Lnq6hJ!<-4FF48{S0s+>sM5iky*- z^(hlSNjU6c`CqB{SATx?7&Eht5L4Q!0Pd`dklfnzG5&bMm*Q4~fq#psmZ^7C?A!yz>g9PQJ7jYi_jGN3qCeHkj@UV34Z(S*J+yzC zUAF;9`#!Mc2xqZ+>=`I0;|*xXy8oMtLrw-fdl+ziyBk{gjG`FAA*1clhv44(5QD(7 zz~VCjvfAJN5B>}8?*|b*NRl=b-Tt?#Q_OlU_La1%{Q7Uc)NUBW7rW57E8nV+z0giz&ZtY9L;dw;UP?{5UL>U zTrHz63|)ZWe!iStxY{$_OMIM3Wv_s{zwF9EI?LS3QR>A>w7?R|81U~OUlekdHy8K~ zPUQZz*l8CwuaeGpJ@oHqj)3dGsZlIep#MmN9|V+-t-gKU9Jt@1i***8`f~bKynu1J z(ts~Id9XWW_Tgj=YeY)>-vdlR$Q=`5riH=^UldRI^8vy?(ElIt-t;5<^FNPFO%g0_ zNooW&dQcKl(ftZIIl8!U&HfKt8RH@AFb&*x*DRI9e$?V6ECUEHQsYuKk|j>+Dxxhc z_F8Gr5{jRPMA8Xd6!z`$K)fFK|J9xVZ_wFP9wbJLr-GdWDNdX zU=u(kwX!3`F2N+?P}vixcmN$q%(`RLa-Xpc1(HggX#91@Ku)v@R?3kfBu22I9Hlar zH3k4q+e(g%)MY440a!#xh&1|A2&uy+o-ja@a)seSg{-JfFs=G1 zu$e z`|XYe4AQD7q)+5hR+(#pMYhETQQw z)b>q6!j5X^D{cW|d=g>wXOc(Ie$vr4m?UBN2yinXp<(hs&Q74;1z9*^FbVyoESq_&{eOaDm~P;CDRat22(~zxq!|^DrwfboCS$ zr~gjTd=73ySpmrJiJ>NuLV~Rxg3*?q7tMM;mr`N{{a z!4(VN#9m3Rt*N!)MGmVuzWG`!WGgsPyfCq#HBQK0t z{sL+yOe-TzYvPM5a)d$61~)Ln3fGtjT1-S0tVZT-p$?qEzbf-Wg$MWn^>Voq(is-& zK_Dp>i8V&y7!Rx2*60o|@%+YH0L~CSZ5zHxO+h&ZvOxN}Q^TWRU6;m8hIBtduKH7< zf!s0OOdEbev@Y+24wNm#Df?LJ(cwItkv#ltSzyTx{6T5%3bo<2C$nNvK~H!iiC5>F5#w+;mBKZ9NvTug>z^@ zayXA}H-w`)Jmb_vGdZf;@v!ki1EL$8nNI}9S3#DvAJ zDEhpmiPB&Z0HBUIPi~ztqD-Q<~<1D-dBkPG|-CAL-X*+bdIfsmD68i zzmOGZ`@WSfnsMh>NJpUv&`=Fi#>gG1F7rZPV$W(Hw7BzB_Tj_dYD8*SjAPp;BK9E= zV*Ai^8VX3H9&iQ8EQWqgW2Bgzfsf(JxR68MlTtmzT{lHnL3!2+RB zTff4tN$3+!3=#4Ucy=qHeTp`iaYXy9=pW4iTH-W&FoueVGmR}ZR}6Y|BNE18WGwNV z(DHpzw;Ms@{`-K(V4ZqS{w`#C$t)*iN7LYj^lac#T8MhF^`{Azxpd|XbzI3K$^f{$ z)2HA(P2m1f7RuvX@IX1CVPs6h-7sq>M8zl~k#Y)mOT3Vh-Row5Mo**}L#xUb2{o?? zhJzkjK11ZFFIscrla!4NE+sTErDaS^p#c6Uws(=c<$saS>q4O5ClvpF+M`^GKp&SH z=0B0J>>G8w;jzBV_Wa&9{8$Q?Uv-5S-p9LK=#@j90HZZ^+l?97z5@_v3Z^k1_4LWn>U(3b40Pv&HDB@x|LN27 zf%UX0S=8lpuppZIRAGqoXJ^Tck5L$n4HZ3W4IN819{1)ex~_Lwgm*Gq)lJ*2oh#AQ zD|y{C9L;cM677^X?NlVvD>@cQEU1xwDDQ1#&#x$intl4Tlq;T_SGS>skBfdzlT-9C z2eXj{pMB6vI1#M{U*yKX_x^a#?^n33xJaVs6;OU&)xtV$+l-*vK{wp$0#f#IjcxS< zO4XO1F|nsRFto_LhFNVFq5rc-=sF{Nz&+zBybG<-#df`xbERf@4NFhtqmiLg`Xg}e zhINXgXL!TLGuSS{G`{~y@87ha>piFMLVm9{nKkSQ2`Z)7KO|9%xb&!bGdXoLZ6k)< zX7yaZd$N0!YTl(HE^s=5`|?S3Ig{@iV+nL^h@Gx$$2~sjuWL@%nfzJ~iH;8`?`bDfriDSrSfZ?NPzL{xAh4~FE(R#ikFI*rovktF4%`xZ^EBN51J7cfH) z*5X!rGf-%w!;fa89Vc)wp-(fwMU$SA-Ac(GR4Ja-BStMrAr&SVzUBu!u0-RIqIT{s z&royaM@FVlE^K$qZ>)FEvsWvGlL}BH?V#tL#?QQGlAikV(g!0CQp%il@^|YG+pCm3 zgniBI`Ppo7*J}z&!X%PIV?4SLtwu}sNErUZe8zh*h=WUwZ&)67X7MqJ0TlMKyi0$$ z4)6!cUGo&9~f@1PE=>qDMA1xSdIn(?)D zpY`$~-t6_b4Rxdir@gT^bhUg( zor3+v=H&~xqOcjy@_V({{c_hvt+bh~;kl}<+~vSWGQz5iirMMSEZdgWJM&1ZJ=|^i zwC6Rhr;HGCwwN;;`u^mo9go+;aJ#`me7RBZI=)2C7iW1k>=I)U30ENF@lw+w5d(hw5wGbM*g~RC{<4!aom9Ks zerr5C{0;e$WD0S5rKc0`>)7@NXY2&3wC1+LU-o11@v`^9&c)T)1L;EBy1(0XWWRIy z*=WX1KYK`ge-=KIiysk6U~#~I4~wwZxggN*brhCN62+_<)q&>YU_iv)-V~nat8d2F zNZ&jGU*phJ(?dbAR~VuAGd)pB9k$>S~2M4q6o~p#bYfC!b)j|UdfHgJ zGZTIa<g%&YYDR#Z)}QwZ(C{r7pjD3A6k$R`!DG2}4MY{P!(&Os*ldhU zr|deYo4Z<(^E6|Vd>GpY_QkFo%AuTQP{Lwr=AJl*6;XjV7%*v~rS0*QJGI#x)6G9> z+sXqpueg=Q*-yfw*p<3P3?Z17_eviPnz$W%6Y%-R<8t_yRV2T5=mkXXovF}RIHR$t zh@E;teF$GBNgXzidF>+6$|S;5x%&}i+<4JuiIn7P@$ekMm+-s2UN~vRB(FxO*P{nm z7MTy*HP2_$HDoO#`?lh>VEoxvMkk(MN}1l~r-Q+2?Nu_N0D2hS+;R@T(F@cJ1;pJ1 zF-Qwdo9U2RgGso)lm4P8*00q{Za7?8xEEXThog;{w|tqtM#SBp*7m;=2Vu8AXQy#P zT;{_ByN2tf_dM19+pKyF6|?L%jdzbW>1=dOMLUVMhMrQ>{SP5TrVlT6j?QoO0MCXuSwVjizPwju1UywY zf$b#xWgRA@robHqk{E)^LZfkfUwf$++G_kO19P97-Tm697;k&wG;25gk@;kkKP0Kdr9`^it1k%MpTB}C9?Cl6AOQC2m5mpM-W zKO)_epNh!v$E5>0(c2B=!TBT!s*e;m(XI;o`d3$RL|sSiZFWf7?I%K!8&d$noI~Me zFB`0?R@~uRoWi8(r9({s;UJTom=hpqo)m(6X`1HLM!H~jkMe6HX6q>+xRF zsEoapn0}kB|$wR#Hqtk$=9MZpp(5Fwe8$HxHRh>$^rBhPt-0FNwVf z-YIX?;0oB6Smj%wCGuR5DDlRfSfg?~fs;3z_}(>0$wB8H>6P@k&4led zecYBy4&nPArHWtjo`|TpI`0|~m}yk-aGd--e?GK?^V7uX9^B=sS_H5!X!)6Ug8Ylz zgnDMXOh2HRJ4fx?%66VAJ3k#6l74+x+HAiOQ7e2bMQn|tSLO4`$ly10iexWnvJadq zjtNKv{N6h;F|3K8pW2i+NZ)b~*kG$H$c?ckJXn04_g!p5h^2n0UTu{jLC@dhJKm@f zXimmXt;>YZ5D))n^?i`mnA?1@bXRIp<5$VP zW9h`(1)Qc-e*>%Qp3X3;6a0BNU6WU>^On6EVle&H{|w;ua}2-cm4Gh;bv>A&UZ0tdjotTBKp_(6{D<2j6I#Eo8^)9RuZ7v{@w@kdgFF zj~pJWoUTBRgKg+`| zb&p`C;|77wqc@JGE78#q@5)=FH;kFsxU%$9T%b7#03gGabFCf;!7e}gnK zU;iU1LNL>%ni+cpS0^s`csoGz;lHZ!?9GoY^{y#-(V#S6sAm8wC(jeXiZ zLs?)gg=e?}cb#u)`4~uq-V==7m-~_K$+^2L8{i`Y>#nN|AT4OT^JSHnZWKL2O7C{9FHJQ$s(1U6GtEdvJCq0dEzqp1tuk z-${jc=$bJK$QEfUx~PFH?s!}6?BM$++O^?|Uh68*lnR2~qFDaxD!f@vXNB4M)9>rl zFUoYzo2}YQn_Y_(KCi`eT(lU9ht2@!A8sLbC#&Lu()@Tw$-|1nr*MAHjbEqpUWE&p z@fApsbYFMO#D$iu_f`Zt@X%ZMe%$*mJHBZIi~A=g+n(lcEPu4e|Gw^Hy_k=c-lR^}=J z=v3G1x4)d$^W%&)0@4VMJANHLyXtNS2Nc{7^LNDiSzWBZBoamNE$Z$lundB(?QGl4 z%-Lcyk7<&IDqQko3`EJuNkAVO9H1N%xMHOiA$_* zvBUZk^eJP?XYZWBu+J zb+qOa%$-nTW&S0ko(kjd{>jsiH`cl8nTMi8^4C)@Q7wrLKeRvNh;ViBT?Yr$b1wex z>fMvK0|X-v;ng(2eij?`QQO7E5?;fM=1>wDL;_wI#G=E)e{P%FGz6%L{1Jf+Jw5mc z4NxSms3ZF&!jg9EnXA4TcTrL==gM1zZ;KTCe>UcT5U4eG&*;EXywCqv(6FElnqisBKN8|^%3;E^kL$|kGvAJ`&R|k{ zm>Q3FHwQE|<(UIGq88R+dfIm8@_!coy<~eQU?5s3Vo7#UIR>7~PQ#9^x?`8y^L;(f zGaad}Fc5yrEUnzT%w%bVxt_T!OW+%i+DK*~;=s2unhhuPEvW$xEJ`*6_wu`NjGvA%f*aC zX%#`x^1B)i@h#D}t;<-vbp_VEwJh*lNeDsxh48Ed1u^b!vom|)u?Z;?Ehk?OQt_S8 zR)?bB;|sIlLizAd0<-GvA#5{wNhDf#!M$hR{-g6SF1mo7LXY-CcJ%c7ZZr(6glNypbXh3i^mCjv!)_Cd|xT^?t`B&Sp# z)5NNwIz&pMC~B5Q4_Vl zbU7Q2NBt*wTEnKOo6lUofNtoAY3xx?(iJI{Tj4D5@^2mpbR8w zvitYwj`AE4fDAkO_fj~$1<2nPe74DZV)17xX{!sD!-|=(JjvVnBP{+MM(~QLYaa$=sa}jZm*$Y8LopT$v}?v}nICz%_mo(T~S& z+0<92^bdoW-m)Wx$z{;V=-wH*H%)d8;lr|*N0F9S(>hT>U(>URoL*~d02G+HkdT%B z@C@R-rMerDojjt64iFxot#+{^^^(->z3{NCSf$3ke5t}ormb(wwb#{0MLXXkI22Fq zD`=@mv|JWFu{W0+ zp6D1V-MOY29*UTYe_PnUt_TP->!!9SF!shoo6UF=sEA?n)f)B72W?e(oGiNmb<<4{T>hUzDYNiN2srs(Cu1o{DOg zXwT&Sp?*}b(-gs(%#^L_e2sUJKMHUw9RQ63SRrW;lF<&36H~~wv;>lU5VSV&RvTNt z{c??4S$5xd877`aLXO0i&LVXzCgU)I_QO;HqX~wylC?uU3hsxDXO9Ral8IrAsW5KW z1Ve4`3SIIGr>Y#4>0m~|v5t*cw^LK+CRY<(c9zDWXW~u4g#wR+T@SOfO_x$xWF{-V zfp6X*hF4RbsNP>Q%G17}Vo{l4r=0E*1#7Ar&CxXWGm@|Yr8U+cN^_F|0we5ar)RtS zO|lQX0!^$DyUAR;m}S*H4kM;lM;A($!d)pgtpJr9hBF3rv2J;hu@+WACp60h0wMz} z3MPyOD4hh;ijxESJuO|2#KpL@jG&qky$NLr>NIr}NSBc=FOm2-I>B$R6_Y!fY{@?- z*&D&A(_Rp~! z+RrVGj5yxQcl}8lxbf=2nIMI3%A55(w&o(kIJ55J z+)09J#8W}$U6-nwfON9Pdm8BGNSHuZxd5n2c`0_|^`nINEk#rt@@(+NuX{ir!E=OH zfrrdKo7vL-k+kXc8BXgz*-tb?LP|)W$MuzNO<&=1sK(hO7g%0}@V5GwpA+V$iWi!w zvL(J`zKnCUEMzfLyNxc5O7(C`sNXASZvn}!XVT(BjXU@MEUmumvdP7W!h05R3Ng-b z6S}uLsT$zxmirQLL|&wg2-;QkW#qF*>i2_&^MK;91Vvz&SoDXB;wCLaGgIWcn;6z6g?E~qC_rJ|T9-9InNXF!3U0RSw&tcm~n>o$A^?Px%73-ZI z{*yl_CKyNw<=U{bc=QYYJPNfRt<129oMea<#ErF`aE~BqZ~ZcsRVjSMxjd+o3JYaI z0?lxmc}kRWa|VerdoX!uKf4S(ZM(hqR=Fi8bZNI}CP?;47_Jp^4JNV${g7a^o~Y269Ft#+~(i%DG52qlG0Bp|K%zWgC=3wT@)U+I4Rk$!{353Yk=_ zAy}IEyrXm6_fJ9diru2qiTNepz+z1?G!m1b*0eKhIIUQ0z6>8w;w+90*f-snlyx#6 zl_EoIeFLT^WGAsImhfL)?RJAo+M0S;Mga{$8zvT7Hf(}aEhNwpJjdoWLN;mop{$qI zsobD?L#?FavWKB1ki()p)n$wG>fF-TQd!;N3AAGG0a;n#QVC#E3#(6Y$_*7YN{YLy zD4YHKvGd{(Yp&so{UEI32L8j?^~MOTr=RI5*Q;@igB6aphfrnw=%a%dVrq2k#gp%y ztBv+jlkBBF-1g($dDp*t!>=6Ok_ma*snSD>2YnLK%1gA;@UEg$$psuh@h3Fm#Q`IcI5RN#Kq{t!6tP!1%qjE z#ATl_PGF8XrEO%1R#@bY`_>liZZwN<*{Ik)3T$|kCo!DE+a(PFTqA}>aj@qUQtFHZ z^&m=avho_pHl1rislUSBo+#BbUIN!yx#*BCebAUhjv&$C#Kug!!UHeA(2%zYw?LS< z%whmM#iA*on}W$0)YwGyrb!2?Xza4*d3eJIR7~uN*&+C*)xuvYCB@zz6)DOg8TW7Z z#O6_(DCyD_P3z#GSw+b)+I`r+Lh7`?J*$%G!-xZI$$4U*iwC34mpr4sELfnMQ}C#xbCyF@PMPvA4aO5W#PmmYv9O_nx4=c zaO`YpDd<@`CAV4M&5o|0?-Y659#~Ev19m~b(HbeV8=Ba6(f91R&pCazHGQhLtF~=f z_=C1}{hC?aE91>c1#Sj6RL1ix#nc;OW|NiG)HblFt6b7z^P4Ig*5_QcUs7w(X zjbDx|Y<2m;jc*%_UyuY$4%vI(u8{Y<6VX}754IRSaYd}o{!_31e*91E`hU8%nAH7K z((yU5X33oaSVBeGaRhSfjv>iZ52Xyr(C@#JS&;^^RF{Uc=w%^G&9qKP;Uz4bvz`nY z2#Aa~+v3P=%1I_5^E^7AaXOQ!cz>ewFD!^)=V**9JCZ5Uczf|06nU&{eikq`zb{ zvk^MGr(FT?^ctPEG(KhUQ*-q;2VVf2+smx3zX?y~4>)emgBX6E!S_e;N!ma8nF+DU z?#YJ9TW6;a&i>&*thI}~B9!Kt+%F)4Skpg^w^JZ=dV2W34msYG;p^`Vnmr5#8-MTenoCyJ27(kVfy7MCl z#$-v4HiXiIRFG$E;JU5H@2Cv=Cpj<-(Dl{Q7MX<57XJ+p&@|#^90XHFNC}L4elG4> z#dB8LdaD$XdQTrMO3=2zLK}6MT+&MY+w6oP?s0g=vUX4(CeJkp%0?3MHXfZp2wjVW zA#g?}TOxbBB)+a}KrCt&h-ny^W8zqpV(}dz+g@#XwefsXD0d%~X}`#>Ae=`nyrz`{ zaiL#5vWL5vYK|iX%KT&QsPahF>XVw8Xi`^cBToA+ND)NH+TVKLstCL*9v8k_VD44(r< zAS(f>ao2)@IRB1ZJE8b0^b;pZz_8|esI63>e^!Y=VXO0~&*g)JP-OQ`6Udx|i0Vyp z4kPAg^#~GDx8%Kq2)*rZeaf5N!#X=+#^cfb)Ue@QqAKvstmGZ{>D5AnJkMLZq#TjS zv@$Bzu7#uc$gl?~kbE8Q;(F}+l_v|-A_U0-sg3&y1IBohwP%h(uNm6ZC6`m=ke> zya+^BRO0!_#E>G7xH|NvW(t6(glO8F$4?jT7lUt2r+{F@AP#7`%?7L;%;TjzL6I9^ zIHCz_RJnT15ymDZk5VjrI z11v`^ZjvyqTRoY3DGz+iZ1z=`rv>Wt-rVRE8u)*zzVKnkEluihfBm*rW zW(AJJ@CkVXQWKqmncekeuL8|Af5Fl<2MGiU4Tjujk&Ey-WJ6bJ6N_6BErAbJf365-F|ax5VUPMh3zX9 z``#3~(!zW?VdS9y6k=8$sf<|BgE5g%V$G;|ryEJ|oA?ua&Le@3Oz&n7k!v4DGLy;{ zd)0?y1)O-`d6*w#(W&cDwQDdK^jG^zFlvN~s*;8p1T~7Ftvzf7mLa0FD?CJ;!2J9+TL~Ff_P`6f~xkbZ(+y02B(eAET@jp-lIFOBAlg8U;#!p%Mn9a~9?v0v+yU86w+D z?&ntVPSn3!{m>`a=SUga>@9U$=8Sktro|x>^L<8THk$!<&P`L2b0ioIgUX07UJ*9c z8=kEa?0KEoPZDjm@wUDwB-yT58-qf18%M?B?2b4a&Q7i_JdNGo`KaKNev1vTQ!XZbaOdkTT@Gu<^} zzi>ra2}#%3df@ma2UY8<>mB|w;U8lyp(bYE1WeR?O@bV3`&m)YAsGRuCd8>T_N`f= zd5bm`2VPc|W$u^_UsZQ0p_T6kI|COA$Phx{OGRU)VQFA!BDF9ta1R@Ac`?$h_5;Pfm5h2F$q_(hU zxI_nZ>%uwsEQjdRK{U3)*m`$ojv?iOK^cD_lnM|Q8$hiheih>ejTynw5lCbcM^V&g5j;fM224;FFeyh}-wp3!plelhT97E&%R~&A4!fVHns04{Adn5M%a#O=t z$LN>c5V(`86eo-6kk6cl(!+Cy`61=lVAay#8~56a#yPOoC+QpVZIg0ouU7W*GeEOi zDHi%vwUC=wl?0O*MG*BtBraH2y;dNcafWuVITEX3Sd?~%5VS0TePy-K1OK+!C=DP2 zQl=i9;}@L5*?&b>ZU8-p;uyE4sVsx;w$u5{g&(Bb{A{MuP><=hwJ%HMHg|1$Qdyrf zlVG>kd|t#Cj;@@Fu_7hTFSZWV*4pe3h{~(CO#OSdDr(bBqrq2Nh1>dyEVp}R?xNsKLnK{ne)P>9!)Eo_M$(}w{@1!h zIdvUOfMnLmj682sk*4;solfwLSQO7yqpd9!Le_0wYuq_Wgft3rb9uV_A(u# z0U#VPA|fp2%?E)n4Z#Lct=6&;~b>II86SM*gCRT zlvZnt5x32DZ)am&7PO0X*HEr5({|Fym9dF;eU3a|mcrE5u?-p({*&||w6sFy63@XH z3&FN|=1v2l72h5&ng2)Q-!VAe%4;?M6@s#NU6SVKXUoLhgU0Pa^IXse(&-uOx08zI zCglEQHD|%)JfWhj#&6Otz?CO>gEh7A+P2UpDz_q`dApEnd5G$jAon0V3|BLmnBogi zsd;V&Rr9MfeE%NnU85OcHjd@3Iax@{Xv0Z2GPFxk-vBP|ei>TD{sObMQXztMZ20;W zyExjW47oTYXIUzRTccLe-ynHyv&Fka?MbZ(Lk(;`d7ji0Aq6Xf>o&d`RV6fQm=8Mj zA}ZDX414XARwm#O{IEquK6u6m{Kv%S?s2pW#t^(&9a;D#n5s3!@|xB8i_}#7r9@WN zbV1=iypXPMx%tU@tJ&5!`-Jj5AP<8D{ZpUA$YBho)m`|LXEJU)8fDb7(jxpS%}%O2lSnB7=6@677n_iJn4>zThxUd+kWpLS$Nf3KQ`k6Tra31f=UiDH%+ j?jN!j96u}>pvG)3cP>G|DFK?bBj8l+RYQ9@b}hlZh%mX?wb5ExRr8-|8KKoExR zaEQ5gopbLw-*@kM|9aPY)?RBrdq2Oet*oFRPX_=Pyp+|{*Mzb`|NB2t2FS*FjK)*K zk#v5Zrd-JJg`Mp?G$D`-?&xx3-c-Ib66{V$N!Gy{$il`N$ZB-gXI=+uWSzz!KKfyC z7B8=`z#9#}k|jw)3Cm6U6RF1b%Ddm_G>j|Zog&O*hu{yz3GBjT3e&LL{#Bq1q=jv| zd(k(1jg|e_59_=H+=W~x?Se5_LTop-`v~kp_b^%9CI^qYl3Y-Jv-mJV5(=6 z<#T0amcCv=->AgD3v>Fzy@IkdZd3NTWYn+vWP002SH6)3`-iaL&}7dC0#2||B;(D$ zD>35ETmAtk|MvL#VAmx^kG zs*<{lBT+6`-*I(DvEJVQDCt8%Od7>l3d8F8F;ZmC#_-yId-ue*#mHS}4G1!#VU}t_ z2wlk$&C2&(MqVO>gwz!9UNVbMd_^^6<+`JsoY|`E>~(ckvr;NeJtZt&^RmV2@M|sj zL>=cnRXCdO;iu(MCVWwuq~eR`SA90ogAD2l|1Hr(6_d9qWd`V;R9SMO{i$H7u<~@R zZ~mkt>v_i>Et=}#HCF{Z4uo3#i!)}X1v;_{Urv`CAOC(6*v56zIu~s4+r*8vuwLP_ zrPsBHvi~$Qu1gY8qHT+Tce9Jc$9Xd@Ib)M9B?~#P7wl?=mc(Af<}Pv%dhcZ~fvl~F zz;CUGQt>A+r3$it8uwqfrVwsENiH6wrjyw^3a9vIN9j4`e9WBV6!t^oIInz@P+4`q z>=h7XVU#curT#d=4yRbL z{K=z({2svo8#TAP&FQI?wjNoL#}@I4J{=|>(?IxfOD_$clBkZRTy|XrXUC5d&qVdQ zS6bY4c*%T$%d9s)5Rv!IK{!_$E!O$kG^PW24F>t|*6+=nsJ1uOPyRd*SbW@&n7{yb z6GH0|%f`L);~h&gMsyY!{QnsKGoM}!UMUANAn-378Mhy4Nl$Y=EO-YCh|$9*k~8O8 zLvZU~c(s8Bob8T+x6X=)M7a_=&l8_^UuWvP3jLRf&ZzB|H_j0jS(-${X-s+>f&?u1 zE!Q!B?X3&(;nU%P;5W17#e=^432k;7Ew>{2<7ml74L#Y+%bIev+Hco-N3M zAe}4CSLr@SuYe&n4qdn(W;g+`_OIprZ=BAtAD4Xk;iA#60v=bY^cUulk8&#~R?A03 zV?ygfIg%)`m? zAKsEmf{1W@|3dy>)o*30$!D;?-i3dwlqqKYl*v$SrTP09+omEv9yiL*B@gNnK@L41u8jbmgypF+qK*&X+VfI}P}z2>{&vl6^Cc z$-?F8SUZ>22&!FuHz`FSnjE3Jqfc}r&_wzFw38LD4$vMEo zS6my2jyFaZPjByMzO3hEn0xDG;d>{as6wChesRV7TamI^KA(a4q^Q3seD5&XlUh98 zB$_}O@qOJ#IOo^5A>aN7CmWOAqQAXz`Y!o?V7BW@uNqi{`NwW1F6D2wp~}%iOD#Pk z%U3a0u7+~&u9~DZeS$CxBUIdLSGH+7-lA1A!j>PCpG2SoaT0L}I}NWS+YBJTf&LEs zDIk)j$Lni_W9>=pKWmwb9)nA2MLVBDO2araPB8 z;EqH3vc{WJQFH4b%6RklzQfeZGQJQ)^$ExE-O)_EKYj--xvi*g(oyDSdta%mYKdD^ z4Ef6qVp%-<4$$gilh#5AU@UZ0t;|#xLc6RIacg zm^R7SQUCNBJm#_15q~L)*Iphpy(eNDU!PO4Z&^U^hZBB&r)#LBr~)yoC`wGL<`}Af z+_IeZh&!k5c6ZlkXA~zWM()T`H7Nkln?F7*cYzr@8ZUQH<7u4F(P#$D8zy!pc1~Ez zG6C8oF>QIP%LfQmomDvqnfJ!ms6+*aAgE>j#HOLvh%+lIX_u_i_QtB!WkA-d@hct0 z*U&)9mTjj}O7BjL5 zkFzN;_(`4KGZ(_^l#nH@o4FZep&`qNa6}%CoIbKAvG+!Q0B?$B(;ALCs?scLLtLD& zQlTmv`%YHqux;#bOh_de-@lUKl&)cwxXpr^3QLckwz5k>Z{457>j^pIeoAJ4bN~7? z?t_x16qOX?dUhwoC*bqNE@^*udNF+XjAG|~ElG(<3A9$Jb(dk4U}N=pLr9QC{kbp& zWm7It$nZYn9~nWgWoF!V-0A+?i|#SMrvou66Qs(cR+OfSwx&NU62{U)#lcaQtY z&3YZlEDMr&)pLvf(Ju|6&K6Jm5(=jwP;k;tD9`golOE zq_DJyxgr&19>T@233eZnNr)udUgVf26qsCV(yDIz3w++`$PAgOiUv=ymw%h*bq%4x z3*T4e%EME)rE^(+h(oRFF4mxi>T@LyAO+e7;|`t3Ze}aSL0dkA?W=!!4}7@9;6&)^(m9dHnH#h=dXebIJdO636&#GR3(x!NOuXP|A#fRpHuCBhA^bkR zwiaA}!UB?#>K(h~^1Ih*pzUe$oc57=|LBnf`1JM$9iWNK9;;$vZ)uO~dMVa05R|0Tcq5y$uA8&N`Oy;V|}(=?w``QF?sYiM%Olbbu7r^(0vY_3$<$>=mRI)b}*x z)6vxBd!d5xDf~b28&ljJ&=zox=7jfV-LOl3_Jd()g`8mKQu5C_!xQt>j(MNzGDRt& zU!#S@&M#)dmiXu`Glq>@Xn)P7_yP#H#e)LuqJriXB8Rhbs|AC@Pa*SB@#JB z;vy=Vv_x8;Rso=ItY@XspNu_H5?EIeg1i0 zY;*=%Yjs3+pC7E~B6&kl<#+jZm$hLCw^a@wIJV-ETieaxn;`@8vEc}vV=dv|gOSPX zq>hhD(gNUfNG6NX4P@M#@=}&%@2oPs@bDJ3`ndwGU!bg;4d6Pf>u%wH`$ZPUJ|bKeV;om7L@!Q# zyQ)c`)8?=dBNU5^2N8@KtB&WH4q`CRKQ`tN)XIV>Fnxg>4O5>BrPgCO%{(RNCzZmN zc@^YrozCNIL(d$N!JcKdEBo3=?y!s@rETNn3`-}(-HK9X2@v(f0tR_JR)~^c-tiWn z30uaAu&=S}q62uTfBX6g5lfUSQQq#wskv0Y>kbM2DjO&n(L2v z`Ov1@Mf@!CLJJ0llsW`3_O~)UW(#JrGYl@)KSrqpe zpTZry<)B;{( z2XaMIwbXx7ckhb6O?SUouQ%f+e#XIIvG3j ziesOwv<4b#q-8Y5b2@Lwy}%H(imQ>2;^_MbU;L!Z@IKu_m?fXGIZ?@{$>jNE5{|vn zqR~W(t3G|_(cMl#Mc0m~q(`7I_gzS>L>s-&oLQr*cr}jWcajv;77;-{purB>M!4!) z8C)w22?6gSqDakZG6Ryz8AKXJucMYNFPUeVfjTVftBOi_V&P}?#n>X?zN!61Q%8^L%Fc9+B|77)bjSL&_PuvIMB@yQT+LR=SYpkVY_cFv zQP}nK(ytx`3^bX;Wco~OR-)E-ffsz>?#ZAJLR7>N1}h1!E0&(Zm2GmY`5+Dww-F?a zp27J@Rt1%kt^9`cWWT(GW?bR}f3SNXn&32SlQ_>w{jH+#R!sR{pk&HjYJiw7+x*ko99!Ho*zL*C~2(!^BGFu=$zT1qa zSz(LqvmP)n0(3NgnN?pn%lB*Xr}U$&)W{^YS4Tpc)yfx(8ZH|b$2N-_uE|OtjT82| zob#`PX(h6)Wv+?8^@q+onmb%|*qbC`;g~f%`U5f3JoDC%P`hdXF{6RW4f={(A4H+i z|8ACGT-v%TGIRAAbj}8 z`j?M!*1|$D5Nc!4sMS2snXRZJ?@yjrsEe!`roRi(u9srV*Hmr`;KS@^lx zIFgu(kXeSF)^@7w&kni#&`HLiUzANPPIM1+fW2is?Hw}!@H@3V87+6z(qQMpGO(30 zuBNBHb+w<8)+RfX;#LqDt3)T|5LA3@-R>OvTsm&!cf`F)_CsCxK!eIa%>%l^l?6x= zc*QL%n$8k`Je?enqq9`ae=FM=cb0d&5^to~>T&eo5IJ6xlT7f%x>dw@T5rNb1ZOR_#-k)fF?62HjjmB}?r}aUHw)ZN7?g@#H zeB}){=6ZEi#(rD0jh39kz1Yf->zOa}+hT08xuS9Gluj6w^pR!!Eeokn>*kl`wb|T> zt!0s;C6i8}>~7~{w+D&Tc*ZQ(_idC>m_!d;+d*eYU{xfkwxA%o))ZinGiV}tE zy!{lt*G8HmBe{m-ep$OFBWH0wgS3AaU)rvE-HHCq&K13N5|bki$I-CJzwa7W*f3Ox^l&Qy-P=G6?_Tavnh3MQ0C3uC@PczUDXPIR1OOEW0e)+}A)MibW z!19f&7F)Ry3G zO_v|;2f@2?W$(q)E)Y)Kz<#5bJ|S+qc_E4sajSS=UQHb8$ss;N&&Bz3TLDMnj08pg qI*s2+_u#aIMnr)l>8P2vO8+we0P$~DHbVvisJHx9CfES~=lvH7K)Xl) literal 0 HcmV?d00001 diff --git a/docs/en/14-reference/07-tdinsight/assets/select_dashboard_db.webp b/docs/en/14-reference/07-tdinsight/assets/select_dashboard_db.webp new file mode 100644 index 0000000000000000000000000000000000000000..956132e37e9df255d3ff82654fd357bec001e695 GIT binary patch literal 23862 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 Apply external notifier uid to TDinsight dashboard. -Alibaba Cloud SMS as Notifier: --s, --sms-enabled To enable tdengine-datasource plugin builtin Alibaba Cloud SMS webhook. --N, --sms-notifier-name Provisioning notifier name.[default: TDinsight Builtin SMS] --U, --sms-notifier-uid Provisioning notifier uid, use lowercase notifier name by default. --D, --sms-notifier-is-default Set notifier as default. --I, --sms-access-key-id Alibaba Cloud SMS access key id --K, --sms-access-key-secret Alibaba Cloud SMS access key secret --S, --sms-sign-name Sign name --C, --sms-template-code Template code --T, --sms-template-param Template param, a escaped JSON string like '{"alarm_level":"%s","time":"%s","name":"%s","content":"%s"}' --B, --sms-phone-numbers Comma-separated numbers list, eg "189xxxxxxxx,132xxxxxxxx" --L, --sms-listen-addr [default: 127.0.0.1:9100] ``` Most command-line options can take effect the same as environment variables. @@ -136,17 +132,6 @@ Most command-line options can take effect the same as environment variables. | -t | --tdinsight-title | TDINSIGHT_DASHBOARD_TITLE | TDinsight dashboard title. [Default: TDinsight] | -e | -tdinsight-title | -e | --tdinsight-editable | TDINSIGHT_DASHBOARD_EDITABLE | If the dashboard is configured to be editable. [Default: false] | -e | --external | -E | --external-notifier | EXTERNAL_NOTIFIER | Apply the external notifier uid to the TDinsight dashboard. | -s -| -s | --sms-enabled | SMS_ENABLED | Enable the tdengine-datasource plugin built into Alibaba Cloud SMS webhook. | -s -| -N | --sms-notifier-name | SMS_NOTIFIER_NAME | The name of the provisioning notifier. [Default: `TDinsight Builtin SMS`] | -U -| -U | --sms-notifier-uid | SMS_NOTIFIER_UID | "Notification Channel" `uid`, lowercase of the program name is used by default, other characters are replaced by "-". |-sms -| -D | --sms-notifier-is-default | SMS_NOTIFIER_IS_DEFAULT | Set built-in SMS notification to default value. |-sms-notifier-is-default -| -I | --sms-access-key-id | SMS_ACCESS_KEY_ID | Alibaba Cloud SMS access key id | -| -K | --sms-access-key-secret | SMS_ACCESS_KEY_SECRET | AliCloud SMS-access-secret-key | -| -S | --sms-sign-name | SMS_SIGN_NAME | Signature | -| -C | --sms-template-code | SMS_TEMPLATE_CODE | Template code | -| -T | --sms-template-param | SMS_TEMPLATE_PARAM | JSON template for template parameters | -| -B | --sms-phone-numbers | SMS_PHONE_NUMBERS | A comma-separated list of phone numbers, e.g. `"189xxxxxxxx,132xxxxxxxx"` | -| -L | --sms-listen-addr | SMS_LISTEN_ADDR | Built-in SMS webhook listener address, default is `127.0.0.1:9100` | Suppose you start a TDengine database on host `tdengine` with HTTP API port `6041`, user `root1`, and password `pass5ord`. Execute the script. @@ -166,24 +151,10 @@ Use the `uid` value obtained above as `-E` input. sudo ./TDinsight.sh -a http://tdengine:6041 -u root1 -p pass5ord -E existing-notifier ``` -If you want to use the [Alibaba Cloud SMS](https://www.aliyun.com/product/sms) service as a notification channel, you should enable it with the `-s` flag add the following parameters. - -- `-N`: Notification Channel name, default is `TDinsight Builtin SMS`. -- `-U`: Channel uid, default is lowercase of `name`, any other character is replaced with -, for the default `-N`, its uid is `tdinsight-builtin-sms`. -- `-I`: Alibaba Cloud SMS access key id. -- `-K`: Alibaba Cloud SMS access secret key. -- `-S`: Alibaba Cloud SMS signature. -- `-C`: Alibaba Cloud SMS template id. -- `-T`: Alibaba Cloud SMS template parameters, for JSON format template, example is as follows `'{"alarm_level":"%s", "time":"%s", "name":"%s", "content":"%s"}'`. There are four parameters: alarm level, time, name and alarm content. -- `-B`: a list of phone numbers, separated by a comma `,`. - If you want to monitor multiple TDengine clusters, you need to set up numerous TDinsight dashboards. Setting up non-default TDinsight requires some changes: the `-n` `-i` `-t` options need to be changed to non-default names, and `-N` and `-L` should also be changed if using the built-in SMS alerting feature. ```bash sudo . /TDengine.sh -n TDengine-Env1 -a http://another:6041 -u root -p taosdata -i tdinsight-env1 -t 'TDinsight Env1' -# If using built-in SMS notifications -sudo . /TDengine.sh -n TDengine-Env1 -a http://another:6041 -u root -p taosdata -i tdinsight-env1 -t 'TDinsight Env1' \ - -s -N 'Env1 SMS' -I xx -K xx -S xx -C SMS_XX -T '' -B 00000000000 -L 127.0.0.01:10611 ``` Please note that the configuration data source, notification channel, and dashboard are not changeable on the front end. You should update the configuration again via this script or manually change the configuration file in the `/etc/grafana/provisioning` directory (this is the default directory for Grafana, use the `-P` option to change it as needed). @@ -249,21 +220,23 @@ Save and test. It will report 'TDengine Data source is working' under normal cir ### Importing dashboards -Point to **+** / **Create** - **import** (or `/dashboard/import` url). +In the page of configuring data source, click **Dashboards** tab. ![TDengine Database TDinsight Import Dashboard and Configuration](./assets/import_dashboard.webp) -Type the dashboard ID `15167` in the **Import via grafana.com** location and **Load**. +Choose `TDengine for 3.x` and click `import`. -![TDengine Database TDinsight Import via grafana.com](./assets/import-dashboard-15167.webp) +After the importing is done, `TDinsight for 3.x` dashboard is available on the page of `search dashboards by name`. -Once the import is complete, the full page view of TDinsight is shown below. +![TDengine Database TDinsight Import via grafana.com](./assets/import_dashboard_view.webp) -![TDengine Database TDinsight show](./assets/TDinsight-full.webp) +In the `TDinsight for 3.x` dashboard, choose the database used by taosKeeper to store monitoring data, you can see the monitoring result. + +![TDengine Database TDinsight 选择数据库](./assets/select_dashboard_db.webp) ## TDinsight dashboard details -The TDinsight dashboard is designed to provide the usage and status of TDengine-related resources [dnodes, mnodes, vnodes](../../taos-sql/node/) or databases. +The TDinsight dashboard is designed to provide the usage and status of TDengine-related resources, e.g. dnodes, mnodes, vnodes and databases. Details of the metrics are as follows. @@ -285,7 +258,6 @@ This section contains the current information and status of the cluster, the ale - **Measuring Points Used**: The number of measuring points used to enable the alert rule (no data available in the community version, healthy by default). - **Grants Expire Time**: the expiration time of the enterprise version of the enabled alert rule (no data available for the community version, healthy by default). - **Error Rate**: Aggregate error rate (average number of errors per second) for alert-enabled clusters. -- **Variables**: `show variables` table display. ### DNodes Status @@ -294,7 +266,6 @@ This section contains the current information and status of the cluster, the ale - **DNodes Status**: simple table view of `show dnodes`. - **DNodes Lifetime**: the time elapsed since the dnode was created. - **DNodes Number**: the number of DNodes changes. -- **Offline Reason**: if any dnode status is offline, the reason for offline is shown as a pie chart. ### MNode Overview @@ -309,7 +280,6 @@ This section contains the current information and status of the cluster, the ale 1. **Requests Rate(Inserts per Second)**: average number of inserts per second. 2. **Requests (Selects)**: number of query requests and change rate (count of second). -3. **Requests (HTTP)**: number of HTTP requests and request rate (count of second). ### Database @@ -319,9 +289,8 @@ Database usage, repeated for each value of the variable `$database` i.e. multipl 1. **STables**: number of super tables. 2. **Total Tables**: number of all tables. -3. **Sub Tables**: the number of all super table subtables. -4. **Tables**: graph of all normal table numbers over time. -5. **Tables Number Foreach VGroups**: The number of tables contained in each VGroups. +3. **Tables**: number of normal tables. +4. **Table number for each vgroup**: number of tables per vgroup. ### DNode Resource Usage @@ -356,12 +325,11 @@ Currently, only the number of logins per minute is reported. Support monitoring taosAdapter request statistics and status details. Includes. -1. **http_request**: contains the total number of requests, the number of failed requests, and the number of requests being processed -2. **top 3 request endpoint**: data of the top 3 requests by endpoint group -3. **Memory Used**: taosAdapter memory usage -4. **latency_quantile(ms)**: quantile of (1, 2, 5, 9, 99) stages -5. **top 3 failed request endpoint**: data of the top 3 failed requests by endpoint grouping -6. **CPU Used**: taosAdapter CPU usage +1. **http_request_inflight**: number of real-time requests. +2. **http_request_total**: number of total requests. +3. **http_request_fail**: number of failed requets. +4. **CPU Used**: CPU usage of taosAdapter. +5. **Memory Used**: Memory usage of taosAdapter. ## Upgrade @@ -403,13 +371,6 @@ services: TDENGINE_API: ${TDENGINE_API} TDENGINE_USER: ${TDENGINE_USER} TDENGINE_PASS: ${TDENGINE_PASS} - SMS_ACCESS_KEY_ID: ${SMS_ACCESS_KEY_ID} - SMS_ACCESS_KEY_SECRET: ${SMS_ACCESS_KEY_SECRET} - SMS_SIGN_NAME: ${SMS_SIGN_NAME} - SMS_TEMPLATE_CODE: ${SMS_TEMPLATE_CODE} - SMS_TEMPLATE_PARAM: '${SMS_TEMPLATE_PARAM}' - SMS_PHONE_NUMBERS: $SMS_PHONE_NUMBERS - SMS_LISTEN_ADDR: ${SMS_LISTEN_ADDR} ports: - 3000:3000 volumes: From ac3fc6c06a76d8013584296fc68ff4cbddb97388 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Thu, 15 Sep 2022 16:35:25 +0800 Subject: [PATCH 112/138] fix: make it impossible to create and update stable at the same time --- source/dnode/mnode/impl/src/mndTrans.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/source/dnode/mnode/impl/src/mndTrans.c b/source/dnode/mnode/impl/src/mndTrans.c index 9c4a5afb03..030f4542b9 100644 --- a/source/dnode/mnode/impl/src/mndTrans.c +++ b/source/dnode/mnode/impl/src/mndTrans.c @@ -790,10 +790,20 @@ static bool mndCheckTransConflict(SMnode *pMnode, STrans *pNew) { if (mndCheckDbConflict(pNew->dbname1, pTrans)) conflict = true; if (mndCheckDbConflict(pNew->dbname2, pTrans)) conflict = true; } + if (pTrans->conflict == TRN_CONFLICT_DB_INSIDE) { + if (mndCheckDbConflict(pNew->dbname2, pTrans)) conflict = true; // for stb + } } - mError("trans:%d, can't execute since conflict with trans:%d, db1:%s db2:%s", pNew->id, pTrans->id, pTrans->dbname1, - pTrans->dbname2); + if (conflict) { + mError("trans:%d, db1:%s db2:%s type:%d, can't execute since conflict with trans:%d db1:%s db2:%s type:%d", + pNew->id, pNew->dbname1, pNew->dbname2, pNew->conflict, pTrans->id, pTrans->dbname1, pTrans->dbname2, + pTrans->conflict); + } else { + mDebug("trans:%d, db1:%s db2:%s type:%d, not conflict with trans:%d db1:%s db2:%s type:%d", pNew->id, + pNew->dbname1, pNew->dbname2, pNew->conflict, pTrans->id, pTrans->dbname1, pTrans->dbname2, + pTrans->conflict); + } sdbRelease(pMnode->pSdb, pTrans); } From e6512296dad1277423ed049a7c164a2fa90c9198 Mon Sep 17 00:00:00 2001 From: gccgdb1234 Date: Thu, 15 Sep 2022 16:38:41 +0800 Subject: [PATCH 113/138] doc: change 10-monitor.md of English version --- docs/en/13-operation/10-monitor.md | 25 ++++--------------------- 1 file changed, 4 insertions(+), 21 deletions(-) diff --git a/docs/en/13-operation/10-monitor.md b/docs/en/13-operation/10-monitor.md index a4679983f2..74a5564a2a 100644 --- a/docs/en/13-operation/10-monitor.md +++ b/docs/en/13-operation/10-monitor.md @@ -2,7 +2,7 @@ title: TDengine Monitoring --- -After TDengine is started, a database named `log` is created automatically to help with monitoring. Information that includes CPU, memory and disk usage, bandwidth, number of requests, disk I/O speed, slow queries, is written into the `log` database at a predefined interval. Additionally, some important system operations, like logon, create user, drop database, and alerts and warnings generated in TDengine are written into the `log` database too. A system operator can view the data in `log` database from TDengine CLI or from a web console. +After TDengine is started, it automatically writes monitoring data including CPU, memory and disk usage, bandwidth, number of requests, disk I/O speed, slow queries, into a designated database at a predefined interval through taosKeeper. Additionally, some important system operations, like logon, create user, drop database, and alerts and warnings generated in TDengine are written into the `log` database too. A system operator can view the data in `log` database from TDengine CLI or from a web console. The collection of the monitoring information is enabled by default, but can be disabled by parameter `monitor` in the configuration file. @@ -10,7 +10,7 @@ The collection of the monitoring information is enabled by default, but can be d TDinsight is a complete solution which uses the monitoring database `log` mentioned previously, and Grafana, to monitor a TDengine cluster. -From version 2.3.3.0, more monitoring data has been added in the `log` database. Please refer to [TDinsight Grafana Dashboard](https://grafana.com/grafana/dashboards/15167) to learn more details about using TDinsight to monitor TDengine. +Please refer to [TDinsight Grafana Dashboard](../../reference/tdinsight) to learn more details about using TDinsight to monitor TDengine. A script `TDinsight.sh` is provided to deploy TDinsight automatically. @@ -30,31 +30,14 @@ Prepare： 2. Grafana Alert Notification -There are two ways to setup Grafana alert notification. +You can use below command to setup Grafana alert notification. -- An existing Grafana Notification Channel can be specified with parameter `-E`, the notifier uid of the channel can be obtained by `curl -u admin:admin localhost:3000/api/alert-notifications |jq` +An existing Grafana Notification Channel can be specified with parameter `-E`, the notifier uid of the channel can be obtained by `curl -u admin:admin localhost:3000/api/alert-notifications |jq` ```bash sudo ./TDinsight.sh -a http://localhost:6041 -u root -p taosdata -E ``` -- The AliCloud SMS alert built in TDengine data source plugin can be enabled with parameter `-s`, the parameters of enabling this plugin are listed below: - - - `-I`: AliCloud SMS Key ID - - `-K`: AliCloud SMS Key Secret - - `-S`: AliCloud SMS Signature - - `-C`: SMS notification template - - `-T`: Input parameters in JSON format for the SMS notification template, for example`{"alarm_level":"%s","time":"%s","name":"%s","content":"%s"}` - - `-B`: List of mobile numbers to be notified - - Below is an example of the full command using the AliCloud SMS alert. - - ```bash - sudo ./TDinsight.sh -a http://localhost:6041 -u root -p taosdata -s \ - -I XXXXXXX -K XXXXXXXX -S taosdata -C SMS_1111111 -B 18900000000 \ - -T '{"alarm_level":"%s","time":"%s","name":"%s","content":"%s"}' - ``` - Launch `TDinsight.sh` with the command above and restart Grafana, then open Dashboard `http://localhost:3000/d/tdinsight`. For more use cases and restrictions please refer to [TDinsight](/reference/tdinsight/). From f8bc0693c028e7501e0e1ea28531b4fecf112f27 Mon Sep 17 00:00:00 2001 From: gccgdb1234 Date: Thu, 15 Sep 2022 16:43:41 +0800 Subject: [PATCH 114/138] doc: fix broken links --- docs/en/14-reference/07-tdinsight/index.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/en/14-reference/07-tdinsight/index.md b/docs/en/14-reference/07-tdinsight/index.md index ebde820828..d03c16a8bc 100644 --- a/docs/en/14-reference/07-tdinsight/index.md +++ b/docs/en/14-reference/07-tdinsight/index.md @@ -11,8 +11,8 @@ After TDengine starts, it automatically writes many metrics in specific interval To deploy TDinsight, we need - a single-node TDengine server or a multi-node TDengine cluster and a [Grafana] server are required. This dashboard requires TDengine 3.0.1.0 and above, with the monitoring feature enabled. For detailed configuration, please refer to [TDengine monitoring configuration](../config/#monitoring-parameters). -- taosAdapter has been instaleld and running, please refer to [taosAdapter](../../taosadapter). -- taosKeeper has been installed and running, please refer to [taosKeeper](../../taoskeeper). +- taosAdapter has been instaleld and running, please refer to [taosAdapter](../taosadapter). +- taosKeeper has been installed and running, please refer to [taosKeeper](../taoskeeper). Please record - The endpoint of taosAdapter REST service, for example `http://tdengine.local:6041` From e8b123b8a20aaa76f0a424e02778d01453b0dc6c Mon Sep 17 00:00:00 2001 From: gccgdb1234 Date: Thu, 15 Sep 2022 17:02:10 +0800 Subject: [PATCH 115/138] doc: English version of distinguished.md --- docs/en/12-taos-sql/12-distinguished.md | 32 +++++++++++-------------- 1 file changed, 14 insertions(+), 18 deletions(-) diff --git a/docs/en/12-taos-sql/12-distinguished.md b/docs/en/12-taos-sql/12-distinguished.md index 707089abe5..98b782c3eb 100644 --- a/docs/en/12-taos-sql/12-distinguished.md +++ b/docs/en/12-taos-sql/12-distinguished.md @@ -5,11 +5,11 @@ title: Time-Series Extensions As a purpose-built database for storing and processing time-series data, TDengine provides time-series-specific extensions to standard SQL. -These extensions include tag-partitioned queries and windowed queries. +These extensions include partitioned queries and windowed queries. -## Tag-Partitioned Queries +## Partitioned Queries -When you query a supertable, you may need to partition the supertable by tag and perform additional operations on a specific partition. In this case, you can use the following SQL clause: +When you query a supertable, you may need to partition the supertable by some dimensions and perform additional operations on a specific partition. In this case, you can use the following SQL clause: ```sql PARTITION BY part_list @@ -17,22 +17,24 @@ PARTITION BY part_list part_list can be any scalar expression, such as a column, constant, scalar function, or a combination of the preceding items. -A PARTITION BY clause with a tag is processed as follows: +A PARTITION BY clause is processed as follows: -- The PARTITION BY clause must occur after the WHERE clause and cannot be used with a JOIN clause. -- The PARTITION BY clause partitions the super table by the specified tag group, and the specified calculation is performed on each partition. The calculation performed is determined by the rest of the statement - a window clause, GROUP BY clause, or SELECT clause. -- You can use PARTITION BY together with a window clause or GROUP BY clause. In this case, the window or GROUP BY clause takes effect on every partition. For example, the following statement partitions the table by the location tag, performs downsampling over a 10 minute window, and returns the maximum value: +- The PARTITION BY clause must occur after the WHERE clause +- The PARTITION BY caluse partitions the data according to the specified dimentions, then perform computation on each partition. The performed computation is determined by the rest of the statement - a window clause, GROUP BY clause, or SELECT clause. +- The PARTITION BY clause can be used together with a window clause or GROUP BY clause. In this case, the window or GROUP BY clause takes effect on every partition. For example, the following statement partitions the table by the location tag, performs downsampling over a 10 minute window, and returns the maximum value: ```sql select max(current) from meters partition by location interval(10m) ``` +The most common usage of PARTITION BY is partitioning the data in subtables by tags then perform computation when querying data in a supertable. More specifically, `PARTITION BY TBNAME` partitions the data of each subtable into a single timeline, and this method facilitates the statistical analysis in many use cases of processing timeseries data. + ## Windowed Queries Aggregation by time window is supported in TDengine. For example, in the case where temperature sensors report the temperature every seconds, the average temperature for every 10 minutes can be retrieved by performing a query with a time window. Window related clauses are used to divide the data set to be queried into subsets and then aggregation is performed across the subsets. There are three kinds of windows: time window, status window, and session window. There are two kinds of time windows: sliding window and flip time/tumbling window. The query syntax is as follows: ```sql -SELECT function_list FROM tb_name +SELECT select_list FROM tb_name [WHERE where_condition] [SESSION(ts_col, tol_val)] [STATE_WINDOW(col)] @@ -42,12 +44,6 @@ SELECT function_list FROM tb_name The following restrictions apply: -### Restricted Functions - -- Aggregate functions and select functions can be used in `function_list`, with each function having only one output. For example COUNT, AVG, SUM, STDDEV, LEASTSQUARES, PERCENTILE, MIN, MAX, FIRST, LAST. Functions having multiple outputs, such as DIFF or arithmetic operations can't be used. -- `LAST_ROW` can't be used together with window aggregate. -- Scalar functions, like CEIL/FLOOR, can't be used with window aggregate. - ### Other Rules - The window clause must occur after the PARTITION BY clause and before the GROUP BY clause. It cannot be used with a GROUP BY clause. @@ -82,7 +78,7 @@ These pseudocolumns occur after the aggregation clause. 1. A huge volume of interpolation output may be returned using `FILL`, so it's recommended to specify the time range when using `FILL`. The maximum number of interpolation values that can be returned in a single query is 10,000,000. 2. The result set is in ascending order of timestamp when you aggregate by time window. -3. If aggregate by window is used on STable, the aggregate function is performed on all the rows matching the filter conditions. If `GROUP BY` is not used in the query, the result set will be returned in ascending order of timestamp; otherwise the result set is not exactly in the order of ascending timestamp in each group. +3. If aggregate by window is used on STable, the aggregate function is performed on all the rows matching the filter conditions. If `PARTITION BY` is not used in the query, the result set will be returned in strict ascending order of timestamp; otherwise the result set is not exactly in the order of ascending timestamp in each group. ::: @@ -112,9 +108,9 @@ When using time windows, note the following: Please note that the `timezone` parameter should be configured to be the same value in the `taos.cfg` configuration file on client side and server side. - The result set is in ascending order of timestamp when you aggregate by time window. -### Status Window +### State Window -In case of using integer, bool, or string to represent the status of a device at any given moment, continuous rows with the same status belong to a status window. Once the status changes, the status window closes. As shown in the following figure, there are two status windows according to status, [2019-04-28 14:22:07，2019-04-28 14:22:10] and [2019-04-28 14:22:11，2019-04-28 14:22:12]. Status window is not applicable to STable for now. +In case of using integer, bool, or string to represent the status of a device at any given moment, continuous rows with the same status belong to a status window. Once the status changes, the status window closes. As shown in the following figure, there are two state windows according to status, [2019-04-28 14:22:07，2019-04-28 14:22:10] and [2019-04-28 14:22:11，2019-04-28 14:22:12]. ![TDengine Database Status Window](./timewindow-3.webp) @@ -130,7 +126,7 @@ The primary key, i.e. timestamp, is used to determine which session window a row ![TDengine Database Session Window](./timewindow-2.webp) -If the time interval between two continuous rows are within the time interval specified by `tol_value` they belong to the same session window; otherwise a new session window is started automatically. Session window is not supported on STable for now. +If the time interval between two continuous rows are within the time interval specified by `tol_value` they belong to the same session window; otherwise a new session window is started automatically. ``` From bc49ecc385f6e268ed7dd4c370abbd17deb06d40 Mon Sep 17 00:00:00 2001 From: gccgdb1234 Date: Thu, 15 Sep 2022 17:10:47 +0800 Subject: [PATCH 116/138] doc: Grant of English version --- docs/en/12-taos-sql/25-grant.md | 54 ++++++++++++++++++++++++++++++--- 1 file changed, 50 insertions(+), 4 deletions(-) diff --git a/docs/en/12-taos-sql/25-grant.md b/docs/en/12-taos-sql/25-grant.md index b9a3fa2321..f895567c62 100644 --- a/docs/en/12-taos-sql/25-grant.md +++ b/docs/en/12-taos-sql/25-grant.md @@ -9,15 +9,54 @@ This document describes how to manage permissions in TDengine. ## Create a User ```sql -CREATE USER use_name PASS 'password'; +CREATE USER user_name PASS 'password' [SYSINFO {1|0}]; ``` This statement creates a user account. -The maximum length of use_name is 23 bytes. +The maximum length of user_name is 23 bytes. The maximum length of password is 128 bytes. The password can include leters, digits, and special characters excluding single quotation marks, double quotation marks, backticks, backslashes, and spaces. The password cannot be empty. +`SYSINFO` indicates whether the user is allowed to view system information. `1` means allowed, `0` means not allowed. System information includes server configuration, dnode, vnode, storage. The default value is `1`. + +For example, we can create a user whose password is `123456` and is able to view system information. + +```sql +taos> create user test pass '123456' sysinfo 1; +Query OK, 0 of 0 rows affected (0.001254s) +``` + +## View Users + +To show the users in the system, please use + +```sql +SHOW USERS; +``` + +This is an example: + +```sql +taos> show users; + name | super | enable | sysinfo | create_time | +================================================================================ + test | 0 | 1 | 1 | 2022-08-29 15:10:27.315 | + root | 1 | 1 | 1 | 2022-08-29 15:03:34.710 | +Query OK, 2 rows in database (0.001657s) +``` + +Alternatively, you can get the user information by querying a built-in table, INFORMATION_SCHEMA.INS_USERS. For example: + +```sql +taos> select * from information_schema.ins_users; + name | super | enable | sysinfo | create_time | +================================================================================ + test | 0 | 1 | 1 | 2022-08-29 15:10:27.315 | + root | 1 | 1 | 1 | 2022-08-29 15:03:34.710 | +Query OK, 2 rows in database (0.001953s) +``` + ## Delete a User ```sql @@ -40,6 +79,13 @@ alter_user_clause: { - ENABLE: Specify whether the user is enabled or disabled. 1 indicates enabled and 0 indicates disabled. - SYSINFO: Specify whether the user can query system information. 1 indicates that the user can query system information and 0 indicates that the user cannot query system information. +For example, you can use below command to disable user `test`: + +```sql +taos> alter user test enable 0; +Query OK, 0 of 0 rows affected (0.001160s) +``` + ## Grant Permissions @@ -62,7 +108,7 @@ priv_level : { } ``` -Grant permissions to a user. +Grant permissions to a user, this feature is only available in enterprise edition. Permissions are granted on the database level. You can grant read or write permissions. @@ -92,4 +138,4 @@ priv_level : { ``` -Revoke permissions from a user. +Revoke permissions from a user, this feature is only available in enterprise edition. From 6c8a01efaca37e6c0408980127ea38f6c287cb17 Mon Sep 17 00:00:00 2001 From: gccgdb1234 Date: Thu, 15 Sep 2022 17:20:15 +0800 Subject: [PATCH 117/138] doc: select.md --- docs/en/12-taos-sql/06-select.md | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) diff --git a/docs/en/12-taos-sql/06-select.md b/docs/en/12-taos-sql/06-select.md index 1f86111925..176a5488e1 100644 --- a/docs/en/12-taos-sql/06-select.md +++ b/docs/en/12-taos-sql/06-select.md @@ -348,19 +348,15 @@ SELECT ... FROM (SELECT ... FROM ...) ...; :::info -- Only one layer of nesting is allowed, that means no sub query is allowed within a sub query -- The result set returned by the inner query will be used as a "virtual table" by the outer query. The "virtual table" can be renamed using `AS` keyword for easy reference in the outer query. -- Sub query is not allowed in continuous query. +- The result of a nested query is returned as a virtual table used by the outer query. It's recommended to give an alias to this table for the convenience of using it in the outer query. - JOIN operation is allowed between tables/STables inside both inner and outer queries. Join operation can be performed on the result set of the inner query. -- UNION operation is not allowed in either inner query or outer query. -- The functions that can be used in the inner query are the same as those that can be used in a non-nested query. +- The features that can be used in the inner query are the same as those that can be used in a non-nested query. - `ORDER BY` inside the inner query is unnecessary and will slow down the query performance significantly. It is best to avoid the use of `ORDER BY` inside the inner query. - Compared to the non-nested query, the functionality that can be used in the outer query has the following restrictions: - Functions - - If the result set returned by the inner query doesn't contain timestamp column, then functions relying on timestamp can't be used in the outer query, like `TOP`, `BOTTOM`, `FIRST`, `LAST`, `DIFF`. - - Functions that need to scan the data twice can't be used in the outer query, like `STDDEV`, `PERCENTILE`. - - `IN` operator is not allowed in the outer query but can be used in the inner query. - - `GROUP BY` is not supported in the outer query. + - If the result set returned by the inner query doesn't contain timestamp column, then functions relying on timestamp can't be used in the outer query, like INTERP,DERIVATIVE, IRATE, LAST_ROW, FIRST, LAST, TWA, STATEDURATION, TAIL, UNIQUE. + - If the result set returned by the inner query are not valid time series, then functions relying on time series can't be used in the outer query, like LEASTSQUARES, ELAPSED, INTERP, DERIVATIVE, IRATE, TWA, DIFF, STATECOUNT, STATEDURATION, CSUM, MAVG, TAIL, UNIQUE. + - Functions that need to scan the data twice can't be used in the outer query, like PERCENTILE. ::: From fe29f000193f79977b79b45fe33194c988e1078c Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Thu, 15 Sep 2022 17:23:48 +0800 Subject: [PATCH 118/138] fix: fix deadlock --- source/client/src/clientHb.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/source/client/src/clientHb.c b/source/client/src/clientHb.c index a7e42a01a3..7ce80553a0 100644 --- a/source/client/src/clientHb.c +++ b/source/client/src/clientHb.c @@ -707,6 +707,7 @@ static void *hbThreadFunc(void *param) { int32_t connCnt = atomic_load_32(&pAppHbMgr->connKeyCnt); if (connCnt == 0) { + taosArrayPush(mgr, &pAppHbMgr); continue; } SClientHbBatchReq *pReq = hbGatherAllInfo(pAppHbMgr); @@ -720,6 +721,7 @@ static void *hbThreadFunc(void *param) { terrno = TSDB_CODE_TSC_OUT_OF_MEMORY; tFreeClientHbBatchReq(pReq); // hbClearReqInfo(pAppHbMgr); + taosArrayPush(mgr, &pAppHbMgr); break; } @@ -731,6 +733,7 @@ static void *hbThreadFunc(void *param) { tFreeClientHbBatchReq(pReq); // hbClearReqInfo(pAppHbMgr); taosMemoryFree(buf); + taosArrayPush(mgr, &pAppHbMgr); break; } pInfo->fp = hbAsyncCallBack; From 6fe3141bd8cfd1f38e4c96790bddce93326438d4 Mon Sep 17 00:00:00 2001 From: wade zhang <95411902+gccgdb1234@users.noreply.github.com> Date: Thu, 15 Sep 2022 17:36:21 +0800 Subject: [PATCH 119/138] Update 06-select.md --- docs/zh/12-taos-sql/06-select.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/zh/12-taos-sql/06-select.md b/docs/zh/12-taos-sql/06-select.md index 0d38cb0635..c3e2e7540f 100644 --- a/docs/zh/12-taos-sql/06-select.md +++ b/docs/zh/12-taos-sql/06-select.md @@ -356,7 +356,7 @@ SELECT ... FROM (SELECT ... FROM ...) ...; - 与非嵌套的查询语句相比，外层查询所能支持的功能特性存在如下限制： - 计算函数部分： - 如果内层查询的结果数据未提供时间戳，那么计算过程隐式依赖时间戳的函数在外层会无法正常工作。例如：INTERP, DERIVATIVE, IRATE, LAST_ROW, FIRST, LAST, TWA, STATEDURATION, TAIL, UNIQUE。 - - 如果内层查询的结果数据不是有效的时间序列，那么计算过程依赖数据为时间序列的函数在外层会无法正常工作。例如：LEASTSQUARES, ELAPSED, INTERP, DERIVATIVE, IRATE, TWA, DIFF, STATECOUNT, STATEDURATION, CSUM, MAVG, TAIL, UNIQUE。 + - 如果内层查询的结果数据不是按时间戳有序，那么计算过程依赖数据为时间序列的函数在外层会无法正常工作。例如：LEASTSQUARES, ELAPSED, INTERP, DERIVATIVE, IRATE, TWA, DIFF, STATECOUNT, STATEDURATION, CSUM, MAVG, TAIL, UNIQUE。 - 计算过程需要两遍扫描的函数，在外层查询中无法正常工作。例如：此类函数包括：PERCENTILE。 ::: From 22e306c73767453e3bd40dbc4dbc4c38e9ca9ac2 Mon Sep 17 00:00:00 2001 From: wade zhang <95411902+gccgdb1234@users.noreply.github.com> Date: Thu, 15 Sep 2022 17:38:06 +0800 Subject: [PATCH 120/138] Update 06-select.md --- docs/en/12-taos-sql/06-select.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/en/12-taos-sql/06-select.md b/docs/en/12-taos-sql/06-select.md index 176a5488e1..118a248373 100644 --- a/docs/en/12-taos-sql/06-select.md +++ b/docs/en/12-taos-sql/06-select.md @@ -355,7 +355,7 @@ SELECT ... FROM (SELECT ... FROM ...) ...; - Compared to the non-nested query, the functionality that can be used in the outer query has the following restrictions: - Functions - If the result set returned by the inner query doesn't contain timestamp column, then functions relying on timestamp can't be used in the outer query, like INTERP,DERIVATIVE, IRATE, LAST_ROW, FIRST, LAST, TWA, STATEDURATION, TAIL, UNIQUE. - - If the result set returned by the inner query are not valid time series, then functions relying on time series can't be used in the outer query, like LEASTSQUARES, ELAPSED, INTERP, DERIVATIVE, IRATE, TWA, DIFF, STATECOUNT, STATEDURATION, CSUM, MAVG, TAIL, UNIQUE. + - If the result set returned by the inner query are not sorted in order by timestamp, then functions relying on data ordered by timestamp can't be used in the outer query, like LEASTSQUARES, ELAPSED, INTERP, DERIVATIVE, IRATE, TWA, DIFF, STATECOUNT, STATEDURATION, CSUM, MAVG, TAIL, UNIQUE. - Functions that need to scan the data twice can't be used in the outer query, like PERCENTILE. ::: From aabdb1e27b4eee445a167605f19de6426042594a Mon Sep 17 00:00:00 2001 From: wade zhang <95411902+gccgdb1234@users.noreply.github.com> Date: Thu, 15 Sep 2022 17:38:43 +0800 Subject: [PATCH 121/138] Update 06-select.md --- docs/zh/12-taos-sql/06-select.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/zh/12-taos-sql/06-select.md b/docs/zh/12-taos-sql/06-select.md index c3e2e7540f..c49351b0c9 100644 --- a/docs/zh/12-taos-sql/06-select.md +++ b/docs/zh/12-taos-sql/06-select.md @@ -356,7 +356,7 @@ SELECT ... FROM (SELECT ... FROM ...) ...; - 与非嵌套的查询语句相比，外层查询所能支持的功能特性存在如下限制： - 计算函数部分： - 如果内层查询的结果数据未提供时间戳，那么计算过程隐式依赖时间戳的函数在外层会无法正常工作。例如：INTERP, DERIVATIVE, IRATE, LAST_ROW, FIRST, LAST, TWA, STATEDURATION, TAIL, UNIQUE。 - - 如果内层查询的结果数据不是按时间戳有序，那么计算过程依赖数据为时间序列的函数在外层会无法正常工作。例如：LEASTSQUARES, ELAPSED, INTERP, DERIVATIVE, IRATE, TWA, DIFF, STATECOUNT, STATEDURATION, CSUM, MAVG, TAIL, UNIQUE。 + - 如果内层查询的结果数据不是按时间戳有序，那么计算过程依赖数据按时间有序的函数在外层会无法正常工作。例如：LEASTSQUARES, ELAPSED, INTERP, DERIVATIVE, IRATE, TWA, DIFF, STATECOUNT, STATEDURATION, CSUM, MAVG, TAIL, UNIQUE。 - 计算过程需要两遍扫描的函数，在外层查询中无法正常工作。例如：此类函数包括：PERCENTILE。 ::: From 0c71d957735c221d8c231e632e908f033e5035f4 Mon Sep 17 00:00:00 2001 From: Haojun Liao Date: Thu, 15 Sep 2022 17:44:28 +0800 Subject: [PATCH 122/138] fix(query):set correct block load condition. --- source/dnode/vnode/src/tsdb/tsdbRead.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/source/dnode/vnode/src/tsdb/tsdbRead.c b/source/dnode/vnode/src/tsdb/tsdbRead.c index 34737bb7fd..6a8de672f1 100644 --- a/source/dnode/vnode/src/tsdb/tsdbRead.c +++ b/source/dnode/vnode/src/tsdb/tsdbRead.c @@ -2096,8 +2096,10 @@ static int32_t buildComposedDataBlock(STsdbReader* pReader) { // it is a clean block, load it directly if (isCleanFileDataBlock(pReader, pBlockInfo, pBlock, pBlockScanInfo, keyInBuf, pLastBlockReader)) { - copyBlockDataToSDataBlock(pReader, pBlockScanInfo); - goto _end; + if (pReader->order == TSDB_ORDER_ASC || (pReader->order == TSDB_ORDER_DESC && (!hasDataInLastBlock(pLastBlockReader)))) { + copyBlockDataToSDataBlock(pReader, pBlockScanInfo); + goto _end; + } } } else { // file blocks not exist pBlockScanInfo = pReader->status.pTableIter; From 3ee376c2c098f4cfe23f57038bf65eba9c5820e0 Mon Sep 17 00:00:00 2001 From: Cary Xu Date: Thu, 15 Sep 2022 18:37:26 +0800 Subject: [PATCH 123/138] fix: revert the code change --- source/dnode/vnode/src/tsdb/tsdbRetention.c | 12 +----------- 1 file changed, 1 insertion(+), 11 deletions(-) diff --git a/source/dnode/vnode/src/tsdb/tsdbRetention.c b/source/dnode/vnode/src/tsdb/tsdbRetention.c index eb4151079b..2c68c57176 100644 --- a/source/dnode/vnode/src/tsdb/tsdbRetention.c +++ b/source/dnode/vnode/src/tsdb/tsdbRetention.c @@ -16,19 +16,9 @@ #include "tsdb.h" static bool tsdbShouldDoRetention(STsdb *pTsdb, int64_t now) { - STsdbKeepCfg *keepCfg = &pTsdb->keepCfg; - - if ((keepCfg->keep0 == keepCfg->keep1) && (keepCfg->keep1 == keepCfg->keep2)) { - return false; - } - - if (tfsGetLevel(pTsdb->pVnode->pTfs) <= 1) { - return false; - } - for (int32_t iSet = 0; iSet < taosArrayGetSize(pTsdb->fs.aDFileSet); iSet++) { SDFileSet *pSet = (SDFileSet *)taosArrayGet(pTsdb->fs.aDFileSet, iSet); - int32_t expLevel = tsdbFidLevel(pSet->fid, keepCfg, now); + int32_t expLevel = tsdbFidLevel(pSet->fid, &pTsdb->keepCfg, now); SDiskID did; if (expLevel == pSet->diskId.level) continue; From e6bb4c1aead0e3f156b13d4536fd9966373c194b Mon Sep 17 00:00:00 2001 From: afwerar <1296468573@qq.com> Date: Thu, 15 Sep 2022 21:25:45 +0800 Subject: [PATCH 124/138] build: release ver-3.0.1.1 --- cmake/cmake.version | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/cmake.version b/cmake/cmake.version index 7c895b12ff..d5721f7671 100644 --- a/cmake/cmake.version +++ b/cmake/cmake.version @@ -2,7 +2,7 @@ IF (DEFINED VERNUMBER) SET(TD_VER_NUMBER ${VERNUMBER}) ELSE () - SET(TD_VER_NUMBER "3.0.1.0") + SET(TD_VER_NUMBER "3.0.1.1") ENDIF () IF (DEFINED VERCOMPATIBLE) From 16ed1f3e2d12e1e57f0b48a89c8e3659b1dd73b8 Mon Sep 17 00:00:00 2001 From: Chait Diwadkar <94201190+cdiwadkar16@users.noreply.github.com> Date: Thu, 15 Sep 2022 11:28:02 -0700 Subject: [PATCH 125/138] docs:cdiwadkar16-patch-1 - create Jupyterlab tech doc for 3.0 This is the Juptyerlab doc for 3.0 --- docs/en/20-third-party/13-Jupyter.md | 98 ++++++++++++++++++++++++++++ 1 file changed, 98 insertions(+) create mode 100644 docs/en/20-third-party/13-Jupyter.md diff --git a/docs/en/20-third-party/13-Jupyter.md b/docs/en/20-third-party/13-Jupyter.md new file mode 100644 index 0000000000..fbd7e530f0 --- /dev/null +++ b/docs/en/20-third-party/13-Jupyter.md @@ -0,0 +1,98 @@ +--- +sidebar_label: JupyterLab +title: Connect JupyterLab to TDengine +--- + +JupyterLab is the next generation of the ubiquitous Jupyter Notebook. In this note we show you how to install the TDengine Python connector to connect to TDengine in JupyterLab. You can then insert data and perform queries against the TDengine instance within JupyterLab. + +## Install JupyterLab +Installing JupyterLab is very easy. Installation instructions can be found at: + +https://jupyterlab.readthedocs.io/en/stable/getting_started/installation.html. + +If you don't feel like clicking on the link here are the instructions. +Jupyter's preferred Python package manager is pip, so we show the instructions for pip. +You can also use **conda** or **pipenv** if you are managing Python environments. +```` +pip install jupyterlab +```` + +For **conda** you can run: +```` +conda install -c conda-forge jupyterlab +```` + +For **pipenv** you can run: +```` +pipenv install jupyterlab +pipenv shell +```` + +## Run JupyterLab +You can start JupyterLab from the command line by running: +```` +jupyter lab +```` +This will automatically launch your default browser and connect to your JupyterLab instance, usually on port 8888. + +## Install the TDengine Python connector +You can now install the TDengine Python connector as follows. + +Start a new Python kernel in JupyterLab. + +If using **conda** run the following: +```` +# Install a conda package in the current Jupyter kernel +import sys +!conda install --yes --prefix {sys.prefix} taospy +```` +If using **pip** run the following: +```` +# Install a pip package in the current Jupyter kernel +import sys +!{sys.executable} -m pip install taospy +```` + +## Connect to TDengine +You can find detailed examples to use the Python connector, in the TDengine documentation here. +Once you have installed the TDengine Python connector in your JupyterLab kernel, the process of connecting to TDengine is the same as that you would use if you weren't using JupyterLab. +Each TDengine instance, has a database called "log" which has monitoring information about the TDengine instance. +In the "log" database there is a [supertable](https://docs.tdengine.com/taos-sql/stable/) called "disks_info". + +The structure of this table is as follows: +```` +taos> desc disks_info; + Field | Type | Length | Note | +================================================================================= + ts | TIMESTAMP | 8 | | + datadir_l0_used | FLOAT | 4 | | + datadir_l0_total | FLOAT | 4 | | + datadir_l1_used | FLOAT | 4 | | + datadir_l1_total | FLOAT | 4 | | + datadir_l2_used | FLOAT | 4 | | + datadir_l2_total | FLOAT | 4 | | + dnode_id | INT | 4 | TAG | + dnode_ep | BINARY | 134 | TAG | +Query OK, 9 row(s) in set (0.000238s) +```` + +The code below is used to fetch data from this table into a pandas DataFrame. + +```` +import sys +import taos +import pandas + +def sqlQuery(conn): + df: pandas.DataFrame = pandas.read_sql("select * from log.disks_info limit 500", conn) + print(df) + return df + +conn = taos.connect() + +result = sqlQuery(conn) + +print(result) +```` + +TDengine has connectors for various languages including Node.js, Go, PHP and there are kernels for these languages which can be found [here](https://github.com/jupyter/jupyter/wiki/Jupyter-kernels). From 9816298caf51f1610934036686a7b0ce693c2af2 Mon Sep 17 00:00:00 2001 From: Jeff Tao Date: Thu, 15 Sep 2022 12:58:22 -0700 Subject: [PATCH 126/138] Update README.md --- README.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 611d97aac9..973d7f184a 100644 --- a/README.md +++ b/README.md @@ -15,7 +15,7 @@ [![Coverage Status](https://coveralls.io/repos/github/taosdata/TDengine/badge.svg?branch=develop)](https://coveralls.io/github/taosdata/TDengine?branch=develop) [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/4201/badge)](https://bestpractices.coreinfrastructure.org/projects/4201) -English | [简体中文](README-CN.md) | We are hiring, check [here](https://tdengine.com/careers) +English | [简体中文](README-CN.md) | [Lean more about TSDB](https://tdengine.com/tsdb) # What is TDengine？ @@ -319,6 +319,7 @@ TDengine provides abundant developing tools for users to develop on TDengine. Fo Please follow the [contribution guidelines](CONTRIBUTING.md) to contribute to the project. -# Join TDengine WeChat Group +# Join TDengine User Community -Add WeChat “tdengine” to join the group，you can communicate with other users. +- Join [TDengine Discord Channel](https://discord.com/invite/VZdSuUg4pS?utm_id=discord) +- Join wechat group by adding WeChat “tdengine” From 0fcb94cfe4974b96679e568d1e8233305f2d1fb6 Mon Sep 17 00:00:00 2001 From: Jeff Tao Date: Thu, 15 Sep 2022 13:00:18 -0700 Subject: [PATCH 127/138] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 973d7f184a..8ead62a3ce 100644 --- a/README.md +++ b/README.md @@ -19,7 +19,7 @@ English | [简体中文](README-CN.md) | [Lean more about TSDB](https://tdengine # What is TDengine？ -TDengine is an open source, high-performance, cloud native [time-series database](https://tdengine.com/tsdb/what-is-a-time-series-database/) optimized for Internet of Things (IoT), Connected Cars, and Industrial IoT. It enables efficient, real-time data ingestion, processing, and monitoring of TB and even PB scale data per day, generated by billions of sensors and data collectors. TDengine differentiates itself from other time-seires databases with the following advantages: +TDengine is an open source, high-performance, cloud native [time-series database](https://tdengine.com/tsdb/) optimized for Internet of Things (IoT), Connected Cars, and Industrial IoT. It enables efficient, real-time data ingestion, processing, and monitoring of TB and even PB scale data per day, generated by billions of sensors and data collectors. TDengine differentiates itself from other time-seires databases with the following advantages: - **[High-Performance](https://tdengine.com/tdengine/high-performance-time-series-database/)**: TDengine is the only time-series database to solve the high cardinality issue to support billions of data collection points while out performing other time-series databases for data ingestion, querying and data compression. From c77aa7004d0f0f34b1af489424ba8814eb47215a Mon Sep 17 00:00:00 2001 From: Jeff Tao Date: Thu, 15 Sep 2022 13:06:56 -0700 Subject: [PATCH 128/138] Update 01-index.md --- docs/en/01-index.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/docs/en/01-index.md b/docs/en/01-index.md index 5265be42f8..13552ea9dc 100644 --- a/docs/en/01-index.md +++ b/docs/en/01-index.md @@ -4,7 +4,7 @@ sidebar_label: Documentation Home slug: / --- -TDengine is an [open-source](https://tdengine.com/tdengine/open-source-time-series-database/), [cloud-native](https://tdengine.com/tdengine/cloud-native-time-series-database/) time-series database optimized for the Internet of Things (IoT), Connected Cars, and Industrial IoT. It enables efficient, real-time data ingestion, processing, and monitoring of TB and even PB scale data per day, generated by billions of sensors and data collectors. This document is the TDengine user manual. It introduces the basic, as well as novel concepts, in TDengine, and also talks in detail about installation, features, SQL, APIs, operation, maintenance, kernel design, and other topics. It’s written mainly for architects, developers, and system administrators. +TDengine is an [open-source](https://tdengine.com/tdengine/open-source-time-series-database/), [cloud-native](https://tdengine.com/tdengine/cloud-native-time-series-database/) [time-series database](https://tdengine.com/tsdb/) optimized for the Internet of Things (IoT), Connected Cars, and Industrial IoT. It enables efficient, real-time data ingestion, processing, and monitoring of TB and even PB scale data per day, generated by billions of sensors and data collectors. This document is the TDengine user manual. It introduces the basic, as well as novel concepts, in TDengine, and also talks in detail about installation, features, SQL, APIs, operation, maintenance, kernel design, and other topics. It’s written mainly for architects, developers, and system administrators. To get an overview of TDengine, such as a feature list, benchmarks, and competitive advantages, please browse through the [Introduction](./intro) section. @@ -22,6 +22,8 @@ If you want to know more about TDengine tools, the REST API, and connectors for If you are very interested in the internal design of TDengine, please read the chapter [Inside TDengine](./tdinternal), which introduces the cluster design, data partitioning, sharding, writing, and reading processes in detail. If you want to study TDengine code or even contribute code, please read this chapter carefully. +To get more general introduction about time series database, please read through [a series of articles](https://tdengine.com/tsdb/). To lean more competitive advantages about TDengine, please read through [a series of blogs](https://tdengine.com/tdengine/). + TDengine is an open-source database, and we would love for you to be a part of TDengine. If you find any errors in the documentation or see parts where more clarity or elaboration is needed, please click "Edit this page" at the bottom of each page to edit it directly. Together, we make a difference! From 9506603bb82e0edcdf08d058e23ca85f758c9754 Mon Sep 17 00:00:00 2001 From: Jeff Tao Date: Thu, 15 Sep 2022 13:11:12 -0700 Subject: [PATCH 129/138] Update index.md --- docs/en/02-intro/index.md | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/docs/en/02-intro/index.md b/docs/en/02-intro/index.md index d385845d7c..3d1b505732 100644 --- a/docs/en/02-intro/index.md +++ b/docs/en/02-intro/index.md @@ -3,7 +3,7 @@ title: Introduction toc_max_heading_level: 2 --- -TDengine is an open source, high-performance, cloud native [time-series database](https://tdengine.com/tsdb/) optimized for Internet of Things (IoT), Connected Cars, and Industrial IoT. Its code, including its cluster feature is open source under GNU AGPL v3.0. Besides the database engine, it provides [caching](../develop/cache), [stream processing](../develop/stream), [data subscription](../develop/tmq) and other functionalities to reduce the system complexity and cost of development and operation. +TDengine is an [open source](https://tdengine.com/tdengine/open-source-time-series-database/), [high-performance](https://tdengine.com/tdengine/high-performance-time-series-database/), cloud native [time-series database](https://tdengine.com/tsdb/) optimized for Internet of Things (IoT), Connected Cars, and Industrial IoT. Its code, including its cluster feature is open source under GNU AGPL v3.0. Besides the database engine, it provides [caching](../develop/cache), [stream processing](../develop/stream), [data subscription](../develop/tmq) and other functionalities to reduce the system complexity and cost of development and operation. This section introduces the major features, competitive advantages, typical use-cases and benchmarks to help you get a high level overview of TDengine. @@ -43,7 +43,7 @@ For more details on features, please read through the entire documentation. ## Competitive Advantages -By making full use of [characteristics of time series data](https://tdengine.com/tsdb/characteristics-of-time-series-data/), TDengine differentiates itself from other time series databases, with the following advantages. +By making full use of [characteristics of time series data](https://tdengine.com/tsdb/characteristics-of-time-series-data/), TDengine differentiates itself from other [time series databases](https://tdengine.com/tsdb), with the following advantages. - **[High-Performance](https://tdengine.com/tdengine/high-performance-time-series-database/)**: TDengine is the only time-series database to solve the high cardinality issue to support billions of data collection points while out performing other time-series databases for data ingestion, querying and data compression. @@ -127,3 +127,8 @@ As a high-performance, scalable and SQL supported time-series database, TDengine - [TDengine vs OpenTSDB](https://tdengine.com/2019/09/12/710.html) - [TDengine vs Cassandra](https://tdengine.com/2019/09/12/708.html) - [TDengine vs InfluxDB](https://tdengine.com/2019/09/12/706.html) + +## More readings +- [Introduction to Time-Series Database](https://tdengine.com/tsdb/) +- [Introduction to TDengine competitive advantages](https://tdengine.com/tdengine/) + From de05b2cf3cb57f89fe8b80144ed28e84546e4559 Mon Sep 17 00:00:00 2001 From: Jeff Tao Date: Thu, 15 Sep 2022 13:12:07 -0700 Subject: [PATCH 130/138] Update index.md --- docs/en/02-intro/index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/en/02-intro/index.md b/docs/en/02-intro/index.md index 3d1b505732..2084088352 100644 --- a/docs/en/02-intro/index.md +++ b/docs/en/02-intro/index.md @@ -3,7 +3,7 @@ title: Introduction toc_max_heading_level: 2 --- -TDengine is an [open source](https://tdengine.com/tdengine/open-source-time-series-database/), [high-performance](https://tdengine.com/tdengine/high-performance-time-series-database/), cloud native [time-series database](https://tdengine.com/tsdb/) optimized for Internet of Things (IoT), Connected Cars, and Industrial IoT. Its code, including its cluster feature is open source under GNU AGPL v3.0. Besides the database engine, it provides [caching](../develop/cache), [stream processing](../develop/stream), [data subscription](../develop/tmq) and other functionalities to reduce the system complexity and cost of development and operation. +TDengine is an [open source](https://tdengine.com/tdengine/open-source-time-series-database/), [high-performance](https://tdengine.com/tdengine/high-performance-time-series-database/), [cloud native](https://tdengine.com/tdengine/cloud-native-time-series-database/) [time-series database](https://tdengine.com/tsdb/) optimized for Internet of Things (IoT), Connected Cars, and Industrial IoT. Its code, including its cluster feature is open source under GNU AGPL v3.0. Besides the database engine, it provides [caching](../develop/cache), [stream processing](../develop/stream), [data subscription](../develop/tmq) and other functionalities to reduce the system complexity and cost of development and operation. This section introduces the major features, competitive advantages, typical use-cases and benchmarks to help you get a high level overview of TDengine. From d24339012601322e5722e44b7069c5755726d25d Mon Sep 17 00:00:00 2001 From: Jeff Tao Date: Thu, 15 Sep 2022 13:29:15 -0700 Subject: [PATCH 131/138] Update README.md --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 8ead62a3ce..a8126d74d4 100644 --- a/README.md +++ b/README.md @@ -33,6 +33,8 @@ TDengine is an open source, high-performance, cloud native [time-series database - **[Open Source](https://tdengine.com/tdengine/open-source-time-series-database/)**: TDengine’s core modules, including cluster feature, are all available under open source licenses. It has gathered 18.8k stars on GitHub. There is an active developer community, and over 139k running instances worldwide. +For a full list of TDengine competitive advantages, please [check here](https://tdengine.com/tdengine/) + # Documentation For user manual, system design and architecture, please refer to [TDengine Documentation](https://docs.tdengine.com) ([TDengine 文档](https://docs.taosdata.com)) From eb9191954b33f62e6d104189ee1fa1e7c6f53317 Mon Sep 17 00:00:00 2001 From: dingbo Date: Fri, 16 Sep 2022 09:50:01 +0800 Subject: [PATCH 132/138] release 3.0.1.1 --- docs/zh/28-releases/01-tdengine.md | 5 +++++ docs/zh/28-releases/02-tools.md | 4 ++++ 2 files changed, 9 insertions(+) diff --git a/docs/zh/28-releases/01-tdengine.md b/docs/zh/28-releases/01-tdengine.md index a6ec560d3c..59a241b6c8 100644 --- a/docs/zh/28-releases/01-tdengine.md +++ b/docs/zh/28-releases/01-tdengine.md @@ -6,6 +6,11 @@ description: TDengine 发布历史、Release Notes 及下载链接 import Release from "/components/ReleaseV3"; + +## 3.0.1.1 + + + ## 3.0.1.0 diff --git a/docs/zh/28-releases/02-tools.md b/docs/zh/28-releases/02-tools.md index 9e8757cc4e..79ae3c4e8a 100644 --- a/docs/zh/28-releases/02-tools.md +++ b/docs/zh/28-releases/02-tools.md @@ -6,6 +6,10 @@ description: taosTools 的发布历史、Release Notes 和下载链接 import Release from "/components/ReleaseV3"; +## 2.2.0 + + + ## 2.1.3 From 36a8d4ffc472aa95ccfdc09fb21626caedd2f4e5 Mon Sep 17 00:00:00 2001 From: dingbo Date: Fri, 16 Sep 2022 10:00:43 +0800 Subject: [PATCH 133/138] release tools 2.2.0 --- docs/zh/28-releases/02-tools.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/zh/28-releases/02-tools.md b/docs/zh/28-releases/02-tools.md index 79ae3c4e8a..9ff8f42224 100644 --- a/docs/zh/28-releases/02-tools.md +++ b/docs/zh/28-releases/02-tools.md @@ -8,7 +8,7 @@ import Release from "/components/ReleaseV3"; ## 2.2.0 - + ## 2.1.3 From 45d47afc790435e3f0e6b3d70d60c9ad524ba56c Mon Sep 17 00:00:00 2001 From: dingbo Date: Fri, 16 Sep 2022 10:55:28 +0800 Subject: [PATCH 134/138] release page of en docs --- docs/en/28-releases.md | 9 --------- docs/en/28-releases/01-tdengine.md | 17 +++++++++++++++++ docs/en/28-releases/02-tools.md | 15 +++++++++++++++ docs/en/28-releases/_category_.yml | 1 + 4 files changed, 33 insertions(+), 9 deletions(-) delete mode 100644 docs/en/28-releases.md create mode 100644 docs/en/28-releases/01-tdengine.md create mode 100644 docs/en/28-releases/02-tools.md create mode 100644 docs/en/28-releases/_category_.yml diff --git a/docs/en/28-releases.md b/docs/en/28-releases.md deleted file mode 100644 index a0c9eb1199..0000000000 --- a/docs/en/28-releases.md +++ /dev/null @@ -1,9 +0,0 @@ ---- -sidebar_label: Releases -title: Released Versions ---- - -import Release from "/components/ReleaseV3"; - - - diff --git a/docs/en/28-releases/01-tdengine.md b/docs/en/28-releases/01-tdengine.md new file mode 100644 index 0000000000..e3901114d3 --- /dev/null +++ b/docs/en/28-releases/01-tdengine.md @@ -0,0 +1,17 @@ +--- +sidebar_label: TDengine +title: TDengine +description: TDengine release history, Release Notes and download links. +--- + +import Release from "/components/ReleaseV3"; + + +## 3.0.1.1 + + + +## 3.0.1.0 + + + diff --git a/docs/en/28-releases/02-tools.md b/docs/en/28-releases/02-tools.md new file mode 100644 index 0000000000..228990df3b --- /dev/null +++ b/docs/en/28-releases/02-tools.md @@ -0,0 +1,15 @@ +--- +sidebar_label: taosTools +title: taosTools +description: taosTools release history, Release Notes, download links. +--- + +import Release from "/components/ReleaseV3"; + +## 2.2.0 + + + +## 2.1.3 + + diff --git a/docs/en/28-releases/_category_.yml b/docs/en/28-releases/_category_.yml new file mode 100644 index 0000000000..c163835206 --- /dev/null +++ b/docs/en/28-releases/_category_.yml @@ -0,0 +1 @@ +label: Releases \ No newline at end of file From cc932bc8d0b5ca16f5e08807b81583d7e7db4132 Mon Sep 17 00:00:00 2001 From: dingbo Date: Fri, 16 Sep 2022 11:11:39 +0800 Subject: [PATCH 135/138] docs: fix broken links --- docs/en/05-get-started/03-package.md | 2 +- docs/en/14-reference/03-connector/_linux_install.mdx | 2 +- docs/en/14-reference/03-connector/_windows_install.mdx | 2 +- docs/en/14-reference/04-taosadapter.md | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/en/05-get-started/03-package.md b/docs/en/05-get-started/03-package.md index b0400de673..292fa82183 100644 --- a/docs/en/05-get-started/03-package.md +++ b/docs/en/05-get-started/03-package.md @@ -111,7 +111,7 @@ Note: TDengine only supports Windows Server 2016/2019 and Windows 10/11 on the W :::info -For information about TDengine releases, see [Release History](../../releases). +For information about TDengine releases, see [Release History](../../releases/tdengine). ::: :::note diff --git a/docs/en/14-reference/03-connector/_linux_install.mdx b/docs/en/14-reference/03-connector/_linux_install.mdx index 07f8fb5c71..97f6cd3339 100644 --- a/docs/en/14-reference/03-connector/_linux_install.mdx +++ b/docs/en/14-reference/03-connector/_linux_install.mdx @@ -4,7 +4,7 @@ import PkgListV3 from "/components/PkgListV3"; - [All Downloads](../../releases) + [All Downloads](../../releases/tdengine) 2. Unzip diff --git a/docs/en/14-reference/03-connector/_windows_install.mdx b/docs/en/14-reference/03-connector/_windows_install.mdx index ea638ed1ed..81fc5573bb 100644 --- a/docs/en/14-reference/03-connector/_windows_install.mdx +++ b/docs/en/14-reference/03-connector/_windows_install.mdx @@ -4,7 +4,7 @@ import PkgListV3 from "/components/PkgListV3"; - [All Downloads](../../releases) + [All Downloads](../../releases/tdengine) 2. Execute the installer, select the default value as prompted, and complete the installation 3. Installation path diff --git a/docs/en/14-reference/04-taosadapter.md b/docs/en/14-reference/04-taosadapter.md index e7ea620d0b..78c4febb92 100644 --- a/docs/en/14-reference/04-taosadapter.md +++ b/docs/en/14-reference/04-taosadapter.md @@ -30,7 +30,7 @@ taosAdapter provides the following features. ### Install taosAdapter -If you use the TDengine server, you don't need additional steps to install taosAdapter. You can download taosAdapter from [TDengine 3.0 released versions](../../releases) to download the TDengine server installation package. If you need to deploy taosAdapter separately on another server other than the TDengine server, you should install the full TDengine server package on that server to install taosAdapter. If you need to build taosAdapter from source code, you can refer to the [Building taosAdapter]( https://github.com/taosdata/taosadapter/blob/3.0/BUILD.md) documentation. +If you use the TDengine server, you don't need additional steps to install taosAdapter. You can download taosAdapter from [TDengine 3.0 released versions](../../releases/tdengine) to download the TDengine server installation package. If you need to deploy taosAdapter separately on another server other than the TDengine server, you should install the full TDengine server package on that server to install taosAdapter. If you need to build taosAdapter from source code, you can refer to the [Building taosAdapter]( https://github.com/taosdata/taosadapter/blob/3.0/BUILD.md) documentation. ### Start/Stop taosAdapter From 88ce98cdfa9436e9b25334de4701852c462f3cc7 Mon Sep 17 00:00:00 2001 From: dingbo Date: Fri, 16 Sep 2022 11:15:33 +0800 Subject: [PATCH 136/138] docs: fix format error --- docs/zh/05-get-started/03-package.md | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/zh/05-get-started/03-package.md b/docs/zh/05-get-started/03-package.md index 66863d1bd9..2c857d37f3 100644 --- a/docs/zh/05-get-started/03-package.md +++ b/docs/zh/05-get-started/03-package.md @@ -73,6 +73,7 @@ install.sh 安装脚本在执行过程中，会通过命令行交互界面询问 + 可以使用 `apt-get` 工具从官方仓库安装。 **配置包仓库** From 0e308d29ebb8427e2a51f5a9ac10a0858407e904 Mon Sep 17 00:00:00 2001 From: Haojun Liao Date: Fri, 16 Sep 2022 12:06:37 +0800 Subject: [PATCH 137/138] fix(query): check the duplicate before adding table into query list --- source/dnode/vnode/src/vnd/vnodeSvr.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/source/dnode/vnode/src/vnd/vnodeSvr.c b/source/dnode/vnode/src/vnd/vnodeSvr.c index 51d83d8eed..e2641aad86 100644 --- a/source/dnode/vnode/src/vnd/vnodeSvr.c +++ b/source/dnode/vnode/src/vnd/vnodeSvr.c @@ -885,6 +885,8 @@ static int32_t vnodeProcessSubmitReq(SVnode *pVnode, int64_t version, void *pReq if (NULL != submitBlkRsp.pMeta) { vnodeUpdateMetaRsp(pVnode, submitBlkRsp.pMeta); } + + taosArrayPush(newTbUids, &createTbReq.uid); } taosArrayPush(newTbUids, &createTbReq.uid); From 15f656e683691d5cc0e385390d7d2795856b489d Mon Sep 17 00:00:00 2001 From: Haojun Liao Date: Fri, 16 Sep 2022 13:06:57 +0800 Subject: [PATCH 138/138] refactor(query): add some logs. --- source/dnode/vnode/src/tsdb/tsdbRead.c | 4 ++-- source/dnode/vnode/src/vnd/vnodeSvr.c | 7 ++++++- source/libs/executor/src/executor.c | 25 ++++++++++++++++++++----- source/libs/executor/src/scanoperator.c | 13 +++++++++++-- 4 files changed, 39 insertions(+), 10 deletions(-) diff --git a/source/dnode/vnode/src/tsdb/tsdbRead.c b/source/dnode/vnode/src/tsdb/tsdbRead.c index 22727a4311..14dbfbd63e 100644 --- a/source/dnode/vnode/src/tsdb/tsdbRead.c +++ b/source/dnode/vnode/src/tsdb/tsdbRead.c @@ -3719,8 +3719,8 @@ int32_t tsdbReaderReset(STsdbReader* pReader, SQueryTableDataCond* pCond) { } } - tsdbDebug("%p reset reader, suid:%" PRIu64 ", numOfTables:%d, query range:%" PRId64 " - %" PRId64 " in query %s", - pReader, pReader->suid, numOfTables, pReader->window.skey, pReader->window.ekey, pReader->idStr); + tsdbDebug("%p reset reader, suid:%" PRIu64 ", numOfTables:%d, skey:%"PRId64", query range:%" PRId64 " - %" PRId64 " in query %s", + pReader, pReader->suid, numOfTables, pCond->twindows.skey, pReader->window.skey, pReader->window.ekey, pReader->idStr); return code; } diff --git a/source/dnode/vnode/src/vnd/vnodeSvr.c b/source/dnode/vnode/src/vnd/vnodeSvr.c index e2641aad86..6e9eba306a 100644 --- a/source/dnode/vnode/src/vnd/vnodeSvr.c +++ b/source/dnode/vnode/src/vnd/vnodeSvr.c @@ -533,6 +533,7 @@ static int32_t vnodeProcessCreateTbReq(SVnode *pVnode, int64_t version, void *pR taosArrayPush(rsp.pArray, &cRsp); } + vDebug("vgId:%d, add %d new created tables into query table list", TD_VID(pVnode), (int32_t)taosArrayGetSize(tbUids)); tqUpdateTbUidList(pVnode->pTq, tbUids, true); if (tdUpdateTbUidList(pVnode->pSma, pStore, true) < 0) { goto _exit; @@ -888,7 +889,6 @@ static int32_t vnodeProcessSubmitReq(SVnode *pVnode, int64_t version, void *pReq taosArrayPush(newTbUids, &createTbReq.uid); } - taosArrayPush(newTbUids, &createTbReq.uid); submitBlkRsp.uid = createTbReq.uid; submitBlkRsp.tblFName = taosMemoryMalloc(strlen(pVnode->config.dbname) + strlen(createTbReq.name) + 2); @@ -919,6 +919,11 @@ static int32_t vnodeProcessSubmitReq(SVnode *pVnode, int64_t version, void *pReq submitRsp.affectedRows += submitBlkRsp.affectedRows; taosArrayPush(submitRsp.pArray, &submitBlkRsp); } + + if (taosArrayGetSize(newTbUids) > 0) { + vDebug("vgId:%d, add %d table into query table list in handling submit", TD_VID(pVnode), (int32_t)taosArrayGetSize(newTbUids)); + } + tqUpdateTbUidList(pVnode->pTq, newTbUids, true); _exit: diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c index ea2180124a..a2bcca9545 100644 --- a/source/libs/executor/src/executor.c +++ b/source/libs/executor/src/executor.c @@ -265,6 +265,15 @@ static SArray* filterUnqualifiedTables(const SStreamScanInfo* pScanInfo, const S int32_t qUpdateQualifiedTableId(qTaskInfo_t tinfo, const SArray* tableIdList, bool isAdd) { SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo; + STableListInfo* pListInfo = &pTaskInfo->tableqinfoList; + + if (isAdd) { + qDebug("add %d tables id into query list, %s", (int32_t) taosArrayGetSize(tableIdList), pTaskInfo->id.str); + } + + if (pListInfo->map == NULL) { + pListInfo->map = taosHashInit(32, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK); + } // traverse to the stream scanner node to add this table id SOperatorInfo* pInfo = pTaskInfo->pRoot; @@ -311,13 +320,19 @@ int32_t qUpdateQualifiedTableId(qTaskInfo_t tinfo, const SArray* tableIdList, bo } } - taosArrayPush(pTaskInfo->tableqinfoList.pTableList, &keyInfo); - if (pTaskInfo->tableqinfoList.map == NULL) { - pTaskInfo->tableqinfoList.map = - taosHashInit(32, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK); + bool exists = false; + for (int32_t k = 0; k < taosArrayGetSize(pListInfo->pTableList); ++k) { + STableKeyInfo* pKeyInfo = taosArrayGet(pListInfo->pTableList, k); + if (pKeyInfo->uid == keyInfo.uid) { + qWarn("ignore duplicated query table uid:%" PRIu64 " added, %s", pKeyInfo->uid, pTaskInfo->id.str); + exists = true; + } } - taosHashPut(pTaskInfo->tableqinfoList.map, uid, sizeof(uid), &keyInfo.groupId, sizeof(keyInfo.groupId)); + if (!exists) { + taosArrayPush(pTaskInfo->tableqinfoList.pTableList, &keyInfo); + taosHashPut(pTaskInfo->tableqinfoList.map, uid, sizeof(uid), &keyInfo.groupId, sizeof(keyInfo.groupId)); + } } if (keyBuf != NULL) { diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c index ad9cd1ffe7..a6d718bafa 100644 --- a/source/libs/executor/src/scanoperator.c +++ b/source/libs/executor/src/scanoperator.c @@ -617,19 +617,28 @@ static SSDataBlock* doTableScan(SOperatorInfo* pOperator) { // if scan table by table if (pInfo->scanMode == TABLE_SCAN__TABLE_ORDER) { - if (pInfo->noTable) return NULL; + if (pInfo->noTable) { + return NULL; + } + + int32_t numOfTables = taosArrayGetSize(pTaskInfo->tableqinfoList.pTableList); + while (1) { SSDataBlock* result = doTableScanGroup(pOperator); if (result) { return result; } + // if no data, switch to next table and continue scan pInfo->currentTable++; - if (pInfo->currentTable >= taosArrayGetSize(pTaskInfo->tableqinfoList.pTableList)) { + if (pInfo->currentTable >= numOfTables) { return NULL; } + STableKeyInfo* pTableInfo = taosArrayGet(pTaskInfo->tableqinfoList.pTableList, pInfo->currentTable); tsdbSetTableId(pInfo->dataReader, pTableInfo->uid); + qDebug("set uid:%" PRIu64 " into scanner, total tables:%d, index:%d %s", pTableInfo->uid, numOfTables, pInfo->currentTable, pTaskInfo->id.str); + tsdbReaderReset(pInfo->dataReader, &pInfo->cond); pInfo->scanTimes = 0; }