diff --git a/include/common/tmsg.h b/include/common/tmsg.h index cab8fea374aba1645f89d804724e6724db52d610..968db0c2add07f752b39e452017830b47f4f5d58 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -70,11 +70,7 @@ typedef uint16_t tmsg_t; #define TSDB_IE_TYPE_DNODE_EXT 6 #define TSDB_IE_TYPE_DNODE_STATE 7 -enum { - CONN_TYPE__QUERY = 1, - CONN_TYPE__TMQ, - CONN_TYPE__MAX -}; +enum { CONN_TYPE__QUERY = 1, CONN_TYPE__TMQ, CONN_TYPE__MAX }; enum { HEARTBEAT_KEY_DBINFO = 1, @@ -342,13 +338,13 @@ int32_t tSerializeSConnectReq(void* buf, int32_t bufLen, SConnectReq* pReq); int32_t tDeserializeSConnectReq(void* buf, int32_t bufLen, SConnectReq* pReq); typedef struct { - int32_t acctId; - int64_t clusterId; + int32_t acctId; + int64_t clusterId; uint32_t connId; - int8_t superUser; - int8_t connType; - SEpSet epSet; - char sVersion[128]; + int8_t superUser; + int8_t connType; + SEpSet epSet; + char sVersion[128]; } SConnectRsp; int32_t tSerializeSConnectRsp(void* buf, int32_t bufLen, SConnectRsp* pRsp); @@ -663,14 +659,13 @@ typedef struct { int32_t outputLen; int32_t bufSize; int64_t signature; - int32_t commentSize; - int32_t codeSize; - char pComment[TSDB_FUNC_COMMENT_LEN]; - char pCode[TSDB_FUNC_CODE_LEN]; + char* pComment; + char* pCode; } SCreateFuncReq; int32_t tSerializeSCreateFuncReq(void* buf, int32_t bufLen, SCreateFuncReq* pReq); int32_t tDeserializeSCreateFuncReq(void* buf, int32_t bufLen, SCreateFuncReq* pReq); +void tFreeSCreateFuncReq(SCreateFuncReq* pReq); typedef struct { char name[TSDB_FUNC_NAME_LEN]; @@ -687,6 +682,7 @@ typedef struct { int32_t tSerializeSRetrieveFuncReq(void* buf, int32_t bufLen, SRetrieveFuncReq* pReq); int32_t tDeserializeSRetrieveFuncReq(void* buf, int32_t bufLen, SRetrieveFuncReq* pReq); +void tFreeSRetrieveFuncReq(SRetrieveFuncReq* pReq); typedef struct { char name[TSDB_FUNC_NAME_LEN]; @@ -698,8 +694,8 @@ typedef struct { int64_t signature; int32_t commentSize; int32_t codeSize; - char pComment[TSDB_FUNC_COMMENT_LEN]; - char pCode[TSDB_FUNC_CODE_LEN]; + char* pComment; + char* pCode; } SFuncInfo; typedef struct { @@ -709,6 +705,7 @@ typedef struct { int32_t tSerializeSRetrieveFuncRsp(void* buf, int32_t bufLen, SRetrieveFuncRsp* pRsp); int32_t tDeserializeSRetrieveFuncRsp(void* buf, int32_t bufLen, SRetrieveFuncRsp* pRsp); +void tFreeSRetrieveFuncRsp(SRetrieveFuncRsp* pRsp); typedef struct { int32_t statusInterval; @@ -1213,12 +1210,12 @@ typedef struct { #define STREAM_TRIGGER_WINDOW_CLOSE 2 typedef struct { - char name[TSDB_TOPIC_FNAME_LEN]; - char outputSTbName[TSDB_TABLE_FNAME_LEN]; - int8_t igExists; - char* sql; - char* ast; - int8_t triggerType; + char name[TSDB_TOPIC_FNAME_LEN]; + char outputSTbName[TSDB_TABLE_FNAME_LEN]; + int8_t igExists; + char* sql; + char* ast; + int8_t triggerType; int64_t watermark; } SCMCreateStreamReq; @@ -1671,14 +1668,14 @@ typedef struct { int32_t pid; char fqdn[TSDB_FQDN_LEN]; int32_t subPlanNum; - SArray* subDesc; // SArray + SArray* subDesc; // SArray } SQueryDesc; typedef struct { - uint32_t connId; - int32_t pid; - char app[TSDB_APP_NAME_LEN]; - SArray* queryDesc; // SArray + uint32_t connId; + int32_t pid; + char app[TSDB_APP_NAME_LEN]; + SArray* queryDesc; // SArray } SQueryHbReqBasic; typedef struct { @@ -1742,7 +1739,7 @@ static FORCE_INLINE void tFreeClientHbReq(void* pReq) { } taosMemoryFreeClear(req->query); } - + if (req->info) { tFreeReqKvHash(req->info); taosHashCleanup(req->info); diff --git a/include/util/tdef.h b/include/util/tdef.h index 5fc30540ee6ad58563795dd1d04c0ef92406d109..5b863f592036ee9115b04bdcac5df4f0c22ad884 100644 --- a/include/util/tdef.h +++ b/include/util/tdef.h @@ -128,17 +128,17 @@ extern const int32_t TYPE_BYTES[15]; #define TSDB_INS_TABLE_QUERIES "queries" #define TSDB_INS_TABLE_VNODES "vnodes" -#define TSDB_PERFORMANCE_SCHEMA_DB "performance_schema" -#define TSDB_PERFS_TABLE_CONNECTIONS "connections" -#define TSDB_PERFS_TABLE_QUERIES "queries" -#define TSDB_PERFS_TABLE_TOPICS "topics" -#define TSDB_PERFS_TABLE_CONSUMERS "consumers" -#define TSDB_PERFS_TABLE_SUBSCRIBES "subscribes" +#define TSDB_PERFORMANCE_SCHEMA_DB "performance_schema" +#define TSDB_PERFS_TABLE_CONNECTIONS "connections" +#define TSDB_PERFS_TABLE_QUERIES "queries" +#define TSDB_PERFS_TABLE_TOPICS "topics" +#define TSDB_PERFS_TABLE_CONSUMERS "consumers" +#define TSDB_PERFS_TABLE_SUBSCRIBES "subscribes" #define TSDB_INDEX_TYPE_SMA "SMA" #define TSDB_INDEX_TYPE_FULLTEXT "FULLTEXT" -#define TSDB_INS_USER_STABLES_DBNAME_COLID 2 +#define TSDB_INS_USER_STABLES_DBNAME_COLID 2 #define TSDB_TICK_PER_SECOND(precision) \ ((int64_t)((precision) == TSDB_TIME_PRECISION_MILLI ? 1e3L \ @@ -234,8 +234,8 @@ typedef enum ELogicConditionType { #define TSDB_DB_FNAME_LEN (TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN + TSDB_NAME_DELIMITER_LEN) #define TSDB_FUNC_NAME_LEN 65 -#define TSDB_FUNC_COMMENT_LEN 4096 -#define TSDB_FUNC_CODE_LEN (65535 - 512) +#define TSDB_FUNC_COMMENT_LEN 1024 * 1024 +#define TSDB_FUNC_CODE_LEN 10 * 1024 * 1024 #define TSDB_FUNC_BUF_SIZE 512 #define TSDB_FUNC_TYPE_SCALAR 1 #define TSDB_FUNC_TYPE_AGGREGATE 2 @@ -339,12 +339,12 @@ typedef enum ELogicConditionType { #define TSDB_MAX_TOTAL_BLOCKS 10000 #define TSDB_DEFAULT_TOTAL_BLOCKS 6 -#define TSDB_MIN_DAYS_PER_FILE 60 // unit minute +#define TSDB_MIN_DAYS_PER_FILE 60 // unit minute #define TSDB_MAX_DAYS_PER_FILE (3650 * 1440) #define TSDB_DEFAULT_DAYS_PER_FILE (10 * 1440) #define TSDB_MIN_KEEP (1 * 1440) // data in db to be reserved. unit minute -#define TSDB_MAX_KEEP (365000 * 1440) // data in db to be reserved. +#define TSDB_MAX_KEEP (365000 * 1440) // data in db to be reserved. #define TSDB_DEFAULT_KEEP (3650 * 1440) // ten years #define TSDB_MIN_MIN_ROW_FBLOCK 10 @@ -419,11 +419,11 @@ typedef enum ELogicConditionType { #define TSDB_DEFAULT_EXPLAIN_VERBOSE false -#define TSDB_MIN_EXPLAIN_RATIO 0 -#define TSDB_MAX_EXPLAIN_RATIO 1 -#define TSDB_DEFAULT_EXPLAIN_RATIO 0.001 +#define TSDB_MIN_EXPLAIN_RATIO 0 +#define TSDB_MAX_EXPLAIN_RATIO 1 +#define TSDB_DEFAULT_EXPLAIN_RATIO 0.001 -#define TSDB_EXPLAIN_RESULT_ROW_SIZE 1024 +#define TSDB_EXPLAIN_RESULT_ROW_SIZE 1024 #define TSDB_EXPLAIN_RESULT_COLUMN_NAME "QUERY PLAN" #define TSDB_MAX_JOIN_TABLE_NUM 10 @@ -509,13 +509,13 @@ enum { SND_WORKER_TYPE__UNIQUE, }; -#define MNODE_HANDLE -1 -#define QNODE_HANDLE 1 +#define MNODE_HANDLE -1 +#define QNODE_HANDLE 1 #define DEFAULT_HANDLE 0 -#define TSDB_CONFIG_OPTION_LEN 16 -#define TSDB_CONIIG_VALUE_LEN 48 -#define TSDB_CONFIG_NUMBER 8 +#define TSDB_CONFIG_OPTION_LEN 16 +#define TSDB_CONIIG_VALUE_LEN 48 +#define TSDB_CONFIG_NUMBER 8 #define QUERY_ID_SIZE 20 #define QUERY_OBJ_ID_SIZE 18 @@ -524,7 +524,6 @@ enum { #define MAX_NUM_STR_SIZE 40 - #ifdef __cplusplus } #endif diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index 3adb0102ce1fe674d373ad9a3ca7f240010b18e5..a21fc81bfad5d33fbb96e9753105062bc31d50ba 100644 --- a/source/common/src/tmsg.c +++ b/source/common/src/tmsg.c @@ -142,10 +142,10 @@ static int32_t tSerializeSClientHbReq(SCoder *pEncoder, const SClientHbReq *pReq if (tEncodeU32(pEncoder, pReq->query->connId) < 0) return -1; if (tEncodeI32(pEncoder, pReq->query->pid) < 0) return -1; if (tEncodeCStr(pEncoder, pReq->query->app) < 0) return -1; - + int32_t num = taosArrayGetSize(pReq->query->queryDesc); if (tEncodeI32(pEncoder, num) < 0) return -1; - + for (int32_t i = 0; i < num; ++i) { SQueryDesc *desc = taosArrayGet(pReq->query->queryDesc, i); if (tEncodeCStr(pEncoder, desc->sql) < 0) return -1; @@ -169,7 +169,7 @@ static int32_t tSerializeSClientHbReq(SCoder *pEncoder, const SClientHbReq *pReq if (tEncodeI32(pEncoder, queryNum) < 0) return -1; } } - + int32_t kvNum = taosHashGetSize(pReq->info); if (tEncodeI32(pEncoder, kvNum) < 0) return -1; void *pIter = taosHashIterate(pReq->info, NULL); @@ -200,7 +200,7 @@ static int32_t tDeserializeSClientHbReq(SCoder *pDecoder, SClientHbReq *pReq) { if (num > 0) { pReq->query->queryDesc = taosArrayInit(num, sizeof(SQueryDesc)); if (NULL == pReq->query->queryDesc) return -1; - + for (int32_t i = 0; i < num; ++i) { SQueryDesc desc = {0}; if (tDecodeCStrTo(pDecoder, desc.sql) < 0) return -1; @@ -217,7 +217,7 @@ static int32_t tDeserializeSClientHbReq(SCoder *pDecoder, SClientHbReq *pReq) { if (snum > 0) { desc.subDesc = taosArrayInit(snum, sizeof(SQuerySubDesc)); if (NULL == desc.subDesc) return -1; - + for (int32_t m = 0; m < snum; ++m) { SQuerySubDesc sDesc = {0}; if (tDecodeI64(pDecoder, &sDesc.tid) < 0) return -1; @@ -254,7 +254,7 @@ static int32_t tSerializeSClientHbRsp(SCoder *pEncoder, const SClientHbRsp *pRsp int32_t queryNum = 0; if (pRsp->query) { queryNum = 1; - if (tEncodeI32(pEncoder, queryNum) < 0) return -1; + if (tEncodeI32(pEncoder, queryNum) < 0) return -1; if (tEncodeU32(pEncoder, pRsp->query->connId) < 0) return -1; if (tEncodeU64(pEncoder, pRsp->query->killRid) < 0) return -1; if (tEncodeI32(pEncoder, pRsp->query->totalDnodes) < 0) return -1; @@ -262,9 +262,9 @@ static int32_t tSerializeSClientHbRsp(SCoder *pEncoder, const SClientHbRsp *pRsp if (tEncodeI8(pEncoder, pRsp->query->killConnection) < 0) return -1; if (tEncodeSEpSet(pEncoder, &pRsp->query->epSet) < 0) return -1; } else { - if (tEncodeI32(pEncoder, queryNum) < 0) return -1; + if (tEncodeI32(pEncoder, queryNum) < 0) return -1; } - + int32_t kvNum = taosArrayGetSize(pRsp->info); if (tEncodeI32(pEncoder, kvNum) < 0) return -1; for (int32_t i = 0; i < kvNum; i++) { @@ -1492,10 +1492,25 @@ int32_t tSerializeSCreateFuncReq(void *buf, int32_t bufLen, SCreateFuncReq *pReq if (tEncodeI32(&encoder, pReq->outputLen) < 0) return -1; if (tEncodeI32(&encoder, pReq->bufSize) < 0) return -1; if (tEncodeI64(&encoder, pReq->signature) < 0) return -1; - if (tEncodeI32(&encoder, pReq->commentSize) < 0) return -1; - if (tEncodeI32(&encoder, pReq->codeSize) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->pComment) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->pCode) < 0) return -1; + + int32_t codeSize = 0; + if (pReq->pCode != NULL) { + codeSize = strlen(pReq->pCode) + 1; + } + if (tEncodeI32(&encoder, codeSize) < 0) return -1; + if (pReq->pCode != NULL) { + if (tEncodeCStr(&encoder, pReq->pCode) < 0) return -1; + } + + int32_t commentSize = 0; + if (pReq->pComment != NULL) { + commentSize = strlen(pReq->pComment) + 1; + } + if (tEncodeI32(&encoder, commentSize) < 0) return -1; + if (pReq->pComment != NULL) { + if (tEncodeCStr(&encoder, pReq->pComment) < 0) return -1; + } + tEndEncode(&encoder); int32_t tlen = encoder.pos; @@ -1516,16 +1531,40 @@ int32_t tDeserializeSCreateFuncReq(void *buf, int32_t bufLen, SCreateFuncReq *pR if (tDecodeI32(&decoder, &pReq->outputLen) < 0) return -1; if (tDecodeI32(&decoder, &pReq->bufSize) < 0) return -1; if (tDecodeI64(&decoder, &pReq->signature) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->commentSize) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->codeSize) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->pComment) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->pCode) < 0) return -1; + + int32_t codeSize = 0; + if (tDecodeI32(&decoder, &codeSize) < 0) return -1; + if (codeSize > 0) { + pReq->pCode = taosMemoryCalloc(1, codeSize); + if (pReq->pCode == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + return -1; + } + if (tDecodeCStrTo(&decoder, pReq->pCode) < 0) return -1; + } + + int32_t commentSize = 0; + if (tDecodeI32(&decoder, &commentSize) < 0) return -1; + if (commentSize > 0) { + pReq->pComment = taosMemoryCalloc(1, commentSize); + if (pReq->pComment == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + return -1; + } + if (tDecodeCStrTo(&decoder, pReq->pComment) < 0) return -1; + } + tEndDecode(&decoder); tCoderClear(&decoder); return 0; } +void tFreeSCreateFuncReq(SCreateFuncReq *pReq) { + taosMemoryFree(pReq->pCode); + taosMemoryFree(pReq->pComment); +} + int32_t tSerializeSDropFuncReq(void *buf, int32_t bufLen, SDropFuncReq *pReq) { SCoder encoder = {0}; tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER); @@ -1594,6 +1633,8 @@ int32_t tDeserializeSRetrieveFuncReq(void *buf, int32_t bufLen, SRetrieveFuncReq return 0; } +void tFreeSRetrieveFuncReq(SRetrieveFuncReq *pReq) { taosArrayDestroy(pReq->pFuncNames); } + int32_t tSerializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp *pRsp) { SCoder encoder = {0}; tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER); @@ -1612,10 +1653,10 @@ int32_t tSerializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp * if (tEncodeI32(&encoder, pInfo->outputLen) < 0) return -1; if (tEncodeI32(&encoder, pInfo->bufSize) < 0) return -1; if (tEncodeI64(&encoder, pInfo->signature) < 0) return -1; - if (tEncodeI32(&encoder, pInfo->commentSize) < 0) return -1; if (tEncodeI32(&encoder, pInfo->codeSize) < 0) return -1; - if (tEncodeCStr(&encoder, pInfo->pComment) < 0) return -1; + if (tEncodeI32(&encoder, pInfo->commentSize) < 0) return -1; if (tEncodeCStr(&encoder, pInfo->pCode) < 0) return -1; + if (tEncodeCStr(&encoder, pInfo->pComment) < 0) return -1; } tEndEncode(&encoder); @@ -1644,10 +1685,17 @@ int32_t tDeserializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp if (tDecodeI32(&decoder, &fInfo.outputLen) < 0) return -1; if (tDecodeI32(&decoder, &fInfo.bufSize) < 0) return -1; if (tDecodeI64(&decoder, &fInfo.signature) < 0) return -1; - if (tDecodeI32(&decoder, &fInfo.commentSize) < 0) return -1; if (tDecodeI32(&decoder, &fInfo.codeSize) < 0) return -1; - if (tDecodeCStrTo(&decoder, fInfo.pComment) < 0) return -1; + if (tDecodeI32(&decoder, &fInfo.commentSize) < 0) return -1; + fInfo.pCode = taosMemoryCalloc(1, fInfo.codeSize); + fInfo.pComment = taosMemoryCalloc(1, fInfo.commentSize); + if (fInfo.pCode == NULL || fInfo.pComment == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + return -1; + } + if (tDecodeCStrTo(&decoder, fInfo.pCode) < 0) return -1; + if (tDecodeCStrTo(&decoder, fInfo.pComment) < 0) return -1; taosArrayPush(pRsp->pFuncInfos, &fInfo); } tEndDecode(&decoder); @@ -1656,6 +1704,16 @@ int32_t tDeserializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp return 0; } +void tFreeSRetrieveFuncRsp(SRetrieveFuncRsp *pRsp) { + int32_t size = taosArrayGetSize(pRsp->pFuncInfos); + for (int32_t i = 0; i < size; ++i) { + SFuncInfo *pInfo = taosArrayGet(pRsp->pFuncInfos, i); + taosMemoryFree(pInfo->pCode); + taosMemoryFree(pInfo->pComment); + } + taosArrayDestroy(pRsp->pFuncInfos); +} + int32_t tSerializeSCreateDbReq(void *buf, int32_t bufLen, SCreateDbReq *pReq) { SCoder encoder = {0}; tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER); diff --git a/source/dnode/mgmt/mgmt_mnode/src/mmFile.c b/source/dnode/mgmt/mgmt_mnode/src/mmFile.c index baf16f591d8f0066ad49abc8f0b74f143028bcfc..75c48e79eb7966fb52fbbf45bb874df93a36d17f 100644 --- a/source/dnode/mgmt/mgmt_mnode/src/mmFile.c +++ b/source/dnode/mgmt/mgmt_mnode/src/mmFile.c @@ -121,7 +121,7 @@ int32_t mmWriteFile(SMgmtWrapper *pWrapper, SDCreateMnodeReq *pReq, bool deploye int32_t len = 0; int32_t maxLen = 4096; char *content = taosMemoryCalloc(1, maxLen + 1); - + len += snprintf(content + len, maxLen - len, "{\n"); len += snprintf(content + len, maxLen - len, " \"mnodes\": [{\n"); diff --git a/source/dnode/mnode/impl/inc/mndDef.h b/source/dnode/mnode/impl/inc/mndDef.h index 5b96416fd719ea5b50ddc275f5165a50c4d4f535..4a6455c0eddfee061735fd15e36376c831cacd7f 100644 --- a/source/dnode/mnode/impl/inc/mndDef.h +++ b/source/dnode/mnode/impl/inc/mndDef.h @@ -275,16 +275,17 @@ typedef struct { } SDbCfg; typedef struct { - char name[TSDB_DB_FNAME_LEN]; - char acct[TSDB_USER_LEN]; - char createUser[TSDB_USER_LEN]; - int64_t createdTime; - int64_t updateTime; - int64_t uid; - int32_t cfgVersion; - int32_t vgVersion; - int8_t hashMethod; // default is 1 - SDbCfg cfg; + char name[TSDB_DB_FNAME_LEN]; + char acct[TSDB_USER_LEN]; + char createUser[TSDB_USER_LEN]; + int64_t createdTime; + int64_t updateTime; + int64_t uid; + int32_t cfgVersion; + int32_t vgVersion; + int8_t hashMethod; // default is 1 + SDbCfg cfg; + SRWLatch lock; } SDbObj; typedef struct { diff --git a/source/dnode/mnode/impl/src/mndBnode.c b/source/dnode/mnode/impl/src/mndBnode.c index f7c4a6c2258425388ae4194a5846998476a7b39a..168bd1db7694a047639a256dac49adb07494ff78 100644 --- a/source/dnode/mnode/impl/src/mndBnode.c +++ b/source/dnode/mnode/impl/src/mndBnode.c @@ -33,7 +33,7 @@ static int32_t mndProcessCreateBnodeReq(SNodeMsg *pReq); static int32_t mndProcessCreateBnodeRsp(SNodeMsg *pRsp); static int32_t mndProcessDropBnodeReq(SNodeMsg *pReq); static int32_t mndProcessDropBnodeRsp(SNodeMsg *pRsp); -static int32_t mndRetrieveBnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows); +static int32_t mndRetrieveBnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows); static void mndCancelGetNextBnode(SMnode *pMnode, void *pIter); int32_t mndInitBnode(SMnode *pMnode) { @@ -437,7 +437,7 @@ static int32_t mndProcessDropBnodeRsp(SNodeMsg *pRsp) { return 0; } -static int32_t mndRetrieveBnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows) { +static int32_t mndRetrieveBnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) { SMnode *pMnode = pReq->pNode; SSdb *pSdb = pMnode->pSdb; int32_t numOfRows = 0; @@ -449,8 +449,8 @@ static int32_t mndRetrieveBnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* p if (pShow->pIter == NULL) break; cols = 0; - SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataAppend(pColInfo, numOfRows, (const char*) &pObj->id, false); + SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); + colDataAppend(pColInfo, numOfRows, (const char *)&pObj->id, false); char buf[TSDB_EP_LEN + VARSTR_HEADER_SIZE] = {0}; STR_WITH_MAXSIZE_TO_VARSTR(buf, pObj->pDnode->ep, pShow->bytes[cols]); @@ -459,7 +459,7 @@ static int32_t mndRetrieveBnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* p colDataAppend(pColInfo, numOfRows, buf, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataAppend(pColInfo, numOfRows, (const char*) &pObj->createdTime, false); + colDataAppend(pColInfo, numOfRows, (const char *)&pObj->createdTime, false); numOfRows++; sdbRelease(pSdb, pObj); diff --git a/source/dnode/mnode/impl/src/mndDb.c b/source/dnode/mnode/impl/src/mndDb.c index 9889743a826f8f5ea8145a80c54b698f86c3330e..755e2828defb88e41d2c94e652b0e88aeb4085b7 100644 --- a/source/dnode/mnode/impl/src/mndDb.c +++ b/source/dnode/mnode/impl/src/mndDb.c @@ -219,10 +219,14 @@ static int32_t mndDbActionDelete(SSdb *pSdb, SDbObj *pDb) { static int32_t mndDbActionUpdate(SSdb *pSdb, SDbObj *pOld, SDbObj *pNew) { mTrace("db:%s, perform update action, old row:%p new row:%p", pOld->name, pOld, pNew); + taosWLockLatch(&pOld->lock); + SArray *pOldRetensions = pOld->cfg.pRetensions; pOld->updateTime = pNew->updateTime; pOld->cfgVersion = pNew->cfgVersion; pOld->vgVersion = pNew->vgVersion; memcpy(&pOld->cfg, &pNew->cfg, sizeof(SDbCfg)); + pNew->cfg.pRetensions = pOldRetensions; + taosWUnLockLatch(&pOld->lock); return 0; } diff --git a/source/dnode/mnode/impl/src/mndFunc.c b/source/dnode/mnode/impl/src/mndFunc.c index a18afbea738420c204df67932785fd5eec72a139..26c7b4d20030557108ac998676f2fbc68757d359 100644 --- a/source/dnode/mnode/impl/src/mndFunc.c +++ b/source/dnode/mnode/impl/src/mndFunc.c @@ -34,7 +34,7 @@ static int32_t mndDropFunc(SMnode *pMnode, SNodeMsg *pReq, SFuncObj *pFunc); static int32_t mndProcessCreateFuncReq(SNodeMsg *pReq); static int32_t mndProcessDropFuncReq(SNodeMsg *pReq); static int32_t mndProcessRetrieveFuncReq(SNodeMsg *pReq); -static int32_t mndRetrieveFuncs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows); +static int32_t mndRetrieveFuncs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows); static void mndCancelGetNextFunc(SMnode *pMnode, void *pIter); int32_t mndInitFunc(SMnode *pMnode) { @@ -63,28 +63,28 @@ static SSdbRaw *mndFuncActionEncode(SFuncObj *pFunc) { int32_t size = pFunc->commentSize + pFunc->codeSize + sizeof(SFuncObj) + SDB_FUNC_RESERVE_SIZE; SSdbRaw *pRaw = sdbAllocRaw(SDB_FUNC, SDB_FUNC_VER, size); - if (pRaw == NULL) goto FUNC_ENCODE_OVER; + if (pRaw == NULL) goto _OVER; int32_t dataPos = 0; - SDB_SET_BINARY(pRaw, dataPos, pFunc->name, TSDB_FUNC_NAME_LEN, FUNC_ENCODE_OVER) - SDB_SET_INT64(pRaw, dataPos, pFunc->createdTime, FUNC_ENCODE_OVER) - SDB_SET_INT8(pRaw, dataPos, pFunc->funcType, FUNC_ENCODE_OVER) - SDB_SET_INT8(pRaw, dataPos, pFunc->scriptType, FUNC_ENCODE_OVER) - SDB_SET_INT8(pRaw, dataPos, pFunc->align, FUNC_ENCODE_OVER) - SDB_SET_INT8(pRaw, dataPos, pFunc->outputType, FUNC_ENCODE_OVER) - SDB_SET_INT32(pRaw, dataPos, pFunc->outputLen, FUNC_ENCODE_OVER) - SDB_SET_INT32(pRaw, dataPos, pFunc->bufSize, FUNC_ENCODE_OVER) - SDB_SET_INT64(pRaw, dataPos, pFunc->signature, FUNC_ENCODE_OVER) - SDB_SET_INT32(pRaw, dataPos, pFunc->commentSize, FUNC_ENCODE_OVER) - SDB_SET_INT32(pRaw, dataPos, pFunc->codeSize, FUNC_ENCODE_OVER) - SDB_SET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, FUNC_ENCODE_OVER) - SDB_SET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize, FUNC_ENCODE_OVER) - SDB_SET_RESERVE(pRaw, dataPos, SDB_FUNC_RESERVE_SIZE, FUNC_ENCODE_OVER) - SDB_SET_DATALEN(pRaw, dataPos, FUNC_ENCODE_OVER); + SDB_SET_BINARY(pRaw, dataPos, pFunc->name, TSDB_FUNC_NAME_LEN, _OVER) + SDB_SET_INT64(pRaw, dataPos, pFunc->createdTime, _OVER) + SDB_SET_INT8(pRaw, dataPos, pFunc->funcType, _OVER) + SDB_SET_INT8(pRaw, dataPos, pFunc->scriptType, _OVER) + SDB_SET_INT8(pRaw, dataPos, pFunc->align, _OVER) + SDB_SET_INT8(pRaw, dataPos, pFunc->outputType, _OVER) + SDB_SET_INT32(pRaw, dataPos, pFunc->outputLen, _OVER) + SDB_SET_INT32(pRaw, dataPos, pFunc->bufSize, _OVER) + SDB_SET_INT64(pRaw, dataPos, pFunc->signature, _OVER) + SDB_SET_INT32(pRaw, dataPos, pFunc->commentSize, _OVER) + SDB_SET_INT32(pRaw, dataPos, pFunc->codeSize, _OVER) + SDB_SET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, _OVER) + SDB_SET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize, _OVER) + SDB_SET_RESERVE(pRaw, dataPos, SDB_FUNC_RESERVE_SIZE, _OVER) + SDB_SET_DATALEN(pRaw, dataPos, _OVER); terrno = 0; -FUNC_ENCODE_OVER: +_OVER: if (terrno != 0) { mError("func:%s, failed to encode to raw:%p since %s", pFunc->name, pRaw, terrstr()); sdbFreeRaw(pRaw); @@ -99,45 +99,45 @@ static SSdbRow *mndFuncActionDecode(SSdbRaw *pRaw) { terrno = TSDB_CODE_OUT_OF_MEMORY; int8_t sver = 0; - if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto FUNC_DECODE_OVER; + if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto _OVER; if (sver != SDB_FUNC_VER) { terrno = TSDB_CODE_SDB_INVALID_DATA_VER; - goto FUNC_DECODE_OVER; + goto _OVER; } SSdbRow *pRow = sdbAllocRow(sizeof(SFuncObj)); - if (pRow == NULL) goto FUNC_DECODE_OVER; + if (pRow == NULL) goto _OVER; SFuncObj *pFunc = sdbGetRowObj(pRow); - if (pFunc == NULL) goto FUNC_DECODE_OVER; + if (pFunc == NULL) goto _OVER; int32_t dataPos = 0; - SDB_GET_BINARY(pRaw, dataPos, pFunc->name, TSDB_FUNC_NAME_LEN, FUNC_DECODE_OVER) - SDB_GET_INT64(pRaw, dataPos, &pFunc->createdTime, FUNC_DECODE_OVER) - SDB_GET_INT8(pRaw, dataPos, &pFunc->funcType, FUNC_DECODE_OVER) - SDB_GET_INT8(pRaw, dataPos, &pFunc->scriptType, FUNC_DECODE_OVER) - SDB_GET_INT8(pRaw, dataPos, &pFunc->align, FUNC_DECODE_OVER) - SDB_GET_INT8(pRaw, dataPos, &pFunc->outputType, FUNC_DECODE_OVER) - SDB_GET_INT32(pRaw, dataPos, &pFunc->outputLen, FUNC_DECODE_OVER) - SDB_GET_INT32(pRaw, dataPos, &pFunc->bufSize, FUNC_DECODE_OVER) - SDB_GET_INT64(pRaw, dataPos, &pFunc->signature, FUNC_DECODE_OVER) - SDB_GET_INT32(pRaw, dataPos, &pFunc->commentSize, FUNC_DECODE_OVER) - SDB_GET_INT32(pRaw, dataPos, &pFunc->codeSize, FUNC_DECODE_OVER) + SDB_GET_BINARY(pRaw, dataPos, pFunc->name, TSDB_FUNC_NAME_LEN, _OVER) + SDB_GET_INT64(pRaw, dataPos, &pFunc->createdTime, _OVER) + SDB_GET_INT8(pRaw, dataPos, &pFunc->funcType, _OVER) + SDB_GET_INT8(pRaw, dataPos, &pFunc->scriptType, _OVER) + SDB_GET_INT8(pRaw, dataPos, &pFunc->align, _OVER) + SDB_GET_INT8(pRaw, dataPos, &pFunc->outputType, _OVER) + SDB_GET_INT32(pRaw, dataPos, &pFunc->outputLen, _OVER) + SDB_GET_INT32(pRaw, dataPos, &pFunc->bufSize, _OVER) + SDB_GET_INT64(pRaw, dataPos, &pFunc->signature, _OVER) + SDB_GET_INT32(pRaw, dataPos, &pFunc->commentSize, _OVER) + SDB_GET_INT32(pRaw, dataPos, &pFunc->codeSize, _OVER) pFunc->pComment = taosMemoryCalloc(1, pFunc->commentSize); pFunc->pCode = taosMemoryCalloc(1, pFunc->codeSize); if (pFunc->pComment == NULL || pFunc->pCode == NULL) { - goto FUNC_DECODE_OVER; + goto _OVER; } - SDB_GET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, FUNC_DECODE_OVER) - SDB_GET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize, FUNC_DECODE_OVER) - SDB_GET_RESERVE(pRaw, dataPos, SDB_FUNC_RESERVE_SIZE, FUNC_DECODE_OVER) + SDB_GET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, _OVER) + SDB_GET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize, _OVER) + SDB_GET_RESERVE(pRaw, dataPos, SDB_FUNC_RESERVE_SIZE, _OVER) terrno = 0; -FUNC_DECODE_OVER: +_OVER: if (terrno != 0) { mError("func:%s, failed to decode from raw:%p since %s", pFunc->name, pRaw, terrstr()); taosMemoryFreeClear(pRow); @@ -192,40 +192,40 @@ static int32_t mndCreateFunc(SMnode *pMnode, SNodeMsg *pReq, SCreateFuncReq *pCr func.outputLen = pCreate->outputLen; func.bufSize = pCreate->bufSize; func.signature = pCreate->signature; - func.commentSize = pCreate->commentSize; - func.codeSize = pCreate->codeSize; + func.commentSize = strlen(pCreate->pComment) + 1; + func.codeSize = strlen(pCreate->pCode) + 1; func.pComment = taosMemoryMalloc(func.commentSize); func.pCode = taosMemoryMalloc(func.codeSize); if (func.pCode == NULL || func.pCode == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - goto CREATE_FUNC_OVER; + goto _OVER; } - memcpy(func.pComment, pCreate->pComment, pCreate->commentSize); + memcpy(func.pComment, pCreate->pComment, func.commentSize); memcpy(func.pCode, pCreate->pCode, func.codeSize); pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_CREATE_FUNC, &pReq->rpcMsg); - if (pTrans == NULL) goto CREATE_FUNC_OVER; + if (pTrans == NULL) goto _OVER; mDebug("trans:%d, used to create func:%s", pTrans->id, pCreate->name); SSdbRaw *pRedoRaw = mndFuncActionEncode(&func); - if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto CREATE_FUNC_OVER; - if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING) != 0) goto CREATE_FUNC_OVER; + if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto _OVER; + if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING) != 0) goto _OVER; SSdbRaw *pUndoRaw = mndFuncActionEncode(&func); - if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto CREATE_FUNC_OVER; - if (sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED) != 0) goto CREATE_FUNC_OVER; + if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto _OVER; + if (sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED) != 0) goto _OVER; SSdbRaw *pCommitRaw = mndFuncActionEncode(&func); - if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto CREATE_FUNC_OVER; - if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) goto CREATE_FUNC_OVER; + if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto _OVER; + if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) goto _OVER; - if (mndTransPrepare(pMnode, pTrans) != 0) goto CREATE_FUNC_OVER; + if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER; code = 0; -CREATE_FUNC_OVER: +_OVER: taosMemoryFree(func.pCode); taosMemoryFree(func.pComment); mndTransDrop(pTrans); @@ -235,27 +235,27 @@ CREATE_FUNC_OVER: static int32_t mndDropFunc(SMnode *pMnode, SNodeMsg *pReq, SFuncObj *pFunc) { int32_t code = -1; STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_DROP_FUNC, &pReq->rpcMsg); - if (pTrans == NULL) goto DROP_FUNC_OVER; + if (pTrans == NULL) goto _OVER; mDebug("trans:%d, used to drop user:%s", pTrans->id, pFunc->name); SSdbRaw *pRedoRaw = mndFuncActionEncode(pFunc); - if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto DROP_FUNC_OVER; + if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto _OVER; sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING); SSdbRaw *pUndoRaw = mndFuncActionEncode(pFunc); - if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto DROP_FUNC_OVER; + if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto _OVER; sdbSetRawStatus(pUndoRaw, SDB_STATUS_READY); SSdbRaw *pCommitRaw = mndFuncActionEncode(pFunc); - if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto DROP_FUNC_OVER; + if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto _OVER; sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED); - if (mndTransPrepare(pMnode, pTrans) != 0) goto DROP_FUNC_OVER; + if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER; code = 0; -DROP_FUNC_OVER: +_OVER: mndTransDrop(pTrans); return code; } @@ -269,7 +269,7 @@ static int32_t mndProcessCreateFuncReq(SNodeMsg *pReq) { if (tDeserializeSCreateFuncReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &createReq) != 0) { terrno = TSDB_CODE_INVALID_MSG; - goto CREATE_FUNC_OVER; + goto _OVER; } mDebug("func:%s, start to create", createReq.name); @@ -279,60 +279,66 @@ static int32_t mndProcessCreateFuncReq(SNodeMsg *pReq) { if (createReq.igExists) { mDebug("func:%s, already exist, ignore exist is set", createReq.name); code = 0; - goto CREATE_FUNC_OVER; + goto _OVER; } else { terrno = TSDB_CODE_MND_FUNC_ALREADY_EXIST; - goto CREATE_FUNC_OVER; + goto _OVER; } } else if (terrno == TSDB_CODE_MND_FUNC_ALREADY_EXIST) { - goto CREATE_FUNC_OVER; + goto _OVER; } if (createReq.name[0] == 0) { terrno = TSDB_CODE_MND_INVALID_FUNC_NAME; - goto CREATE_FUNC_OVER; + goto _OVER; } - if (createReq.commentSize <= 0 || createReq.commentSize > TSDB_FUNC_COMMENT_LEN) { + if (createReq.pComment == NULL) { terrno = TSDB_CODE_MND_INVALID_FUNC_COMMENT; - goto CREATE_FUNC_OVER; + goto _OVER; } - if (createReq.codeSize <= 0 || createReq.codeSize > TSDB_FUNC_CODE_LEN) { + if (createReq.pComment[0] == 0) { + terrno = TSDB_CODE_MND_INVALID_FUNC_COMMENT; + goto _OVER; + } + + if (createReq.pCode == NULL) { terrno = TSDB_CODE_MND_INVALID_FUNC_CODE; - goto CREATE_FUNC_OVER; + goto _OVER; } if (createReq.pCode[0] == 0) { terrno = TSDB_CODE_MND_INVALID_FUNC_CODE; - goto CREATE_FUNC_OVER; + goto _OVER; } if (createReq.bufSize <= 0 || createReq.bufSize > TSDB_FUNC_BUF_SIZE) { terrno = TSDB_CODE_MND_INVALID_FUNC_BUFSIZE; - goto CREATE_FUNC_OVER; + goto _OVER; } pUser = mndAcquireUser(pMnode, pReq->user); if (pUser == NULL) { terrno = TSDB_CODE_MND_NO_USER_FROM_CONN; - goto CREATE_FUNC_OVER; + goto _OVER; } if (mndCheckFuncAuth(pUser)) { - goto CREATE_FUNC_OVER; + goto _OVER; } code = mndCreateFunc(pMnode, pReq, &createReq); if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS; -CREATE_FUNC_OVER: +_OVER: if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) { mError("func:%s, failed to create since %s", createReq.name, terrstr()); } mndReleaseFunc(pMnode, pFunc); mndReleaseUser(pMnode, pUser); + tFreeSCreateFuncReq(&createReq); return code; } @@ -346,14 +352,14 @@ static int32_t mndProcessDropFuncReq(SNodeMsg *pReq) { if (tDeserializeSDropFuncReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) { terrno = TSDB_CODE_INVALID_MSG; - goto DROP_FUNC_OVER; + goto _OVER; } mDebug("func:%s, start to drop", dropReq.name); if (dropReq.name[0] == 0) { terrno = TSDB_CODE_MND_INVALID_FUNC_NAME; - goto DROP_FUNC_OVER; + goto _OVER; } pFunc = mndAcquireFunc(pMnode, dropReq.name); @@ -361,27 +367,27 @@ static int32_t mndProcessDropFuncReq(SNodeMsg *pReq) { if (dropReq.igNotExists) { mDebug("func:%s, not exist, ignore not exist is set", dropReq.name); code = 0; - goto DROP_FUNC_OVER; + goto _OVER; } else { terrno = TSDB_CODE_MND_FUNC_NOT_EXIST; - goto DROP_FUNC_OVER; + goto _OVER; } } pUser = mndAcquireUser(pMnode, pReq->user); if (pUser == NULL) { terrno = TSDB_CODE_MND_NO_USER_FROM_CONN; - goto DROP_FUNC_OVER; + goto _OVER; } if (mndCheckFuncAuth(pUser)) { - goto DROP_FUNC_OVER; + goto _OVER; } code = mndDropFunc(pMnode, pReq, pFunc); if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS; -DROP_FUNC_OVER: +_OVER: if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) { mError("func:%s, failed to drop since %s", dropReq.name, terrstr()); } @@ -434,6 +440,12 @@ static int32_t mndProcessRetrieveFuncReq(SNodeMsg *pReq) { funcInfo.signature = pFunc->signature; funcInfo.commentSize = pFunc->commentSize; funcInfo.codeSize = pFunc->codeSize; + funcInfo.pCode = taosMemoryCalloc(1, sizeof(funcInfo.codeSize)); + funcInfo.pComment = taosMemoryCalloc(1, sizeof(funcInfo.commentSize)); + if (funcInfo.pCode == NULL || funcInfo.pComment == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + goto RETRIEVE_FUNC_OVER; + } memcpy(funcInfo.pComment, pFunc->pComment, pFunc->commentSize); memcpy(funcInfo.pCode, pFunc->pCode, pFunc->codeSize); taosArrayPush(retrieveRsp.pFuncInfos, &funcInfo); @@ -455,8 +467,8 @@ static int32_t mndProcessRetrieveFuncReq(SNodeMsg *pReq) { code = 0; RETRIEVE_FUNC_OVER: - taosArrayDestroy(retrieveReq.pFuncNames); - taosArrayDestroy(retrieveRsp.pFuncInfos); + tFreeSRetrieveFuncReq(&retrieveReq); + tFreeSRetrieveFuncRsp(&retrieveRsp); return code; } @@ -479,7 +491,7 @@ static void *mnodeGenTypeStr(char *buf, int32_t buflen, uint8_t type, int16_t le return tDataTypes[type].name; } -static int32_t mndRetrieveFuncs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows) { +static int32_t mndRetrieveFuncs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) { SMnode *pMnode = pReq->pNode; SSdb *pSdb = pMnode->pSdb; int32_t numOfRows = 0; @@ -496,34 +508,35 @@ static int32_t mndRetrieveFuncs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pB char b1[tListLen(pFunc->name) + VARSTR_HEADER_SIZE] = {0}; STR_WITH_MAXSIZE_TO_VARSTR(b1, pFunc->name, pShow->bytes[cols]); - SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataAppend(pColInfo, numOfRows, (const char*) b1, false); + SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); + colDataAppend(pColInfo, numOfRows, (const char *)b1, false); - char* b2 = taosMemoryCalloc(1, pShow->bytes[cols]); + char *b2 = taosMemoryCalloc(1, pShow->bytes[cols]); STR_WITH_MAXSIZE_TO_VARSTR(b2, pFunc->pComment, pShow->bytes[cols]); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataAppend(pColInfo, numOfRows, (const char*) b2, false); + colDataAppend(pColInfo, numOfRows, (const char *)b2, false); int32_t isAgg = (pFunc->funcType == TSDB_FUNC_TYPE_AGGREGATE) ? 1 : 0; pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataAppend(pColInfo, numOfRows, (const char*) &isAgg, false); + colDataAppend(pColInfo, numOfRows, (const char *)&isAgg, false); char b3[TSDB_TYPE_STR_MAX_LEN] = {0}; - STR_WITH_MAXSIZE_TO_VARSTR(b3, mnodeGenTypeStr(buf, TSDB_TYPE_STR_MAX_LEN, pFunc->outputType, pFunc->outputLen), pShow->bytes[cols]); + STR_WITH_MAXSIZE_TO_VARSTR(b3, mnodeGenTypeStr(buf, TSDB_TYPE_STR_MAX_LEN, pFunc->outputType, pFunc->outputLen), + pShow->bytes[cols]); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataAppend(pColInfo, numOfRows, (const char*) b3, false); + colDataAppend(pColInfo, numOfRows, (const char *)b3, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataAppend(pColInfo, numOfRows, (const char*) &pFunc->createdTime, false); + colDataAppend(pColInfo, numOfRows, (const char *)&pFunc->createdTime, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataAppend(pColInfo, numOfRows, (const char*) &pFunc->codeSize, false); + colDataAppend(pColInfo, numOfRows, (const char *)&pFunc->codeSize, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataAppend(pColInfo, numOfRows, (const char*) &pFunc->bufSize, false); + colDataAppend(pColInfo, numOfRows, (const char *)&pFunc->bufSize, false); numOfRows++; sdbRelease(pSdb, pFunc); diff --git a/source/dnode/mnode/impl/src/mndMnode.c b/source/dnode/mnode/impl/src/mndMnode.c index 6be7097e6af9304cfc2d4f2a81d497f287fb7b13..f403da2f2d9d698421a78a36418dcf8deb4ed9fb 100644 --- a/source/dnode/mnode/impl/src/mndMnode.c +++ b/source/dnode/mnode/impl/src/mndMnode.c @@ -78,13 +78,13 @@ void mndReleaseMnode(SMnode *pMnode, SMnodeObj *pObj) { const char *mndGetRoleStr(int32_t showType) { switch (showType) { case TAOS_SYNC_STATE_FOLLOWER: - return "unsynced"; + return "FOLLOWER"; case TAOS_SYNC_STATE_CANDIDATE: - return "slave"; + return "CANDIDATE"; case TAOS_SYNC_STATE_LEADER: - return "master"; + return "LEADER"; default: - return "undefined"; + return "ERROR"; } } @@ -615,7 +615,7 @@ static int32_t mndProcessDropMnodeRsp(SNodeMsg *pRsp) { return 0; } -static int32_t mndRetrieveMnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows) { +static int32_t mndRetrieveMnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) { SMnode *pMnode = pReq->pNode; SSdb *pSdb = pMnode->pSdb; int32_t numOfRows = 0; @@ -628,8 +628,8 @@ static int32_t mndRetrieveMnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* p if (pShow->pIter == NULL) break; cols = 0; - SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataAppend(pColInfo, numOfRows, (const char*) &pObj->id, false); + SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); + colDataAppend(pColInfo, numOfRows, (const char *)&pObj->id, false); char b1[TSDB_EP_LEN + VARSTR_HEADER_SIZE] = {0}; STR_WITH_MAXSIZE_TO_VARSTR(b1, pObj->pDnode->ep, pShow->bytes[cols]); @@ -638,11 +638,11 @@ static int32_t mndRetrieveMnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* p colDataAppend(pColInfo, numOfRows, b1, false); const char *roles = mndGetRoleStr(pObj->role); - char* b2 = taosMemoryCalloc(1, strlen(roles) + VARSTR_HEADER_SIZE); + char *b2 = taosMemoryCalloc(1, strlen(roles) + VARSTR_HEADER_SIZE); STR_WITH_MAXSIZE_TO_VARSTR(b2, roles, pShow->bytes[cols]); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataAppend(pColInfo, numOfRows, (const char*) b2, false); + colDataAppend(pColInfo, numOfRows, (const char *)b2, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); colDataAppend(pColInfo, numOfRows, (const char *)&pObj->roleTime, false); diff --git a/source/dnode/mnode/impl/src/mndQnode.c b/source/dnode/mnode/impl/src/mndQnode.c index 3b622795cb0f56095484481ba848f06295384e80..96dba9baf695d557a7be5a444bcc5f1583a0fecd 100644 --- a/source/dnode/mnode/impl/src/mndQnode.c +++ b/source/dnode/mnode/impl/src/mndQnode.c @@ -34,7 +34,7 @@ static int32_t mndProcessCreateQnodeRsp(SNodeMsg *pRsp); static int32_t mndProcessDropQnodeReq(SNodeMsg *pReq); static int32_t mndProcessDropQnodeRsp(SNodeMsg *pRsp); static int32_t mndProcessQnodeListReq(SNodeMsg *pReq); -static int32_t mndRetrieveQnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows); +static int32_t mndRetrieveQnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows); static void mndCancelGetNextQnode(SMnode *pMnode, void *pIter); int32_t mndInitQnode(SMnode *pMnode) { @@ -497,7 +497,7 @@ static int32_t mndProcessDropQnodeRsp(SNodeMsg *pRsp) { return 0; } -static int32_t mndRetrieveQnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows) { +static int32_t mndRetrieveQnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) { SMnode *pMnode = pReq->pNode; SSdb *pSdb = pMnode->pSdb; int32_t numOfRows = 0; @@ -510,8 +510,8 @@ static int32_t mndRetrieveQnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* p if (pShow->pIter == NULL) break; cols = 0; - SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataAppend(pColInfo, numOfRows, (const char*)&pObj->id, false); + SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); + colDataAppend(pColInfo, numOfRows, (const char *)&pObj->id, false); char ep[TSDB_EP_LEN + VARSTR_HEADER_SIZE] = {0}; STR_WITH_MAXSIZE_TO_VARSTR(ep, pObj->pDnode->ep, pShow->bytes[cols]); diff --git a/source/dnode/mnode/impl/src/mndSnode.c b/source/dnode/mnode/impl/src/mndSnode.c index 686cf1400dc75e75b276ac89c5798198bd04d471..b7d0ed8f5afa7558e72fc43a8645dba15b2a4892 100644 --- a/source/dnode/mnode/impl/src/mndSnode.c +++ b/source/dnode/mnode/impl/src/mndSnode.c @@ -33,7 +33,7 @@ static int32_t mndProcessCreateSnodeReq(SNodeMsg *pReq); static int32_t mndProcessCreateSnodeRsp(SNodeMsg *pRsp); static int32_t mndProcessDropSnodeReq(SNodeMsg *pReq); static int32_t mndProcessDropSnodeRsp(SNodeMsg *pRsp); -static int32_t mndRetrieveSnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows); +static int32_t mndRetrieveSnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows); static void mndCancelGetNextSnode(SMnode *pMnode, void *pIter); int32_t mndInitSnode(SMnode *pMnode) { @@ -447,7 +447,7 @@ static int32_t mndProcessDropSnodeRsp(SNodeMsg *pRsp) { return 0; } -static int32_t mndRetrieveSnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows) { +static int32_t mndRetrieveSnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) { SMnode *pMnode = pReq->pNode; SSdb *pSdb = pMnode->pSdb; int32_t numOfRows = 0; @@ -459,8 +459,8 @@ static int32_t mndRetrieveSnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* p if (pShow->pIter == NULL) break; cols = 0; - SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataAppend(pColInfo, numOfRows, (const char*)&pObj->id, false); + SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); + colDataAppend(pColInfo, numOfRows, (const char *)&pObj->id, false); char ep[TSDB_EP_LEN + VARSTR_HEADER_SIZE] = {0}; STR_WITH_MAXSIZE_TO_VARSTR(ep, pObj->pDnode->ep, pShow->bytes[cols]); diff --git a/source/dnode/mnode/impl/src/mndStb.c b/source/dnode/mnode/impl/src/mndStb.c index 0ce73005e882ef9327086c09ccb0203435c6c10e..777141c5d29cc21b3529a7587c07af37c3cefdf0 100644 --- a/source/dnode/mnode/impl/src/mndStb.c +++ b/source/dnode/mnode/impl/src/mndStb.c @@ -74,59 +74,59 @@ SSdbRaw *mndStbActionEncode(SStbObj *pStb) { int32_t size = sizeof(SStbObj) + (pStb->numOfColumns + pStb->numOfTags + pStb->numOfSmas) * sizeof(SSchema) + TSDB_STB_RESERVE_SIZE; SSdbRaw *pRaw = sdbAllocRaw(SDB_STB, TSDB_STB_VER_NUMBER, size); - if (pRaw == NULL) goto STB_ENCODE_OVER; + if (pRaw == NULL) goto _OVER; int32_t dataPos = 0; - SDB_SET_BINARY(pRaw, dataPos, pStb->name, TSDB_TABLE_FNAME_LEN, STB_ENCODE_OVER) - SDB_SET_BINARY(pRaw, dataPos, pStb->db, TSDB_DB_FNAME_LEN, STB_ENCODE_OVER) - SDB_SET_INT64(pRaw, dataPos, pStb->createdTime, STB_ENCODE_OVER) - SDB_SET_INT64(pRaw, dataPos, pStb->updateTime, STB_ENCODE_OVER) - SDB_SET_INT64(pRaw, dataPos, pStb->uid, STB_ENCODE_OVER) - SDB_SET_INT64(pRaw, dataPos, pStb->dbUid, STB_ENCODE_OVER) - SDB_SET_INT32(pRaw, dataPos, pStb->version, STB_ENCODE_OVER) - SDB_SET_INT32(pRaw, dataPos, pStb->nextColId, STB_ENCODE_OVER) - SDB_SET_INT32(pRaw, dataPos, (int32_t)(pStb->xFilesFactor * 10000), STB_ENCODE_OVER) - SDB_SET_INT32(pRaw, dataPos, pStb->aggregationMethod, STB_ENCODE_OVER) - SDB_SET_INT32(pRaw, dataPos, pStb->delay, STB_ENCODE_OVER) - SDB_SET_INT32(pRaw, dataPos, pStb->ttl, STB_ENCODE_OVER) - SDB_SET_INT32(pRaw, dataPos, pStb->numOfColumns, STB_ENCODE_OVER) - SDB_SET_INT32(pRaw, dataPos, pStb->numOfTags, STB_ENCODE_OVER) - SDB_SET_INT32(pRaw, dataPos, pStb->numOfSmas, STB_ENCODE_OVER) - SDB_SET_INT32(pRaw, dataPos, pStb->commentLen, STB_ENCODE_OVER) + SDB_SET_BINARY(pRaw, dataPos, pStb->name, TSDB_TABLE_FNAME_LEN, _OVER) + SDB_SET_BINARY(pRaw, dataPos, pStb->db, TSDB_DB_FNAME_LEN, _OVER) + SDB_SET_INT64(pRaw, dataPos, pStb->createdTime, _OVER) + SDB_SET_INT64(pRaw, dataPos, pStb->updateTime, _OVER) + SDB_SET_INT64(pRaw, dataPos, pStb->uid, _OVER) + SDB_SET_INT64(pRaw, dataPos, pStb->dbUid, _OVER) + SDB_SET_INT32(pRaw, dataPos, pStb->version, _OVER) + SDB_SET_INT32(pRaw, dataPos, pStb->nextColId, _OVER) + SDB_SET_INT32(pRaw, dataPos, (int32_t)(pStb->xFilesFactor * 10000), _OVER) + SDB_SET_INT32(pRaw, dataPos, pStb->aggregationMethod, _OVER) + SDB_SET_INT32(pRaw, dataPos, pStb->delay, _OVER) + SDB_SET_INT32(pRaw, dataPos, pStb->ttl, _OVER) + SDB_SET_INT32(pRaw, dataPos, pStb->numOfColumns, _OVER) + SDB_SET_INT32(pRaw, dataPos, pStb->numOfTags, _OVER) + SDB_SET_INT32(pRaw, dataPos, pStb->numOfSmas, _OVER) + SDB_SET_INT32(pRaw, dataPos, pStb->commentLen, _OVER) for (int32_t i = 0; i < pStb->numOfColumns; ++i) { SSchema *pSchema = &pStb->pColumns[i]; - SDB_SET_INT8(pRaw, dataPos, pSchema->type, STB_ENCODE_OVER) - SDB_SET_INT16(pRaw, dataPos, pSchema->colId, STB_ENCODE_OVER) - SDB_SET_INT32(pRaw, dataPos, pSchema->bytes, STB_ENCODE_OVER) - SDB_SET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, STB_ENCODE_OVER) + SDB_SET_INT8(pRaw, dataPos, pSchema->type, _OVER) + SDB_SET_INT16(pRaw, dataPos, pSchema->colId, _OVER) + SDB_SET_INT32(pRaw, dataPos, pSchema->bytes, _OVER) + SDB_SET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, _OVER) } for (int32_t i = 0; i < pStb->numOfTags; ++i) { SSchema *pSchema = &pStb->pTags[i]; - SDB_SET_INT8(pRaw, dataPos, pSchema->type, STB_ENCODE_OVER) - SDB_SET_INT16(pRaw, dataPos, pSchema->colId, STB_ENCODE_OVER) - SDB_SET_INT32(pRaw, dataPos, pSchema->bytes, STB_ENCODE_OVER) - SDB_SET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, STB_ENCODE_OVER) + SDB_SET_INT8(pRaw, dataPos, pSchema->type, _OVER) + SDB_SET_INT16(pRaw, dataPos, pSchema->colId, _OVER) + SDB_SET_INT32(pRaw, dataPos, pSchema->bytes, _OVER) + SDB_SET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, _OVER) } for (int32_t i = 0; i < pStb->numOfSmas; ++i) { SSchema *pSchema = &pStb->pSmas[i]; - SDB_SET_INT8(pRaw, dataPos, pSchema->type, STB_ENCODE_OVER) - SDB_SET_INT16(pRaw, dataPos, pSchema->colId, STB_ENCODE_OVER) - SDB_SET_INT32(pRaw, dataPos, pSchema->bytes, STB_ENCODE_OVER) - SDB_SET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, STB_ENCODE_OVER) + SDB_SET_INT8(pRaw, dataPos, pSchema->type, _OVER) + SDB_SET_INT16(pRaw, dataPos, pSchema->colId, _OVER) + SDB_SET_INT32(pRaw, dataPos, pSchema->bytes, _OVER) + SDB_SET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, _OVER) } if (pStb->commentLen > 0) { - SDB_SET_BINARY(pRaw, dataPos, pStb->comment, pStb->commentLen, STB_ENCODE_OVER) + SDB_SET_BINARY(pRaw, dataPos, pStb->comment, pStb->commentLen, _OVER) } - SDB_SET_RESERVE(pRaw, dataPos, TSDB_STB_RESERVE_SIZE, STB_ENCODE_OVER) - SDB_SET_DATALEN(pRaw, dataPos, STB_ENCODE_OVER) + SDB_SET_RESERVE(pRaw, dataPos, TSDB_STB_RESERVE_SIZE, _OVER) + SDB_SET_DATALEN(pRaw, dataPos, _OVER) terrno = 0; -STB_ENCODE_OVER: +_OVER: if (terrno != 0) { mError("stb:%s, failed to encode to raw:%p since %s", pStb->name, pRaw, terrstr()); sdbFreeRaw(pRaw); @@ -141,80 +141,80 @@ static SSdbRow *mndStbActionDecode(SSdbRaw *pRaw) { terrno = TSDB_CODE_OUT_OF_MEMORY; int8_t sver = 0; - if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto STB_DECODE_OVER; + if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto _OVER; if (sver != TSDB_STB_VER_NUMBER) { terrno = TSDB_CODE_SDB_INVALID_DATA_VER; - goto STB_DECODE_OVER; + goto _OVER; } SSdbRow *pRow = sdbAllocRow(sizeof(SStbObj)); - if (pRow == NULL) goto STB_DECODE_OVER; + if (pRow == NULL) goto _OVER; SStbObj *pStb = sdbGetRowObj(pRow); - if (pStb == NULL) goto STB_DECODE_OVER; + if (pStb == NULL) goto _OVER; int32_t dataPos = 0; - SDB_GET_BINARY(pRaw, dataPos, pStb->name, TSDB_TABLE_FNAME_LEN, STB_DECODE_OVER) - SDB_GET_BINARY(pRaw, dataPos, pStb->db, TSDB_DB_FNAME_LEN, STB_DECODE_OVER) - SDB_GET_INT64(pRaw, dataPos, &pStb->createdTime, STB_DECODE_OVER) - SDB_GET_INT64(pRaw, dataPos, &pStb->updateTime, STB_DECODE_OVER) - SDB_GET_INT64(pRaw, dataPos, &pStb->uid, STB_DECODE_OVER) - SDB_GET_INT64(pRaw, dataPos, &pStb->dbUid, STB_DECODE_OVER) - SDB_GET_INT32(pRaw, dataPos, &pStb->version, STB_DECODE_OVER) - SDB_GET_INT32(pRaw, dataPos, &pStb->nextColId, STB_DECODE_OVER) + SDB_GET_BINARY(pRaw, dataPos, pStb->name, TSDB_TABLE_FNAME_LEN, _OVER) + SDB_GET_BINARY(pRaw, dataPos, pStb->db, TSDB_DB_FNAME_LEN, _OVER) + SDB_GET_INT64(pRaw, dataPos, &pStb->createdTime, _OVER) + SDB_GET_INT64(pRaw, dataPos, &pStb->updateTime, _OVER) + SDB_GET_INT64(pRaw, dataPos, &pStb->uid, _OVER) + SDB_GET_INT64(pRaw, dataPos, &pStb->dbUid, _OVER) + SDB_GET_INT32(pRaw, dataPos, &pStb->version, _OVER) + SDB_GET_INT32(pRaw, dataPos, &pStb->nextColId, _OVER) int32_t xFilesFactor = 0; - SDB_GET_INT32(pRaw, dataPos, &xFilesFactor, STB_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &xFilesFactor, _OVER) pStb->xFilesFactor = xFilesFactor / 10000.0f; - SDB_GET_INT32(pRaw, dataPos, &pStb->aggregationMethod, STB_DECODE_OVER) - SDB_GET_INT32(pRaw, dataPos, &pStb->delay, STB_DECODE_OVER) - SDB_GET_INT32(pRaw, dataPos, &pStb->ttl, STB_DECODE_OVER) - SDB_GET_INT32(pRaw, dataPos, &pStb->numOfColumns, STB_DECODE_OVER) - SDB_GET_INT32(pRaw, dataPos, &pStb->numOfTags, STB_DECODE_OVER) - SDB_GET_INT32(pRaw, dataPos, &pStb->numOfSmas, STB_DECODE_OVER) - SDB_GET_INT32(pRaw, dataPos, &pStb->commentLen, STB_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pStb->aggregationMethod, _OVER) + SDB_GET_INT32(pRaw, dataPos, &pStb->delay, _OVER) + SDB_GET_INT32(pRaw, dataPos, &pStb->ttl, _OVER) + SDB_GET_INT32(pRaw, dataPos, &pStb->numOfColumns, _OVER) + SDB_GET_INT32(pRaw, dataPos, &pStb->numOfTags, _OVER) + SDB_GET_INT32(pRaw, dataPos, &pStb->numOfSmas, _OVER) + SDB_GET_INT32(pRaw, dataPos, &pStb->commentLen, _OVER) pStb->pColumns = taosMemoryCalloc(pStb->numOfColumns, sizeof(SSchema)); pStb->pTags = taosMemoryCalloc(pStb->numOfTags, sizeof(SSchema)); pStb->pSmas = taosMemoryCalloc(pStb->numOfSmas, sizeof(SSchema)); if (pStb->pColumns == NULL || pStb->pTags == NULL || pStb->pSmas == NULL) { - goto STB_DECODE_OVER; + goto _OVER; } for (int32_t i = 0; i < pStb->numOfColumns; ++i) { SSchema *pSchema = &pStb->pColumns[i]; - SDB_GET_INT8(pRaw, dataPos, &pSchema->type, STB_DECODE_OVER) - SDB_GET_INT16(pRaw, dataPos, &pSchema->colId, STB_DECODE_OVER) - SDB_GET_INT32(pRaw, dataPos, &pSchema->bytes, STB_DECODE_OVER) - SDB_GET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, STB_DECODE_OVER) + SDB_GET_INT8(pRaw, dataPos, &pSchema->type, _OVER) + SDB_GET_INT16(pRaw, dataPos, &pSchema->colId, _OVER) + SDB_GET_INT32(pRaw, dataPos, &pSchema->bytes, _OVER) + SDB_GET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, _OVER) } for (int32_t i = 0; i < pStb->numOfTags; ++i) { SSchema *pSchema = &pStb->pTags[i]; - SDB_GET_INT8(pRaw, dataPos, &pSchema->type, STB_DECODE_OVER) - SDB_GET_INT16(pRaw, dataPos, &pSchema->colId, STB_DECODE_OVER) - SDB_GET_INT32(pRaw, dataPos, &pSchema->bytes, STB_DECODE_OVER) - SDB_GET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, STB_DECODE_OVER) + SDB_GET_INT8(pRaw, dataPos, &pSchema->type, _OVER) + SDB_GET_INT16(pRaw, dataPos, &pSchema->colId, _OVER) + SDB_GET_INT32(pRaw, dataPos, &pSchema->bytes, _OVER) + SDB_GET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, _OVER) } for (int32_t i = 0; i < pStb->numOfSmas; ++i) { SSchema *pSchema = &pStb->pSmas[i]; - SDB_GET_INT8(pRaw, dataPos, &pSchema->type, STB_DECODE_OVER) - SDB_GET_INT16(pRaw, dataPos, &pSchema->colId, STB_DECODE_OVER) - SDB_GET_INT32(pRaw, dataPos, &pSchema->bytes, STB_DECODE_OVER) - SDB_GET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, STB_DECODE_OVER) + SDB_GET_INT8(pRaw, dataPos, &pSchema->type, _OVER) + SDB_GET_INT16(pRaw, dataPos, &pSchema->colId, _OVER) + SDB_GET_INT32(pRaw, dataPos, &pSchema->bytes, _OVER) + SDB_GET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, _OVER) } if (pStb->commentLen > 0) { pStb->comment = taosMemoryCalloc(pStb->commentLen, 1); - if (pStb->comment == NULL) goto STB_DECODE_OVER; - SDB_GET_BINARY(pRaw, dataPos, pStb->comment, pStb->commentLen, STB_DECODE_OVER) + if (pStb->comment == NULL) goto _OVER; + SDB_GET_BINARY(pRaw, dataPos, pStb->comment, pStb->commentLen, _OVER) } - SDB_GET_RESERVE(pRaw, dataPos, TSDB_STB_RESERVE_SIZE, STB_DECODE_OVER) + SDB_GET_RESERVE(pRaw, dataPos, TSDB_STB_RESERVE_SIZE, _OVER) terrno = 0; -STB_DECODE_OVER: +_OVER: if (terrno != 0) { mError("stb:%s, failed to decode from raw:%p since %s", pStb->name, pRaw, terrstr()); taosMemoryFreeClear(pStb->pColumns); @@ -724,21 +724,21 @@ static int32_t mndCreateStb(SMnode *pMnode, SNodeMsg *pReq, SMCreateStbReq *pCre int32_t code = -1; STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_CREATE_STB, &pReq->rpcMsg); - if (pTrans == NULL) goto CREATE_STB_OVER; + if (pTrans == NULL) goto _OVER; mDebug("trans:%d, used to create stb:%s", pTrans->id, pCreate->name); mndTransSetDbInfo(pTrans, pDb); - if (mndSetCreateStbRedoLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto CREATE_STB_OVER; - if (mndSetCreateStbUndoLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto CREATE_STB_OVER; - if (mndSetCreateStbCommitLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto CREATE_STB_OVER; - if (mndSetCreateStbRedoActions(pMnode, pTrans, pDb, &stbObj) != 0) goto CREATE_STB_OVER; - if (mndSetCreateStbUndoActions(pMnode, pTrans, pDb, &stbObj) != 0) goto CREATE_STB_OVER; - if (mndTransPrepare(pMnode, pTrans) != 0) goto CREATE_STB_OVER; + if (mndSetCreateStbRedoLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER; + if (mndSetCreateStbUndoLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER; + if (mndSetCreateStbCommitLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER; + if (mndSetCreateStbRedoActions(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER; + if (mndSetCreateStbUndoActions(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER; + if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER; code = 0; -CREATE_STB_OVER: +_OVER: mndTransDrop(pTrans); return code; } @@ -754,13 +754,13 @@ static int32_t mndProcessMCreateStbReq(SNodeMsg *pReq) { if (tDeserializeSMCreateStbReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &createReq) != 0) { terrno = TSDB_CODE_INVALID_MSG; - goto CREATE_STB_OVER; + goto _OVER; } mDebug("stb:%s, start to create", createReq.name); if (mndCheckCreateStbReq(&createReq) != 0) { terrno = TSDB_CODE_INVALID_MSG; - goto CREATE_STB_OVER; + goto _OVER; } pStb = mndAcquireStb(pMnode, createReq.name); @@ -768,40 +768,40 @@ static int32_t mndProcessMCreateStbReq(SNodeMsg *pReq) { if (createReq.igExists) { mDebug("stb:%s, already exist, ignore exist is set", createReq.name); code = 0; - goto CREATE_STB_OVER; + goto _OVER; } else { terrno = TSDB_CODE_MND_STB_ALREADY_EXIST; - goto CREATE_STB_OVER; + goto _OVER; } } else if (terrno != TSDB_CODE_MND_STB_NOT_EXIST) { - goto CREATE_STB_OVER; + goto _OVER; } pTopicStb = mndAcquireStb(pMnode, createReq.name); if (pTopicStb != NULL) { terrno = TSDB_CODE_MND_NAME_CONFLICT_WITH_TOPIC; - goto CREATE_STB_OVER; + goto _OVER; } pDb = mndAcquireDbByStb(pMnode, createReq.name); if (pDb == NULL) { terrno = TSDB_CODE_MND_DB_NOT_SELECTED; - goto CREATE_STB_OVER; + goto _OVER; } pUser = mndAcquireUser(pMnode, pReq->user); if (pUser == NULL) { - goto CREATE_STB_OVER; + goto _OVER; } if (mndCheckWriteAuth(pUser, pDb) != 0) { - goto CREATE_STB_OVER; + goto _OVER; } code = mndCreateStb(pMnode, pReq, &createReq, pDb); if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS; -CREATE_STB_OVER: +_OVER: if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) { mError("stb:%s, failed to create since %s", createReq.name, terrstr()); } @@ -1211,23 +1211,23 @@ static int32_t mndAlterStb(SMnode *pMnode, SNodeMsg *pReq, const SMAltertbReq *p break; } - if (code != 0) goto ALTER_STB_OVER; + if (code != 0) goto _OVER; code = -1; pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_ALTER_STB, &pReq->rpcMsg); - if (pTrans == NULL) goto ALTER_STB_OVER; + if (pTrans == NULL) goto _OVER; mDebug("trans:%d, used to alter stb:%s", pTrans->id, pAlter->name); mndTransSetDbInfo(pTrans, pDb); - if (mndSetAlterStbRedoLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto ALTER_STB_OVER; - if (mndSetAlterStbCommitLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto ALTER_STB_OVER; - if (mndSetAlterStbRedoActions(pMnode, pTrans, pDb, &stbObj) != 0) goto ALTER_STB_OVER; - if (mndTransPrepare(pMnode, pTrans) != 0) goto ALTER_STB_OVER; + if (mndSetAlterStbRedoLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER; + if (mndSetAlterStbCommitLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER; + if (mndSetAlterStbRedoActions(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER; + if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER; code = 0; -ALTER_STB_OVER: +_OVER: mndTransDrop(pTrans); taosMemoryFreeClear(stbObj.pTags); taosMemoryFreeClear(stbObj.pColumns); @@ -1244,37 +1244,37 @@ static int32_t mndProcessMAlterStbReq(SNodeMsg *pReq) { if (tDeserializeSMAlterStbReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &alterReq) != 0) { terrno = TSDB_CODE_INVALID_MSG; - goto ALTER_STB_OVER; + goto _OVER; } mDebug("stb:%s, start to alter", alterReq.name); - if (mndCheckAlterStbReq(&alterReq) != 0) goto ALTER_STB_OVER; + if (mndCheckAlterStbReq(&alterReq) != 0) goto _OVER; pDb = mndAcquireDbByStb(pMnode, alterReq.name); if (pDb == NULL) { terrno = TSDB_CODE_MND_INVALID_DB; - goto ALTER_STB_OVER; + goto _OVER; } pStb = mndAcquireStb(pMnode, alterReq.name); if (pStb == NULL) { terrno = TSDB_CODE_MND_STB_NOT_EXIST; - goto ALTER_STB_OVER; + goto _OVER; } pUser = mndAcquireUser(pMnode, pReq->user); if (pUser == NULL) { - goto ALTER_STB_OVER; + goto _OVER; } if (mndCheckWriteAuth(pUser, pDb) != 0) { - goto ALTER_STB_OVER; + goto _OVER; } code = mndAlterStb(pMnode, pReq, &alterReq, pDb, pStb); if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS; -ALTER_STB_OVER: +_OVER: if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) { mError("stb:%s, failed to alter since %s", alterReq.name, terrstr()); } @@ -1353,19 +1353,19 @@ static int32_t mndSetDropStbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj * static int32_t mndDropStb(SMnode *pMnode, SNodeMsg *pReq, SDbObj *pDb, SStbObj *pStb) { int32_t code = -1; STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_DROP_STB, &pReq->rpcMsg); - if (pTrans == NULL) goto DROP_STB_OVER; + if (pTrans == NULL) goto _OVER; mDebug("trans:%d, used to drop stb:%s", pTrans->id, pStb->name); mndTransSetDbInfo(pTrans, pDb); - if (mndSetDropStbRedoLogs(pMnode, pTrans, pStb) != 0) goto DROP_STB_OVER; - if (mndSetDropStbCommitLogs(pMnode, pTrans, pStb) != 0) goto DROP_STB_OVER; - if (mndSetDropStbRedoActions(pMnode, pTrans, pDb, pStb) != 0) goto DROP_STB_OVER; - if (mndTransPrepare(pMnode, pTrans) != 0) goto DROP_STB_OVER; + if (mndSetDropStbRedoLogs(pMnode, pTrans, pStb) != 0) goto _OVER; + if (mndSetDropStbCommitLogs(pMnode, pTrans, pStb) != 0) goto _OVER; + if (mndSetDropStbRedoActions(pMnode, pTrans, pDb, pStb) != 0) goto _OVER; + if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER; code = 0; -DROP_STB_OVER: +_OVER: mndTransDrop(pTrans); return code; } @@ -1380,7 +1380,7 @@ static int32_t mndProcessMDropStbReq(SNodeMsg *pReq) { if (tDeserializeSMDropStbReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) { terrno = TSDB_CODE_INVALID_MSG; - goto DROP_STB_OVER; + goto _OVER; } mDebug("stb:%s, start to drop", dropReq.name); @@ -1390,32 +1390,32 @@ static int32_t mndProcessMDropStbReq(SNodeMsg *pReq) { if (dropReq.igNotExists) { mDebug("stb:%s, not exist, ignore not exist is set", dropReq.name); code = 0; - goto DROP_STB_OVER; + goto _OVER; } else { terrno = TSDB_CODE_MND_STB_NOT_EXIST; - goto DROP_STB_OVER; + goto _OVER; } } pDb = mndAcquireDbByStb(pMnode, dropReq.name); if (pDb == NULL) { terrno = TSDB_CODE_MND_DB_NOT_SELECTED; - goto DROP_STB_OVER; + goto _OVER; } pUser = mndAcquireUser(pMnode, pReq->user); if (pUser == NULL) { - goto DROP_STB_OVER; + goto _OVER; } if (mndCheckWriteAuth(pUser, pDb) != 0) { - goto DROP_STB_OVER; + goto _OVER; } code = mndDropStb(pMnode, pReq, pDb, pStb); if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS; -DROP_STB_OVER: +_OVER: if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) { mError("stb:%s, failed to drop since %s", dropReq.name, terrstr()); } @@ -1509,36 +1509,36 @@ static int32_t mndProcessTableMetaReq(SNodeMsg *pReq) { if (tDeserializeSTableInfoReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &infoReq) != 0) { terrno = TSDB_CODE_INVALID_MSG; - goto RETRIEVE_META_OVER; + goto _OVER; } if (0 == strcmp(infoReq.dbFName, TSDB_INFORMATION_SCHEMA_DB)) { mDebug("information_schema table:%s.%s, start to retrieve meta", infoReq.dbFName, infoReq.tbName); if (mndBuildInsTableSchema(pMnode, infoReq.dbFName, infoReq.tbName, &metaRsp) != 0) { - goto RETRIEVE_META_OVER; + goto _OVER; } } else if (0 == strcmp(infoReq.dbFName, TSDB_PERFORMANCE_SCHEMA_DB)) { mDebug("performance_schema table:%s.%s, start to retrieve meta", infoReq.dbFName, infoReq.tbName); if (mndBuildPerfsTableSchema(pMnode, infoReq.dbFName, infoReq.tbName, &metaRsp) != 0) { - goto RETRIEVE_META_OVER; + goto _OVER; } } else { mDebug("stb:%s.%s, start to retrieve meta", infoReq.dbFName, infoReq.tbName); if (mndBuildStbSchema(pMnode, infoReq.dbFName, infoReq.tbName, &metaRsp) != 0) { - goto RETRIEVE_META_OVER; + goto _OVER; } } int32_t rspLen = tSerializeSTableMetaRsp(NULL, 0, &metaRsp); if (rspLen < 0) { terrno = TSDB_CODE_INVALID_MSG; - goto RETRIEVE_META_OVER; + goto _OVER; } void *pRsp = rpcMallocCont(rspLen); if (pRsp == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - goto RETRIEVE_META_OVER; + goto _OVER; } tSerializeSTableMetaRsp(pRsp, rspLen, &metaRsp); @@ -1548,7 +1548,7 @@ static int32_t mndProcessTableMetaReq(SNodeMsg *pReq) { mDebug("stb:%s.%s, meta is retrieved", infoReq.dbFName, infoReq.tbName); -RETRIEVE_META_OVER: +_OVER: if (code != 0) { mError("stb:%s.%s, failed to retrieve meta since %s", infoReq.dbFName, infoReq.tbName, terrstr()); } diff --git a/source/dnode/mnode/impl/test/func/func.cpp b/source/dnode/mnode/impl/test/func/func.cpp index 6b9c410738dd0e0bf4300299b7df7ede39ee1524..22b0387d8b83c3498b0fd71434200f7da0e63d7f 100644 --- a/source/dnode/mnode/impl/test/func/func.cpp +++ b/source/dnode/mnode/impl/test/func/func.cpp @@ -21,10 +21,25 @@ class MndTestFunc : public ::testing::Test { public: void SetUp() override {} void TearDown() override {} + + void SetCode(SCreateFuncReq* pReq, const char* pCode); + void SetComment(SCreateFuncReq* pReq, const char* pComment); }; Testbase MndTestFunc::test; +void MndTestFunc::SetCode(SCreateFuncReq* pReq, const char* pCode) { + int32_t len = strlen(pCode); + pReq->pCode = (char*)taosMemoryCalloc(1, len + 1); + strcpy(pReq->pCode, pCode); +} + +void MndTestFunc::SetComment(SCreateFuncReq* pReq, const char* pComment) { + int32_t len = strlen(pComment); + pReq->pComment = (char*)taosMemoryCalloc(1, len + 1); + strcpy(pReq->pComment, pComment); +} + TEST_F(MndTestFunc, 01_Show_Func) { test.SendShowReq(TSDB_MGMT_TABLE_FUNC, "user_functions", ""); EXPECT_EQ(test.GetShowRows(), 0); @@ -38,6 +53,7 @@ TEST_F(MndTestFunc, 02_Create_Func) { int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); tSerializeSCreateFuncReq(pReq, contLen, &createReq); + tFreeSCreateFuncReq(&createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -47,10 +63,12 @@ TEST_F(MndTestFunc, 02_Create_Func) { { SCreateFuncReq createReq = {0}; strcpy(createReq.name, "f1"); + SetCode(&createReq, "code1"); int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); tSerializeSCreateFuncReq(pReq, contLen, &createReq); + tFreeSCreateFuncReq(&createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -60,25 +78,12 @@ TEST_F(MndTestFunc, 02_Create_Func) { { SCreateFuncReq createReq = {0}; strcpy(createReq.name, "f1"); - createReq.commentSize = TSDB_FUNC_COMMENT_LEN + 1; - - int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq); - void* pReq = rpcMallocCont(contLen); - tSerializeSCreateFuncReq(pReq, contLen, &createReq); - - SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen); - ASSERT_NE(pRsp, nullptr); - ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_COMMENT); - } - - { - SCreateFuncReq createReq = {0}; - strcpy(createReq.name, "f1"); - createReq.commentSize = TSDB_FUNC_COMMENT_LEN; + SetComment(&createReq, "comment1"); int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); tSerializeSCreateFuncReq(pReq, contLen, &createReq); + tFreeSCreateFuncReq(&createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -88,27 +93,29 @@ TEST_F(MndTestFunc, 02_Create_Func) { { SCreateFuncReq createReq = {0}; strcpy(createReq.name, "f1"); - createReq.commentSize = TSDB_FUNC_COMMENT_LEN; - createReq.codeSize = TSDB_FUNC_CODE_LEN + 1; + SetCode(&createReq, "code1"); + SetComment(&createReq, ""); int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); tSerializeSCreateFuncReq(pReq, contLen, &createReq); + tFreeSCreateFuncReq(&createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); - ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_CODE); + ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_COMMENT); } { SCreateFuncReq createReq = {0}; strcpy(createReq.name, "f1"); - createReq.commentSize = TSDB_FUNC_COMMENT_LEN; - createReq.codeSize = TSDB_FUNC_CODE_LEN; + SetCode(&createReq, ""); + SetComment(&createReq, "comment1"); int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); tSerializeSCreateFuncReq(pReq, contLen, &createReq); + tFreeSCreateFuncReq(&createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -118,13 +125,13 @@ TEST_F(MndTestFunc, 02_Create_Func) { { SCreateFuncReq createReq = {0}; strcpy(createReq.name, "f1"); - createReq.commentSize = TSDB_FUNC_COMMENT_LEN; - createReq.codeSize = TSDB_FUNC_CODE_LEN; - createReq.pCode[0] = 'a'; + SetCode(&createReq, "code1"); + SetComment(&createReq, "comment1"); int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); tSerializeSCreateFuncReq(pReq, contLen, &createReq); + tFreeSCreateFuncReq(&createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -134,14 +141,14 @@ TEST_F(MndTestFunc, 02_Create_Func) { { SCreateFuncReq createReq = {0}; strcpy(createReq.name, "f1"); - createReq.commentSize = TSDB_FUNC_COMMENT_LEN; - createReq.codeSize = TSDB_FUNC_CODE_LEN; - createReq.pCode[0] = 'a'; + SetCode(&createReq, "code1"); + SetComment(&createReq, "comment1"); createReq.bufSize = TSDB_FUNC_BUF_SIZE + 1; int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); tSerializeSCreateFuncReq(pReq, contLen, &createReq); + tFreeSCreateFuncReq(&createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -151,9 +158,8 @@ TEST_F(MndTestFunc, 02_Create_Func) { for (int32_t i = 0; i < 3; ++i) { SCreateFuncReq createReq = {0}; strcpy(createReq.name, "f1"); - createReq.commentSize = TSDB_FUNC_COMMENT_LEN; - createReq.codeSize = TSDB_FUNC_CODE_LEN; - createReq.pCode[0] = 'a'; + SetCode(&createReq, "code1"); + SetComment(&createReq, "comment1"); createReq.bufSize = TSDB_FUNC_BUF_SIZE + 1; createReq.igExists = 0; if (i == 2) createReq.igExists = 1; @@ -163,16 +169,11 @@ TEST_F(MndTestFunc, 02_Create_Func) { createReq.outputLen = 12; createReq.bufSize = 4; createReq.signature = 5; - for (int32_t i = 0; i < createReq.commentSize - 1; ++i) { - createReq.pComment[i] = 'm'; - } - for (int32_t i = 0; i < createReq.codeSize - 1; ++i) { - createReq.pCode[i] = 'd'; - } int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); tSerializeSCreateFuncReq(pReq, contLen, &createReq); + tFreeSCreateFuncReq(&createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -197,7 +198,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq); void* pReq = rpcMallocCont(contLen); tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq); - taosArrayDestroy(retrieveReq.pFuncNames); + tFreeSRetrieveFuncReq(&retrieveReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -217,20 +218,10 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { EXPECT_EQ(pFuncInfo->outputLen, 12); EXPECT_EQ(pFuncInfo->bufSize, 4); EXPECT_EQ(pFuncInfo->signature, 5); - EXPECT_EQ(pFuncInfo->commentSize, TSDB_FUNC_COMMENT_LEN); - EXPECT_EQ(pFuncInfo->codeSize, TSDB_FUNC_CODE_LEN); + EXPECT_STREQ("comment1", pFuncInfo->pComment); + EXPECT_STREQ("code1", pFuncInfo->pCode); - char comments[TSDB_FUNC_COMMENT_LEN] = {0}; - for (int32_t i = 0; i < TSDB_FUNC_COMMENT_LEN - 1; ++i) { - comments[i] = 'm'; - } - char codes[TSDB_FUNC_CODE_LEN] = {0}; - for (int32_t i = 0; i < TSDB_FUNC_CODE_LEN - 1; ++i) { - codes[i] = 'd'; - } - EXPECT_STREQ(comments, pFuncInfo->pComment); - EXPECT_STREQ(codes, pFuncInfo->pCode); - taosArrayDestroy(retrieveRsp.pFuncInfos); + tFreeSRetrieveFuncRsp(&retrieveRsp); } { @@ -241,7 +232,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq); void* pReq = rpcMallocCont(contLen); tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq); - taosArrayDestroy(retrieveReq.pFuncNames); + tFreeSRetrieveFuncReq(&retrieveReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -259,7 +250,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq); void* pReq = rpcMallocCont(contLen); tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq); - taosArrayDestroy(retrieveReq.pFuncNames); + tFreeSRetrieveFuncReq(&retrieveReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -275,7 +266,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq); void* pReq = rpcMallocCont(contLen); tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq); - taosArrayDestroy(retrieveReq.pFuncNames); + tFreeSRetrieveFuncReq(&retrieveReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -285,8 +276,6 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { { SCreateFuncReq createReq = {0}; strcpy(createReq.name, "f2"); - createReq.commentSize = 1024; - createReq.codeSize = 9527; createReq.igExists = 1; createReq.funcType = 2; createReq.scriptType = 3; @@ -294,16 +283,13 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { createReq.outputLen = 24; createReq.bufSize = 6; createReq.signature = 18; - for (int32_t i = 0; i < createReq.commentSize - 1; ++i) { - createReq.pComment[i] = 'p'; - } - for (int32_t i = 0; i < createReq.codeSize - 1; ++i) { - createReq.pCode[i] = 'q'; - } + SetCode(&createReq, "code2"); + SetComment(&createReq, "comment2"); int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); tSerializeSCreateFuncReq(pReq, contLen, &createReq); + tFreeSCreateFuncReq(&createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -322,7 +308,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq); void* pReq = rpcMallocCont(contLen); tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq); - taosArrayDestroy(retrieveReq.pFuncNames); + tFreeSRetrieveFuncReq(&retrieveReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -342,21 +328,13 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { EXPECT_EQ(pFuncInfo->outputLen, 24); EXPECT_EQ(pFuncInfo->bufSize, 6); EXPECT_EQ(pFuncInfo->signature, 18); - EXPECT_EQ(pFuncInfo->commentSize, 1024); - EXPECT_EQ(pFuncInfo->codeSize, 9527); + EXPECT_EQ(pFuncInfo->commentSize, strlen("comment2") + 1); + EXPECT_EQ(pFuncInfo->codeSize, strlen("code2") + 1); - char comments[TSDB_FUNC_COMMENT_LEN] = {0}; - for (int32_t i = 0; i < 1024 - 1; ++i) { - comments[i] = 'p'; - } - char codes[TSDB_FUNC_CODE_LEN] = {0}; - for (int32_t i = 0; i < 9527 - 1; ++i) { - codes[i] = 'q'; - } + EXPECT_STREQ("comment2", pFuncInfo->pComment); + EXPECT_STREQ("code2", pFuncInfo->pCode); - EXPECT_STREQ(comments, pFuncInfo->pComment); - EXPECT_STREQ(codes, pFuncInfo->pCode); - taosArrayDestroy(retrieveRsp.pFuncInfos); + tFreeSRetrieveFuncRsp(&retrieveRsp); } { @@ -369,7 +347,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq); void* pReq = rpcMallocCont(contLen); tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq); - taosArrayDestroy(retrieveReq.pFuncNames); + tFreeSRetrieveFuncReq(&retrieveReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -389,20 +367,10 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { EXPECT_EQ(pFuncInfo->outputLen, 24); EXPECT_EQ(pFuncInfo->bufSize, 6); EXPECT_EQ(pFuncInfo->signature, 18); - EXPECT_EQ(pFuncInfo->commentSize, 1024); - EXPECT_EQ(pFuncInfo->codeSize, 9527); - - char comments[TSDB_FUNC_COMMENT_LEN] = {0}; - for (int32_t i = 0; i < 1024 - 1; ++i) { - comments[i] = 'p'; - } - char codes[TSDB_FUNC_CODE_LEN] = {0}; - for (int32_t i = 0; i < 9527 - 1; ++i) { - codes[i] = 'q'; - } - - EXPECT_STREQ(comments, pFuncInfo->pComment); - EXPECT_STREQ(codes, pFuncInfo->pCode); + EXPECT_EQ(pFuncInfo->commentSize, strlen("comment2") + 1); + EXPECT_EQ(pFuncInfo->codeSize, strlen("code2") + 1); + EXPECT_STREQ("comment2", pFuncInfo->pComment); + EXPECT_STREQ("code2", pFuncInfo->pCode); } { @@ -414,21 +382,11 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { EXPECT_EQ(pFuncInfo->outputLen, 12); EXPECT_EQ(pFuncInfo->bufSize, 4); EXPECT_EQ(pFuncInfo->signature, 5); - EXPECT_EQ(pFuncInfo->commentSize, TSDB_FUNC_COMMENT_LEN); - EXPECT_EQ(pFuncInfo->codeSize, TSDB_FUNC_CODE_LEN); - - char comments[TSDB_FUNC_COMMENT_LEN] = {0}; - for (int32_t i = 0; i < TSDB_FUNC_COMMENT_LEN - 1; ++i) { - comments[i] = 'm'; - } - char codes[TSDB_FUNC_CODE_LEN] = {0}; - for (int32_t i = 0; i < TSDB_FUNC_CODE_LEN - 1; ++i) { - codes[i] = 'd'; - } - EXPECT_STREQ(comments, pFuncInfo->pComment); - EXPECT_STREQ(codes, pFuncInfo->pCode); + EXPECT_STREQ("comment1", pFuncInfo->pComment); + EXPECT_STREQ("code1", pFuncInfo->pCode); } - taosArrayDestroy(retrieveRsp.pFuncInfos); + + tFreeSRetrieveFuncRsp(&retrieveRsp); } { @@ -441,7 +399,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq); void* pReq = rpcMallocCont(contLen); tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq); - taosArrayDestroy(retrieveReq.pFuncNames); + tFreeSRetrieveFuncReq(&retrieveReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); diff --git a/source/os/src/osFile.c b/source/os/src/osFile.c index 4b55d4912cba3157186b3a6aaf557e964866a4ca..c2c4af18e5cafe14276ca7e6c65df2a6c982b213 100644 --- a/source/os/src/osFile.c +++ b/source/os/src/osFile.c @@ -772,6 +772,9 @@ int64_t taosGetLineFile(TdFilePtr pFile, char **__restrict ptrBuf) { if (pFile == NULL) { return -1; } + if (*ptrBuf != NULL) { + taosMemoryFreeClear(*ptrBuf); + } assert(pFile->fp != NULL); size_t len = 0; diff --git a/tests/script/tsim/bnode/basic1.sim b/tests/script/tsim/bnode/basic1.sim index 0ce0c2bc5df2a30b11fdd9829abfae651ac7ce85..b1db6efc72afce083d9594987ccee3d10ab83ef4 100644 --- a/tests/script/tsim/bnode/basic1.sim +++ b/tests/script/tsim/bnode/basic1.sim @@ -24,7 +24,7 @@ if $data00 != 1 then return -1 endi -if $data02 != master then +if $data02 != LEADER then return -1 endi @@ -71,7 +71,7 @@ if $data00 != 1 then return -1 endi -if $data02 != master then +if $data02 != LEADER then return -1 endi diff --git a/tests/script/tsim/db/alter_option.sim b/tests/script/tsim/db/alter_option.sim index e9795bd8d2ade40100bdbd4228ea2f30e8a3d190..525de9c5c47375b8fd5797450645c3bb3178aed3 100644 --- a/tests/script/tsim/db/alter_option.sim +++ b/tests/script/tsim/db/alter_option.sim @@ -72,7 +72,7 @@ print rows: $rows print $data00 $data01 $data02 $data03 $data04 $data05 $data06 $data07 $data08 $data09 print $data10 $data11 $data12 $data13 $data14 $data15 $data16 $data17 $data18 $data19 print ====> dataX_db -print $data0_db $data1_db $data2_db $data3_db $data4_db $data5_db $data6_db $data7_db $data8_db $data9_db $data10_db $data11_db $data12_db $data13_db $data14_db $data15_db $data16_db $data17_db +print $data(db)[0] $data(db)[1] $data2_db $data3_db $data4_db $data5_db $data6_db $data7_db $data8_db $data9_db $data10_db $data11_db $data12_db $data13_db $data14_db $data15_db $data16_db $data17_db if $rows != 3 then return -1 diff --git a/tests/script/tsim/db/basic6.sim b/tests/script/tsim/db/basic6.sim index 4d0a1e9ee9c6f08632ed9fedbeabe04ad9ec498d..f682dcc8162d6db4049c241ee4b6ba6abe336865 100644 --- a/tests/script/tsim/db/basic6.sim +++ b/tests/script/tsim/db/basic6.sim @@ -17,7 +17,6 @@ print =============== step1 # quorum presicion sql create database $db vgroups 8 replica 1 days 2880 keep 3650 cache 32 blocks 12 minrows 80 maxrows 10000 wal 2 fsync 1000 comp 0 cachelast 2 precision 'us' sql show databases -print $data0_1 $data1_1 $data2_1 $data3_1 $data4_1 $data5_1 $data6_1 $data7_1 $data8_1 $data9_1 print $data00 $data01 $data02 $data03 $data04 $data05 $data06 $data07 $data08 $data09 if $rows != 3 then diff --git a/tests/script/tsim/dnode/basic1.sim b/tests/script/tsim/dnode/basic1.sim index 51399e905003f8ec00f21a9c7d0edc66fa7e469e..d49dba60f3940094245c0a9f82a912d3a97155c4 100644 --- a/tests/script/tsim/dnode/basic1.sim +++ b/tests/script/tsim/dnode/basic1.sim @@ -29,7 +29,7 @@ if $data00 != 1 then return -1 endi -if $data02 != master then +if $data02 != LEADER then return -1 endi @@ -76,7 +76,7 @@ if $data00 != 1 then return -1 endi -if $data02 != master then +if $data02 != LEADER then return -1 endi diff --git a/tests/script/tsim/mnode/basic1.sim b/tests/script/tsim/mnode/basic1.sim index e3d27d0c132d2f45838a1ac786d551be9bafac06..235889ece6da4aa2713d5dac2cc306f52cd694cd 100644 --- a/tests/script/tsim/mnode/basic1.sim +++ b/tests/script/tsim/mnode/basic1.sim @@ -24,7 +24,7 @@ if $data00 != 1 then return -1 endi -if $data02 != master then +if $data02 != LEADER then return -1 endi @@ -71,7 +71,7 @@ if $data00 != 1 then return -1 endi -if $data02 != master then +if $data02 != LEADER then return -1 endi diff --git a/tests/script/tsim/qnode/basic1.sim b/tests/script/tsim/qnode/basic1.sim index 3b478cfa46a6de47234fd3cb078b3cf84ec509c3..2351403909e9f641e2ada2789561a095a0e915d4 100644 --- a/tests/script/tsim/qnode/basic1.sim +++ b/tests/script/tsim/qnode/basic1.sim @@ -24,7 +24,7 @@ if $data00 != 1 then return -1 endi -if $data02 != master then +if $data02 != LEADER then return -1 endi @@ -71,7 +71,7 @@ if $data00 != 1 then return -1 endi -if $data02 != master then +if $data02 != LEADER then return -1 endi diff --git a/tests/script/tsim/query/explain.sim b/tests/script/tsim/query/explain.sim index 5119f58ec3da27e235e52e9fc8376405a5d67621..638109d5105dd95e07f93cf90308124483a5ed82 100644 --- a/tests/script/tsim/query/explain.sim +++ b/tests/script/tsim/query/explain.sim @@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1 system sh/cfg.sh -n dnode1 -c wallevel -v 2 system sh/cfg.sh -n dnode1 -c numOfMnodes -v 1 -print ========= start dnode1 as master +print ========= start dnode1 as LEADER system sh/exec.sh -n dnode1 -s start sleep 2000 sql connect diff --git a/tests/script/tsim/query/session.sim b/tests/script/tsim/query/session.sim index 6f4010c3f3e8bdc443765360c4372bdb8e7ac455..d5e77c7b28471fe84ddf6fbe8310ba038f1ac358 100644 --- a/tests/script/tsim/query/session.sim +++ b/tests/script/tsim/query/session.sim @@ -26,14 +26,6 @@ sql connect $vgroups = 4 $dbNamme = d0 -print ====> create database d1 precision 'us' -sql create database d1 precision 'us' -sql use d1 -sql create table dev_001 (ts timestamp ,i timestamp ,j int) -sql insert into dev_001 values(1623046993681000,now,1)(1623046993681001,now+1s,2)(1623046993681002,now+2s,3)(1623046993681004,now+5s,4) -sql create table secondts(ts timestamp,t2 timestamp,i int) -sql insert into secondts values(1623046993681000,now,1)(1623046993681001,now+1s,2)(1623046993681002,now+2s,3)(1623046993681004,now+5s,4) - print ====> create database $dbNamme vgroups $vgroups sql create database $dbNamme vgroups $vgroups sql show databases @@ -296,11 +288,14 @@ sql_error select count(*) from dev_001 session(i,1y) sql_error select count(*) from dev_001 session(ts,1d) where ts <'2020-05-20 0:0:0' # vnode does not return the precision of the table -#print ====> create database d1 precision 'us' -#sql create database d1 precision 'us' -#sql use d1 -#sql create table dev_001 (ts timestamp ,i timestamp ,j int) -#sql insert into dev_001 values(1623046993681000,now,1)(1623046993681001,now+1s,2)(1623046993681002,now+2s,3)(1623046993681004,now+5s,4) +print ====> create database d1 precision 'us' +sql create database d1 precision 'us' +sql use d1 +sql create table dev_001 (ts timestamp ,i timestamp ,j int) +sql insert into dev_001 values(1623046993681000,now,1)(1623046993681001,now+1s,2)(1623046993681002,now+2s,3)(1623046993681004,now+5s,4) +sql create table secondts(ts timestamp,t2 timestamp,i int) +sql insert into secondts values(1623046993681000,now,1)(1623046993681001,now+1s,2)(1623046993681002,now+2s,3)(1623046993681004,now+5s,4) + #print ====> select count(*) from dev_001 session(ts,1u) #sql select _wstartts, count(*) from dev_001 session(ts,1u) #print rows: $rows @@ -312,14 +307,12 @@ sql_error select count(*) from dev_001 session(ts,1d) where ts <'2020-05-20 0:0: # print expect 2, actual: $rows # return -1 #endi -# #if $data01 != 1 then # return -1 #endi -#sql_error select count(*) from dev_001 session(i,1s) -sql create table secondts(ts timestamp,t2 timestamp,i int) -#sql_error select count(*) from secondts session(t2,2s) +sql_error select count(*) from dev_001 session(i,1s) +sql_error select count(*) from secondts session(t2,2s) if $loop_test == 0 then print =============== stop and restart taosd diff --git a/tests/script/tsim/snode/basic1.sim b/tests/script/tsim/snode/basic1.sim index 3b478cfa46a6de47234fd3cb078b3cf84ec509c3..2351403909e9f641e2ada2789561a095a0e915d4 100644 --- a/tests/script/tsim/snode/basic1.sim +++ b/tests/script/tsim/snode/basic1.sim @@ -24,7 +24,7 @@ if $data00 != 1 then return -1 endi -if $data02 != master then +if $data02 != LEADER then return -1 endi @@ -71,7 +71,7 @@ if $data00 != 1 then return -1 endi -if $data02 != master then +if $data02 != LEADER then return -1 endi diff --git a/tests/script/tsim/user/basic1.sim b/tests/script/tsim/user/basic1.sim index 7af5ba8d001bd9795378f53b91663d671afc351f..06a52c6604fe8b6742f8efcae5f2cdb87628a149 100644 --- a/tests/script/tsim/user/basic1.sim +++ b/tests/script/tsim/user/basic1.sim @@ -9,9 +9,9 @@ if $rows != 1 then return -1 endi -print $data00 $data01 $data02 -print $data10 $data11 $data22 -print $data20 $data11 $data22 +print $data[0][0] $data[0][1] $data[0][2] +print $data[1][0] $data[1][1] $data[1][2] +print $data[2][0] $data[1][2] $data[2][2] sql_error show accounts; sql_error create account a pass "a" @@ -25,10 +25,10 @@ if $rows != 2 then return -1 endi -print $data00 $data01 $data02 -print $data10 $data11 $data12 -print $data20 $data11 $data22 -print $data30 $data31 $data32 +print $data[0][0] $data[0][1] $data[0][2] +print $data[1][0] $data[1][1] $data[1][2] +print $data[2][0] $data[1][2] $data[2][2] +print $data[3][0] $data[3][1] $data[3][2] print =============== create user2 sql create user user2 PASS 'user2' @@ -37,10 +37,10 @@ if $rows != 3 then return -1 endi -print $data00 $data01 $data02 -print $data10 $data11 $data12 -print $data20 $data11 $data22 -print $data30 $data31 $data32 +print $data[0][0] $data[0][1] $data[0][2] +print $data[1][0] $data[1][1] $data[1][2] +print $data[2][0] $data[1][2] $data[2][2] +print $data[3][0] $data[3][1] $data[3][2] print $data40 $data41 $data42 print =============== drop user1 @@ -50,10 +50,10 @@ if $rows != 2 then return -1 endi -print $data00 $data01 $data02 -print $data10 $data11 $data22 -print $data20 $data11 $data22 -print $data30 $data31 $data32 +print $data[0][0] $data[0][1] $data[0][2] +print $data[1][0] $data[1][1] $data[1][2] +print $data[2][0] $data[1][2] $data[2][2] +print $data[3][0] $data[3][1] $data[3][2] print =============== restart taosd system sh/exec.sh -n dnode1 -s stop @@ -66,9 +66,9 @@ if $rows != 2 then return -1 endi -print $data00 $data01 $data02 -print $data10 $data11 $data22 -print $data20 $data11 $data22 -print $data30 $data31 $data32 +print $data[0][0] $data[0][1] $data[0][2] +print $data[1][0] $data[1][1] $data[1][2] +print $data[2][0] $data[1][2] $data[2][2] +print $data[3][0] $data[3][1] $data[3][2] system sh/exec.sh -n dnode1 -s stop -x SIGINT diff --git a/tests/tsim/inc/simInt.h b/tests/tsim/inc/simInt.h index 24119b1433562fae32623675bb7f1d4f816dddb8..f9e96fc67b20eee8b05619475c3d577cfa5b659c 100644 --- a/tests/tsim/inc/simInt.h +++ b/tests/tsim/inc/simInt.h @@ -33,9 +33,9 @@ #define MAX_BACKGROUND_SCRIPT_NUM 10 #define MAX_FILE_NAME_LEN 256 #define MAX_ERROR_LEN 1024 -#define MAX_QUERY_VALUE_LEN 10240 -#define MAX_QUERY_COL_NUM 20 -#define MAX_QUERY_ROW_NUM 20 +#define MAX_QUERY_VALUE_LEN 1024 +#define MAX_QUERY_COL_NUM 100 +#define MAX_QUERY_ROW_NUM 100 #define MAX_SYSTEM_RESULT_LEN 2048 #define MAX_VAR_LEN 100 #define MAX_VAR_NAME_LEN 32 diff --git a/tests/tsim/src/simExe.c b/tests/tsim/src/simExe.c index a4db0eff13f15856976db159a65d220b0203df35..8b3edb6035e7cde02ef6ff348fec68f791712d0d 100644 --- a/tests/tsim/src/simExe.c +++ b/tests/tsim/src/simExe.c @@ -49,6 +49,41 @@ char *simParseHostName(char *varName) { return hostName; } +static void simFindFirstNum(const char *begin, int32_t beginLen, int32_t *num) { + if (beginLen <= 5) { + *num = 0; + } else { + *num = atoi(begin + 5); + } +} + +static void simFindSecondNum(const char *begin, int32_t beginLen, int32_t *num) { + const char *number = strstr(begin, "]["); + if (number == NULL) { + *num = 0; + } else { + *num = atoi(number + 2); + } +} + +static void simFindFirstKeyVal(const char *begin, int32_t beginLen, char *key, int32_t keyLen) { + key[0] = 0; + for (int32_t i = 5; i < beginLen && i - 5 < keyLen; ++i) { + if (begin[i] != 0 && begin[i] != ']' && begin[i] != ')') { + key[i - 5] = begin[i]; + } + } +} + +static void simFindSecondKeyNum(const char *begin, int32_t beginLen, int32_t *num) { + const char *number = strstr(begin, ")["); + if (number == NULL) { + *num = 0; + } else { + *num = atoi(number + 2); + } +} + char *simGetVariable(SScript *script, char *varName, int32_t varLen) { if (strncmp(varName, "hostname", 8) == 0) { return simParseHostName(varName); @@ -66,13 +101,40 @@ char *simGetVariable(SScript *script, char *varName, int32_t varLen) { if (strncmp(varName, "system_content", varLen) == 0) return script->system_ret_content; - // variable like data2_192.168.0.1 if (strncmp(varName, "data", 4) == 0) { if (varLen < 6) { return "null"; } - if (varName[5] == '_') { + int32_t row = 0; + int32_t col = 0; + char keyVal[1024] = {0}; + int32_t keyLen = 1024; + + if (varName[4] == '[') { + // $data[0][1] + simFindFirstNum(varName, varLen, &row); + simFindSecondNum(varName, varLen, &col); + if (row < 0 || row >= MAX_QUERY_ROW_NUM) { + return "null"; + } + if (col < 0 || col >= MAX_QUERY_COL_NUM) { + return "null"; + } + simDebug("script:%s, data[%d][%d]=%s", script->fileName, row, col, script->data[row][col]); + return script->data[row][col]; + } else if (varName[4] == '(') { + // $data(db)[0] + simFindFirstKeyVal(varName, varLen, keyVal, keyLen); + simFindSecondKeyNum(varName, varLen, &col); + for (int32_t i = 0; i < MAX_QUERY_ROW_NUM; ++i) { + if (strncmp(keyVal, script->data[i][0], keyLen) == 0) { + simDebug("script:%s, keyName:%s, keyValue:%s", script->fileName, script->data[i][0], script->data[i][col]); + return script->data[i][col]; + } + } + } else if (varName[5] == '_') { + // data2_db int32_t col = varName[4] - '0'; if (col < 0 || col >= MAX_QUERY_COL_NUM) { return "null"; @@ -90,6 +152,7 @@ char *simGetVariable(SScript *script, char *varName, int32_t varLen) { } return "null"; } else if (varName[6] == '_') { + // data21_db int32_t col = (varName[4] - '0') * 10 + (varName[5] - '0'); if (col < 0 || col >= MAX_QUERY_COL_NUM) { return "null"; @@ -107,6 +170,7 @@ char *simGetVariable(SScript *script, char *varName, int32_t varLen) { } return "null"; } else { + // $data00 int32_t row = varName[4] - '0'; int32_t col = varName[5] - '0'; if (row < 0 || row >= MAX_QUERY_ROW_NUM) { @@ -119,6 +183,8 @@ char *simGetVariable(SScript *script, char *varName, int32_t varLen) { simDebug("script:%s, data[%d][%d]=%s", script->fileName, row, col, script->data[row][col]); return script->data[row][col]; } + + return "null"; } for (int32_t i = 0; i < script->varLen; ++i) { @@ -127,9 +193,6 @@ char *simGetVariable(SScript *script, char *varName, int32_t varLen) { continue; } if (strncmp(varName, var->varName, varLen) == 0) { - // if (strlen(var->varValue) != 0) - // simDebug("script:%s, var:%s, value:%s", script->fileName, - // var->varName, var->varValue); return var->varValue; } }