diff --git a/.gitignore b/.gitignore index 334947a64c..1798a920eb 100644 --- a/.gitignore +++ b/.gitignore @@ -100,6 +100,9 @@ tests/examples/JDBC/JDBCDemo/.project tests/examples/JDBC/JDBCDemo/.settings/ source/libs/parser/inc/sql.* tests/script/tmqResult.txt +tests/system-test/case_to_run.txt +tests/develop-test/case_to_run.txt +tests/scripts/case_to_run.txt tests/tmqResult.txt tests/script/jenkins/basic.txt diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index f0aaf183d7..1bc9dd07cf 100644 --- a/source/common/src/tmsg.c +++ b/source/common/src/tmsg.c @@ -2651,125 +2651,171 @@ void tFreeSGetUserAuthRsp(SGetUserAuthRsp *pRsp) { int32_t tSerializeSGetUserWhiteListReq(void *buf, int32_t bufLen, SGetUserWhiteListReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; + tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->user) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->user)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSGetUserWhiteListReq(void *buf, int32_t bufLen, SGetUserWhiteListReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->user)); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } int32_t tSerializeSGetUserWhiteListRsp(void *buf, int32_t bufLen, SGetUserWhiteListRsp *pRsp) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pRsp->user) < 0) return -1; - if (tEncodeI32(&encoder, pRsp->numWhiteLists) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pRsp->user)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pRsp->numWhiteLists)); for (int i = 0; i < pRsp->numWhiteLists; ++i) { - if (tEncodeU32(&encoder, pRsp->pWhiteLists[i].ip) < 0) return -1; - if (tEncodeU32(&encoder, pRsp->pWhiteLists[i].mask) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeU32(&encoder, pRsp->pWhiteLists[i].ip)); + TAOS_CHECK_EXIT(tEncodeU32(&encoder, pRsp->pWhiteLists[i].mask)); } tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSGetUserWhiteListRsp(void *buf, int32_t bufLen, SGetUserWhiteListRsp *pRsp) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pRsp->user) < 0) return -1; - - if (tDecodeI32(&decoder, &pRsp->numWhiteLists) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pRsp->user)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pRsp->numWhiteLists)); pRsp->pWhiteLists = taosMemoryMalloc(pRsp->numWhiteLists * sizeof(SIpV4Range)); - if (pRsp->pWhiteLists == NULL) return -1; + if (pRsp->pWhiteLists == NULL) { + TAOS_CHECK_EXIT(terrno); + } for (int32_t i = 0; i < pRsp->numWhiteLists; ++i) { - if (tDecodeU32(&decoder, &(pRsp->pWhiteLists[i].ip)) < 0) return -1; - if (tDecodeU32(&decoder, &(pRsp->pWhiteLists[i].mask)) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeU32(&decoder, &(pRsp->pWhiteLists[i].ip))); + TAOS_CHECK_EXIT(tDecodeU32(&decoder, &(pRsp->pWhiteLists[i].mask))); } tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSGetUserWhiteListRsp(SGetUserWhiteListRsp *pRsp) { taosMemoryFree(pRsp->pWhiteLists); } int32_t tSerializeSMCfgClusterReq(void *buf, int32_t bufLen, SMCfgClusterReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->config) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->value) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->config)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->value)); ENCODESQL(); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSMCfgClusterReq(void *buf, int32_t bufLen, SMCfgClusterReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->config) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->value) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->config)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->value)); DECODESQL(); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSMCfgClusterReq(SMCfgClusterReq *pReq) { FREESQL(); } int32_t tSerializeSCreateDropMQSNodeReq(void *buf, int32_t bufLen, SMCreateQnodeReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeI32(&encoder, pReq->dnodeId) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->dnodeId)); ENCODESQL(); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSCreateDropMQSNodeReq(void *buf, int32_t bufLen, SMCreateQnodeReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->dnodeId) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->dnodeId)); DECODESQL(); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSMCreateQnodeReq(SMCreateQnodeReq *pReq) { FREESQL(); } @@ -2778,33 +2824,43 @@ void tFreeSDDropQnodeReq(SDDropQnodeReq *pReq) { FREESQL(); } int32_t tSerializeSDropDnodeReq(void *buf, int32_t bufLen, SDropDnodeReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeI32(&encoder, pReq->dnodeId) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->fqdn) < 0) return -1; - if (tEncodeI32(&encoder, pReq->port) < 0) return -1; - if (tEncodeI8(&encoder, pReq->force) < 0) return -1; - if (tEncodeI8(&encoder, pReq->unsafe) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->dnodeId)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->fqdn)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->port)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->force)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->unsafe)); ENCODESQL(); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSDropDnodeReq(void *buf, int32_t bufLen, SDropDnodeReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->dnodeId) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->fqdn) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->port) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->force) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->dnodeId)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->fqdn)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->port)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->force)); if (!tDecodeIsEnd(&decoder)) { - if (tDecodeI8(&decoder, &pReq->unsafe) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->unsafe)); } else { pReq->unsafe = false; } @@ -2812,214 +2868,270 @@ int32_t tDeserializeSDropDnodeReq(void *buf, int32_t bufLen, SDropDnodeReq *pReq DECODESQL(); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSDropDnodeReq(SDropDnodeReq *pReq) { FREESQL(); } int32_t tSerializeSRestoreDnodeReq(void *buf, int32_t bufLen, SRestoreDnodeReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeI32(&encoder, pReq->dnodeId) < 0) return -1; - if (tEncodeI8(&encoder, pReq->restoreType) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->dnodeId)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->restoreType)); ENCODESQL(); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSRestoreDnodeReq(void *buf, int32_t bufLen, SRestoreDnodeReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->dnodeId) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->restoreType) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->dnodeId)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->restoreType)); DECODESQL(); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSRestoreDnodeReq(SRestoreDnodeReq *pReq) { FREESQL(); } int32_t tSerializeSMCfgDnodeReq(void *buf, int32_t bufLen, SMCfgDnodeReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeI32(&encoder, pReq->dnodeId) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->config) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->value) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->dnodeId)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->config)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->value)); ENCODESQL(); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSMCfgDnodeReq(void *buf, int32_t bufLen, SMCfgDnodeReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->dnodeId) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->config) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->value) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->dnodeId)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->config)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->value)); DECODESQL(); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSMCfgDnodeReq(SMCfgDnodeReq *pReq) { FREESQL(); } int32_t tSerializeSDCfgDnodeReq(void *buf, int32_t bufLen, SDCfgDnodeReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->config) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->value) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->config)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->value)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSDCfgDnodeReq(void *buf, int32_t bufLen, SDCfgDnodeReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->config) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->value) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->config)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->value)); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } int32_t tSerializeSCreateDnodeReq(void *buf, int32_t bufLen, SCreateDnodeReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->fqdn) < 0) return -1; - if (tEncodeI32(&encoder, pReq->port) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->fqdn)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->port)); ENCODESQL(); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSCreateDnodeReq(void *buf, int32_t bufLen, SCreateDnodeReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->fqdn) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->port) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->fqdn)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->port)); DECODESQL(); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSCreateDnodeReq(SCreateDnodeReq *pReq) { FREESQL(); } int32_t tSerializeSCreateFuncReq(void *buf, int32_t bufLen, SCreateFuncReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->name) < 0) return -1; - if (tEncodeI8(&encoder, pReq->igExists) < 0) return -1; - if (tEncodeI8(&encoder, pReq->funcType) < 0) return -1; - if (tEncodeI8(&encoder, pReq->scriptType) < 0) return -1; - if (tEncodeI8(&encoder, pReq->outputType) < 0) return -1; - if (tEncodeI32(&encoder, pReq->outputLen) < 0) return -1; - if (tEncodeI32(&encoder, pReq->bufSize) < 0) return -1; - if (tEncodeI32(&encoder, pReq->codeLen) < 0) return -1; - if (tEncodeI64(&encoder, pReq->signature) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->name)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->igExists)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->funcType)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->scriptType)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->outputType)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->outputLen)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->bufSize)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->codeLen)); + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->signature)); if (pReq->pCode != NULL) { - if (tEncodeBinary(&encoder, pReq->pCode, pReq->codeLen) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeBinary(&encoder, pReq->pCode, pReq->codeLen)); } int32_t commentSize = 0; if (pReq->pComment != NULL) { commentSize = strlen(pReq->pComment) + 1; } - if (tEncodeI32(&encoder, commentSize) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI32(&encoder, commentSize)); if (pReq->pComment != NULL) { - if (tEncodeCStr(&encoder, pReq->pComment) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->pComment)); } - if (tEncodeI8(&encoder, pReq->orReplace) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->orReplace)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSCreateFuncReq(void *buf, int32_t bufLen, SCreateFuncReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->igExists) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->funcType) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->scriptType) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->outputType) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->outputLen) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->bufSize) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->codeLen) < 0) return -1; - if (tDecodeI64(&decoder, &pReq->signature) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->name)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->igExists)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->funcType)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->scriptType)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->outputType)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->outputLen)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->bufSize)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->codeLen)); + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->signature)); if (pReq->codeLen > 0) { pReq->pCode = taosMemoryCalloc(1, pReq->codeLen); if (pReq->pCode == NULL) { - return -1; + TAOS_CHECK_EXIT(terrno); } - if (tDecodeCStrTo(&decoder, pReq->pCode) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->pCode)); } int32_t commentSize = 0; - if (tDecodeI32(&decoder, &commentSize) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &commentSize)); if (commentSize > 0) { pReq->pComment = taosMemoryCalloc(1, commentSize); if (pReq->pComment == NULL) { - return -1; + TAOS_CHECK_EXIT(terrno); } - if (tDecodeCStrTo(&decoder, pReq->pComment) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->pComment)); } if (!tDecodeIsEnd(&decoder)) { - if (tDecodeI8(&decoder, &pReq->orReplace) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->orReplace)); } else { pReq->orReplace = false; } tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSCreateFuncReq(SCreateFuncReq *pReq) { @@ -3029,176 +3141,229 @@ void tFreeSCreateFuncReq(SCreateFuncReq *pReq) { int32_t tSerializeSDropFuncReq(void *buf, int32_t bufLen, SDropFuncReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->name) < 0) return -1; - if (tEncodeI8(&encoder, pReq->igNotExists) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->name)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->igNotExists)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSDropFuncReq(void *buf, int32_t bufLen, SDropFuncReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->igNotExists) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->name)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->igNotExists)); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } int32_t tSerializeSRetrieveFuncReq(void *buf, int32_t bufLen, SRetrieveFuncReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeI32(&encoder, pReq->numOfFuncs) < 0) return -1; - if (tEncodeI8(&encoder, pReq->ignoreCodeComment) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->numOfFuncs)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->ignoreCodeComment)); - if (pReq->numOfFuncs != (int32_t)taosArrayGetSize(pReq->pFuncNames)) return -1; + if (pReq->numOfFuncs != (int32_t)taosArrayGetSize(pReq->pFuncNames)) { + TAOS_CHECK_EXIT(TSDB_CODE_INVALID_PARA); + } for (int32_t i = 0; i < pReq->numOfFuncs; ++i) { char *fname = taosArrayGet(pReq->pFuncNames, i); - if (tEncodeCStr(&encoder, fname) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, fname)); } tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSRetrieveFuncReq(void *buf, int32_t bufLen, SRetrieveFuncReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->numOfFuncs) < 0) return -1; - if (tDecodeI8(&decoder, (int8_t *)&pReq->ignoreCodeComment) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->numOfFuncs)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, (int8_t *)&pReq->ignoreCodeComment)); pReq->pFuncNames = taosArrayInit(pReq->numOfFuncs, TSDB_FUNC_NAME_LEN); - if (pReq->pFuncNames == NULL) return -1; + if (pReq->pFuncNames == NULL) { + TAOS_CHECK_EXIT(terrno); + } for (int32_t i = 0; i < pReq->numOfFuncs; ++i) { char fname[TSDB_FUNC_NAME_LEN] = {0}; - if (tDecodeCStrTo(&decoder, fname) < 0) return -1; - if (taosArrayPush(pReq->pFuncNames, fname) == NULL) return -1; + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, fname)); + if (taosArrayPush(pReq->pFuncNames, fname) == NULL) { + TAOS_CHECK_EXIT(terrno); + } } tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSRetrieveFuncReq(SRetrieveFuncReq *pReq) { taosArrayDestroy(pReq->pFuncNames); } int32_t tSerializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp *pRsp) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeI32(&encoder, pRsp->numOfFuncs) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pRsp->numOfFuncs)); - if (pRsp->numOfFuncs != (int32_t)taosArrayGetSize(pRsp->pFuncInfos)) return -1; + if (pRsp->numOfFuncs != (int32_t)taosArrayGetSize(pRsp->pFuncInfos)) { + TAOS_CHECK_EXIT(TSDB_CODE_INVALID_PARA); + } for (int32_t i = 0; i < pRsp->numOfFuncs; ++i) { SFuncInfo *pInfo = taosArrayGet(pRsp->pFuncInfos, i); - if (tEncodeCStr(&encoder, pInfo->name) < 0) return -1; - if (tEncodeI8(&encoder, pInfo->funcType) < 0) return -1; - if (tEncodeI8(&encoder, pInfo->scriptType) < 0) return -1; - if (tEncodeI8(&encoder, pInfo->outputType) < 0) return -1; - 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->codeSize) < 0) return -1; - if (tEncodeI32(&encoder, pInfo->commentSize) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pInfo->name)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pInfo->funcType)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pInfo->scriptType)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pInfo->outputType)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pInfo->outputLen)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pInfo->bufSize)); + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pInfo->signature)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pInfo->codeSize)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pInfo->commentSize)); if (pInfo->codeSize) { - if (tEncodeBinary(&encoder, pInfo->pCode, pInfo->codeSize) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeBinary(&encoder, pInfo->pCode, pInfo->codeSize)); } if (pInfo->commentSize) { - if (tEncodeCStr(&encoder, pInfo->pComment) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pInfo->pComment)); } } - if (pRsp->numOfFuncs != (int32_t)taosArrayGetSize(pRsp->pFuncExtraInfos)) return -1; + if (pRsp->numOfFuncs != (int32_t)taosArrayGetSize(pRsp->pFuncExtraInfos)) { + TAOS_CHECK_EXIT(TSDB_CODE_INVALID_PARA); + } for (int32_t i = 0; i < pRsp->numOfFuncs; ++i) { SFuncExtraInfo *extraInfo = taosArrayGet(pRsp->pFuncExtraInfos, i); - if (tEncodeI32(&encoder, extraInfo->funcVersion) < 0) return -1; - if (tEncodeI64(&encoder, extraInfo->funcCreatedTime) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI32(&encoder, extraInfo->funcVersion)); + TAOS_CHECK_EXIT(tEncodeI64(&encoder, extraInfo->funcCreatedTime)); } tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp *pRsp) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeI32(&decoder, &pRsp->numOfFuncs) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pRsp->numOfFuncs)); pRsp->pFuncInfos = taosArrayInit(pRsp->numOfFuncs, sizeof(SFuncInfo)); - if (pRsp->pFuncInfos == NULL) return -1; + if (pRsp->pFuncInfos == NULL) { + TAOS_CHECK_EXIT(terrno); + } for (int32_t i = 0; i < pRsp->numOfFuncs; ++i) { SFuncInfo fInfo = {0}; - if (tDecodeCStrTo(&decoder, fInfo.name) < 0) return -1; - if (tDecodeI8(&decoder, &fInfo.funcType) < 0) return -1; - if (tDecodeI8(&decoder, &fInfo.scriptType) < 0) return -1; - if (tDecodeI8(&decoder, &fInfo.outputType) < 0) return -1; - 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.codeSize) < 0) return -1; - if (tDecodeI32(&decoder, &fInfo.commentSize) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, fInfo.name)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &fInfo.funcType)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &fInfo.scriptType)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &fInfo.outputType)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &fInfo.outputLen)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &fInfo.bufSize)); + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &fInfo.signature)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &fInfo.codeSize)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &fInfo.commentSize)); if (fInfo.codeSize) { fInfo.pCode = taosMemoryCalloc(1, fInfo.codeSize); if (fInfo.pCode == NULL) { - return -1; + TAOS_CHECK_EXIT(terrno); } - if (tDecodeCStrTo(&decoder, fInfo.pCode) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, fInfo.pCode)); } if (fInfo.commentSize) { fInfo.pComment = taosMemoryCalloc(1, fInfo.commentSize); if (fInfo.pComment == NULL) { - return -1; + TAOS_CHECK_EXIT(terrno); } - if (tDecodeCStrTo(&decoder, fInfo.pComment) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, fInfo.pComment)); } - if (taosArrayPush(pRsp->pFuncInfos, &fInfo) == NULL) return -1; + if (taosArrayPush(pRsp->pFuncInfos, &fInfo) == NULL) { + TAOS_CHECK_EXIT(terrno); + } } pRsp->pFuncExtraInfos = taosArrayInit(pRsp->numOfFuncs, sizeof(SFuncExtraInfo)); - if (pRsp->pFuncExtraInfos == NULL) return -1; + if (pRsp->pFuncExtraInfos == NULL) { + TAOS_CHECK_EXIT(terrno); + } if (tDecodeIsEnd(&decoder)) { for (int32_t i = 0; i < pRsp->numOfFuncs; ++i) { SFuncExtraInfo extraInfo = {0}; - if (taosArrayPush(pRsp->pFuncExtraInfos, &extraInfo) == NULL) return -1; + if (taosArrayPush(pRsp->pFuncExtraInfos, &extraInfo) == NULL) { + TAOS_CHECK_EXIT(terrno); + } } } else { for (int32_t i = 0; i < pRsp->numOfFuncs; ++i) { SFuncExtraInfo extraInfo = {0}; - if (tDecodeI32(&decoder, &extraInfo.funcVersion) < 0) return -1; - if (tDecodeI64(&decoder, &extraInfo.funcCreatedTime) < 0) return -1; - if (taosArrayPush(pRsp->pFuncExtraInfos, &extraInfo) == NULL) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &extraInfo.funcVersion)); + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &extraInfo.funcCreatedTime)); + if (taosArrayPush(pRsp->pFuncExtraInfos, &extraInfo) == NULL) { + TAOS_CHECK_EXIT(terrno); + } } } tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSFuncInfo(SFuncInfo *pInfo) { @@ -3268,113 +3433,129 @@ int32_t tDeserializeSTableCfgReq(void *buf, int32_t bufLen, STableCfgReq *pReq) int32_t tSerializeSTableCfgRsp(void *buf, int32_t bufLen, STableCfgRsp *pRsp) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pRsp->tbName) < 0) return -1; - if (tEncodeCStr(&encoder, pRsp->stbName) < 0) return -1; - if (tEncodeCStr(&encoder, pRsp->dbFName) < 0) return -1; - if (tEncodeI32(&encoder, pRsp->numOfTags) < 0) return -1; - if (tEncodeI32(&encoder, pRsp->numOfColumns) < 0) return -1; - if (tEncodeI8(&encoder, pRsp->tableType) < 0) return -1; - if (tEncodeI64(&encoder, pRsp->delay1) < 0) return -1; - if (tEncodeI64(&encoder, pRsp->delay2) < 0) return -1; - if (tEncodeI64(&encoder, pRsp->watermark1) < 0) return -1; - if (tEncodeI64(&encoder, pRsp->watermark2) < 0) return -1; - if (tEncodeI32(&encoder, pRsp->ttl) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pRsp->tbName)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pRsp->stbName)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pRsp->dbFName)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pRsp->numOfTags)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pRsp->numOfColumns)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pRsp->tableType)); + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRsp->delay1)); + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRsp->delay2)); + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRsp->watermark1)); + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRsp->watermark2)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pRsp->ttl)); int32_t numOfFuncs = taosArrayGetSize(pRsp->pFuncs); - if (tEncodeI32(&encoder, numOfFuncs) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI32(&encoder, numOfFuncs)); for (int32_t i = 0; i < numOfFuncs; ++i) { const char *pFunc = taosArrayGet(pRsp->pFuncs, i); - if (tEncodeCStr(&encoder, pFunc) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pFunc)); } - if (tEncodeI32(&encoder, pRsp->commentLen) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pRsp->commentLen)); if (pRsp->commentLen > 0) { - if (tEncodeCStr(&encoder, pRsp->pComment) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pRsp->pComment)); } for (int32_t i = 0; i < pRsp->numOfColumns + pRsp->numOfTags; ++i) { SSchema *pSchema = &pRsp->pSchemas[i]; - if (tEncodeSSchema(&encoder, pSchema) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeSSchema(&encoder, pSchema)); } - if (tEncodeI32(&encoder, pRsp->tagsLen) < 0) return -1; - if (tEncodeBinary(&encoder, pRsp->pTags, pRsp->tagsLen) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pRsp->tagsLen)); + TAOS_CHECK_EXIT(tEncodeBinary(&encoder, pRsp->pTags, pRsp->tagsLen)); if (useCompress(pRsp->tableType)) { for (int32_t i = 0; i < pRsp->numOfColumns; ++i) { SSchemaExt *pSchemaExt = &pRsp->pSchemaExt[i]; - if (tEncodeSSchemaExt(&encoder, pSchemaExt) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeSSchemaExt(&encoder, pSchemaExt)); } } tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSTableCfgRsp(void *buf, int32_t bufLen, STableCfgRsp *pRsp) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pRsp->tbName) < 0) return -1; - if (tDecodeCStrTo(&decoder, pRsp->stbName) < 0) return -1; - if (tDecodeCStrTo(&decoder, pRsp->dbFName) < 0) return -1; - if (tDecodeI32(&decoder, &pRsp->numOfTags) < 0) return -1; - if (tDecodeI32(&decoder, &pRsp->numOfColumns) < 0) return -1; - if (tDecodeI8(&decoder, &pRsp->tableType) < 0) return -1; - if (tDecodeI64(&decoder, &pRsp->delay1) < 0) return -1; - if (tDecodeI64(&decoder, &pRsp->delay2) < 0) return -1; - if (tDecodeI64(&decoder, &pRsp->watermark1) < 0) return -1; - if (tDecodeI64(&decoder, &pRsp->watermark2) < 0) return -1; - if (tDecodeI32(&decoder, &pRsp->ttl) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pRsp->tbName)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pRsp->stbName)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pRsp->dbFName)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pRsp->numOfTags)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pRsp->numOfColumns)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pRsp->tableType)); + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->delay1)); + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->delay2)); + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->watermark1)); + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->watermark2)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pRsp->ttl)); int32_t numOfFuncs = 0; - if (tDecodeI32(&decoder, &numOfFuncs) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &numOfFuncs)); if (numOfFuncs > 0) { pRsp->pFuncs = taosArrayInit(numOfFuncs, TSDB_FUNC_NAME_LEN); - if (NULL == pRsp->pFuncs) return -1; + if (NULL == pRsp->pFuncs) { + TAOS_CHECK_EXIT(terrno); + } } for (int32_t i = 0; i < numOfFuncs; ++i) { char pFunc[TSDB_FUNC_NAME_LEN]; - if (tDecodeCStrTo(&decoder, pFunc) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pFunc)); if (taosArrayPush(pRsp->pFuncs, pFunc) == NULL) { - return -1; + TAOS_CHECK_EXIT(terrno); } } - if (tDecodeI32(&decoder, &pRsp->commentLen) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pRsp->commentLen)); if (pRsp->commentLen > 0) { - if (tDecodeCStrAlloc(&decoder, &pRsp->pComment) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeCStrAlloc(&decoder, &pRsp->pComment)); } else { pRsp->pComment = NULL; } int32_t totalCols = pRsp->numOfTags + pRsp->numOfColumns; pRsp->pSchemas = taosMemoryMalloc(sizeof(SSchema) * totalCols); - if (pRsp->pSchemas == NULL) return -1; + if (pRsp->pSchemas == NULL) { + TAOS_CHECK_EXIT(terrno); + } for (int32_t i = 0; i < totalCols; ++i) { SSchema *pSchema = &pRsp->pSchemas[i]; - if (tDecodeSSchema(&decoder, pSchema) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeSSchema(&decoder, pSchema)); } - if (tDecodeI32(&decoder, &pRsp->tagsLen) < 0) return -1; - if (tDecodeBinaryAlloc(&decoder, (void **)&pRsp->pTags, NULL) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pRsp->tagsLen)); + TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void **)&pRsp->pTags, NULL)); if (!tDecodeIsEnd(&decoder)) { if (useCompress(pRsp->tableType) && pRsp->numOfColumns > 0) { pRsp->pSchemaExt = taosMemoryMalloc(sizeof(SSchemaExt) * pRsp->numOfColumns); - if (pRsp->pSchemaExt == NULL) return -1; + if (pRsp->pSchemaExt == NULL) { + TAOS_CHECK_EXIT(terrno); + } for (int32_t i = 0; i < pRsp->numOfColumns; ++i) { SSchemaExt *pSchemaExt = &pRsp->pSchemaExt[i]; - if (tDecodeSSchemaExt(&decoder, pSchemaExt) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeSSchemaExt(&decoder, pSchemaExt)); } } else { pRsp->pSchemaExt = NULL; @@ -3382,8 +3563,9 @@ int32_t tDeserializeSTableCfgRsp(void *buf, int32_t bufLen, STableCfgRsp *pRsp) } tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSTableCfgRsp(STableCfgRsp *pRsp) { @@ -3401,120 +3583,131 @@ void tFreeSTableCfgRsp(STableCfgRsp *pRsp) { int32_t tSerializeSCreateDbReq(void *buf, int32_t bufLen, SCreateDbReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; + tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->db) < 0) return -1; - if (tEncodeI32(&encoder, pReq->numOfVgroups) < 0) return -1; - if (tEncodeI32(&encoder, pReq->numOfStables) < 0) return -1; - if (tEncodeI32(&encoder, pReq->buffer) < 0) return -1; - if (tEncodeI32(&encoder, pReq->pageSize) < 0) return -1; - if (tEncodeI32(&encoder, pReq->pages) < 0) return -1; - if (tEncodeI32(&encoder, pReq->cacheLastSize) < 0) return -1; - if (tEncodeI32(&encoder, pReq->daysPerFile) < 0) return -1; - if (tEncodeI32(&encoder, pReq->daysToKeep0) < 0) return -1; - if (tEncodeI32(&encoder, pReq->daysToKeep1) < 0) return -1; - if (tEncodeI32(&encoder, pReq->daysToKeep2) < 0) return -1; - if (tEncodeI32(&encoder, pReq->minRows) < 0) return -1; - if (tEncodeI32(&encoder, pReq->maxRows) < 0) return -1; - if (tEncodeI32(&encoder, pReq->walFsyncPeriod) < 0) return -1; - if (tEncodeI8(&encoder, pReq->walLevel) < 0) return -1; - if (tEncodeI8(&encoder, pReq->precision) < 0) return -1; - if (tEncodeI8(&encoder, pReq->compression) < 0) return -1; - if (tEncodeI8(&encoder, pReq->replications) < 0) return -1; - if (tEncodeI8(&encoder, pReq->strict) < 0) return -1; - if (tEncodeI8(&encoder, pReq->cacheLast) < 0) return -1; - if (tEncodeI8(&encoder, pReq->schemaless) < 0) return -1; - if (tEncodeI32(&encoder, pReq->walRetentionPeriod) < 0) return -1; - if (tEncodeI64(&encoder, pReq->walRetentionSize) < 0) return -1; - if (tEncodeI32(&encoder, pReq->walRollPeriod) < 0) return -1; - if (tEncodeI64(&encoder, pReq->walSegmentSize) < 0) return -1; - if (tEncodeI32(&encoder, pReq->sstTrigger) < 0) return -1; - if (tEncodeI16(&encoder, pReq->hashPrefix) < 0) return -1; - if (tEncodeI16(&encoder, pReq->hashSuffix) < 0) return -1; - if (tEncodeI8(&encoder, pReq->ignoreExist) < 0) return -1; - if (tEncodeI32(&encoder, pReq->numOfRetensions) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->db)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->numOfVgroups)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->numOfStables)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->buffer)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->pageSize)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->pages)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->cacheLastSize)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->daysPerFile)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->daysToKeep0)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->daysToKeep1)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->daysToKeep2)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->minRows)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->maxRows)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->walFsyncPeriod)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->walLevel)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->precision)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->compression)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->replications)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->strict)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->cacheLast)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->schemaless)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->walRetentionPeriod)); + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->walRetentionSize)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->walRollPeriod)); + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->walSegmentSize)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->sstTrigger)); + TAOS_CHECK_EXIT(tEncodeI16(&encoder, pReq->hashPrefix)); + TAOS_CHECK_EXIT(tEncodeI16(&encoder, pReq->hashSuffix)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->ignoreExist)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->numOfRetensions)); for (int32_t i = 0; i < pReq->numOfRetensions; ++i) { SRetention *pRetension = taosArrayGet(pReq->pRetensions, i); - if (tEncodeI64(&encoder, pRetension->freq) < 0) return -1; - if (tEncodeI64(&encoder, pRetension->keep) < 0) return -1; - if (tEncodeI8(&encoder, pRetension->freqUnit) < 0) return -1; - if (tEncodeI8(&encoder, pRetension->keepUnit) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRetension->freq)); + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRetension->keep)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pRetension->freqUnit)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pRetension->keepUnit)); } - if (tEncodeI32(&encoder, pReq->tsdbPageSize) < 0) return -1; - if (tEncodeI32(&encoder, pReq->keepTimeOffset) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->tsdbPageSize)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->keepTimeOffset)); ENCODESQL(); - if (tEncodeI8(&encoder, pReq->withArbitrator) < 0) return -1; - if (tEncodeI8(&encoder, pReq->encryptAlgorithm) < 0) return -1; - if (tEncodeI32(&encoder, pReq->s3ChunkSize) < 0) return -1; - if (tEncodeI32(&encoder, pReq->s3KeepLocal) < 0) return -1; - if (tEncodeI8(&encoder, pReq->s3Compact) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->withArbitrator)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->encryptAlgorithm)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->s3ChunkSize)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->s3KeepLocal)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->s3Compact)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSCreateDbReq(void *buf, int32_t bufLen, SCreateDbReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->numOfVgroups) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->numOfStables) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->buffer) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->pageSize) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->pages) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->cacheLastSize) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->daysPerFile) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->daysToKeep0) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->daysToKeep1) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->daysToKeep2) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->minRows) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->maxRows) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->walFsyncPeriod) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->walLevel) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->precision) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->compression) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->replications) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->strict) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->cacheLast) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->schemaless) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->walRetentionPeriod) < 0) return -1; - if (tDecodeI64(&decoder, &pReq->walRetentionSize) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->walRollPeriod) < 0) return -1; - if (tDecodeI64(&decoder, &pReq->walSegmentSize) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->sstTrigger) < 0) return -1; - if (tDecodeI16(&decoder, &pReq->hashPrefix) < 0) return -1; - if (tDecodeI16(&decoder, &pReq->hashSuffix) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->ignoreExist) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->numOfRetensions) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->db)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->numOfVgroups)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->numOfStables)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->buffer)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->pageSize)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->pages)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->cacheLastSize)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->daysPerFile)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->daysToKeep0)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->daysToKeep1)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->daysToKeep2)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->minRows)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->maxRows)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->walFsyncPeriod)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->walLevel)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->precision)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->compression)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->replications)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->strict)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->cacheLast)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->schemaless)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->walRetentionPeriod)); + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->walRetentionSize)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->walRollPeriod)); + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->walSegmentSize)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->sstTrigger)); + TAOS_CHECK_EXIT(tDecodeI16(&decoder, &pReq->hashPrefix)); + TAOS_CHECK_EXIT(tDecodeI16(&decoder, &pReq->hashSuffix)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->ignoreExist)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->numOfRetensions)); pReq->pRetensions = taosArrayInit(pReq->numOfRetensions, sizeof(SRetention)); if (pReq->pRetensions == NULL) { - return -1; + TAOS_CHECK_EXIT(terrno); } for (int32_t i = 0; i < pReq->numOfRetensions; ++i) { SRetention rentension = {0}; - if (tDecodeI64(&decoder, &rentension.freq) < 0) return -1; - if (tDecodeI64(&decoder, &rentension.keep) < 0) return -1; - if (tDecodeI8(&decoder, &rentension.freqUnit) < 0) return -1; - if (tDecodeI8(&decoder, &rentension.keepUnit) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &rentension.freq)); + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &rentension.keep)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &rentension.freqUnit)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &rentension.keepUnit)); if (taosArrayPush(pReq->pRetensions, &rentension) == NULL) { - return -1; + TAOS_CHECK_EXIT(terrno); } } - if (tDecodeI32(&decoder, &pReq->tsdbPageSize) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->tsdbPageSize)); pReq->keepTimeOffset = TSDB_DEFAULT_KEEP_TIME_OFFSET; if (!tDecodeIsEnd(&decoder)) { - if (tDecodeI32(&decoder, &pReq->keepTimeOffset) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->keepTimeOffset)); } DECODESQL(); @@ -3525,16 +3718,18 @@ int32_t tDeserializeSCreateDbReq(void *buf, int32_t bufLen, SCreateDbReq *pReq) pReq->s3KeepLocal = TSDB_DEFAULT_S3_KEEP_LOCAL; pReq->s3Compact = TSDB_DEFAULT_S3_COMPACT; if (!tDecodeIsEnd(&decoder)) { - if (tDecodeI8(&decoder, &pReq->withArbitrator) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->encryptAlgorithm) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->s3ChunkSize) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->s3KeepLocal) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->s3Compact) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->withArbitrator)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->encryptAlgorithm)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->s3ChunkSize)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->s3KeepLocal)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->s3Compact)); } tEndDecode(&decoder); + +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSCreateDbReq(SCreateDbReq *pReq) { @@ -3545,616 +3740,776 @@ void tFreeSCreateDbReq(SCreateDbReq *pReq) { int32_t tSerializeSAlterDbReq(void *buf, int32_t bufLen, SAlterDbReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; + tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->db) < 0) return -1; - if (tEncodeI32(&encoder, pReq->buffer) < 0) return -1; - if (tEncodeI32(&encoder, pReq->pageSize) < 0) return -1; - if (tEncodeI32(&encoder, pReq->pages) < 0) return -1; - if (tEncodeI32(&encoder, pReq->cacheLastSize) < 0) return -1; - if (tEncodeI32(&encoder, pReq->daysPerFile) < 0) return -1; - if (tEncodeI32(&encoder, pReq->daysToKeep0) < 0) return -1; - if (tEncodeI32(&encoder, pReq->daysToKeep1) < 0) return -1; - if (tEncodeI32(&encoder, pReq->daysToKeep2) < 0) return -1; - if (tEncodeI32(&encoder, pReq->walFsyncPeriod) < 0) return -1; - if (tEncodeI8(&encoder, pReq->walLevel) < 0) return -1; - if (tEncodeI8(&encoder, pReq->strict) < 0) return -1; - if (tEncodeI8(&encoder, pReq->cacheLast) < 0) return -1; - if (tEncodeI8(&encoder, pReq->replications) < 0) return -1; - if (tEncodeI32(&encoder, pReq->sstTrigger) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->db)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->buffer)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->pageSize)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->pages)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->cacheLastSize)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->daysPerFile)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->daysToKeep0)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->daysToKeep1)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->daysToKeep2)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->walFsyncPeriod)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->walLevel)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->strict)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->cacheLast)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->replications)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->sstTrigger)); // 1st modification - if (tEncodeI32(&encoder, pReq->minRows) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->minRows)); // 2nd modification - if (tEncodeI32(&encoder, pReq->walRetentionPeriod) < 0) return -1; - if (tEncodeI32(&encoder, pReq->walRetentionSize) < 0) return -1; - if (tEncodeI32(&encoder, pReq->keepTimeOffset) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->walRetentionPeriod)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->walRetentionSize)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->keepTimeOffset)); - if (tEncodeI32(&encoder, pReq->s3KeepLocal) < 0) return -1; - if (tEncodeI8(&encoder, pReq->s3Compact) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->s3KeepLocal)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->s3Compact)); ENCODESQL(); - if (tEncodeI8(&encoder, pReq->withArbitrator) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->withArbitrator)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSAlterDbReq(void *buf, int32_t bufLen, SAlterDbReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->buffer) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->pageSize) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->pages) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->cacheLastSize) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->daysPerFile) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->daysToKeep0) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->daysToKeep1) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->daysToKeep2) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->walFsyncPeriod) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->walLevel) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->strict) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->cacheLast) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->replications) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->sstTrigger) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->db)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->buffer)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->pageSize)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->pages)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->cacheLastSize)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->daysPerFile)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->daysToKeep0)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->daysToKeep1)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->daysToKeep2)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->walFsyncPeriod)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->walLevel)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->strict)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->cacheLast)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->replications)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->sstTrigger)); // 1st modification if (!tDecodeIsEnd(&decoder)) { - if (tDecodeI32(&decoder, &pReq->minRows) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->minRows)); } else { pReq->minRows = -1; } // 2nd modification if (!tDecodeIsEnd(&decoder)) { - if (tDecodeI32(&decoder, &pReq->walRetentionPeriod) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->walRetentionSize) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->walRetentionPeriod)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->walRetentionSize)); } else { pReq->walRetentionPeriod = -1; pReq->walRetentionSize = -1; } pReq->keepTimeOffset = TSDB_DEFAULT_KEEP_TIME_OFFSET; if (!tDecodeIsEnd(&decoder)) { - if (tDecodeI32(&decoder, &pReq->keepTimeOffset) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->keepTimeOffset)); } pReq->s3KeepLocal = TSDB_DEFAULT_S3_KEEP_LOCAL; pReq->s3Compact = TSDB_DEFAULT_S3_COMPACT; if (!tDecodeIsEnd(&decoder)) { - if (tDecodeI32(&decoder, &pReq->s3KeepLocal) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->s3Compact) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->s3KeepLocal)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->s3Compact)); } DECODESQL(); pReq->withArbitrator = TSDB_DEFAULT_DB_WITH_ARBITRATOR; if (!tDecodeIsEnd(&decoder)) { - if (tDecodeI8(&decoder, &pReq->withArbitrator) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->withArbitrator)); } tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSAlterDbReq(SAlterDbReq *pReq) { FREESQL(); } int32_t tSerializeSDropDbReq(void *buf, int32_t bufLen, SDropDbReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->db) < 0) return -1; - if (tEncodeI8(&encoder, pReq->ignoreNotExists) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->db)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->ignoreNotExists)); ENCODESQL(); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSDropDbReq(void *buf, int32_t bufLen, SDropDbReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->ignoreNotExists) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->db)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->ignoreNotExists)); DECODESQL(); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSDropDbReq(SDropDbReq *pReq) { FREESQL(); } int32_t tSerializeSDropDbRsp(void *buf, int32_t bufLen, SDropDbRsp *pRsp) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pRsp->db) < 0) return -1; - if (tEncodeI64(&encoder, pRsp->uid) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pRsp->db)); + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRsp->uid)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSDropDbRsp(void *buf, int32_t bufLen, SDropDbRsp *pRsp) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pRsp->db) < 0) return -1; - if (tDecodeI64(&decoder, &pRsp->uid) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pRsp->db)); + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->uid)); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } int32_t tSerializeSUseDbReq(void *buf, int32_t bufLen, SUseDbReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->db) < 0) return -1; - if (tEncodeI64(&encoder, pReq->dbId) < 0) return -1; - if (tEncodeI32(&encoder, pReq->vgVersion) < 0) return -1; - if (tEncodeI32(&encoder, pReq->numOfTable) < 0) return -1; - if (tEncodeI64(&encoder, pReq->stateTs) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->db)); + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->dbId)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->vgVersion)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->numOfTable)); + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->stateTs)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSUseDbReq(void *buf, int32_t bufLen, SUseDbReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1; - if (tDecodeI64(&decoder, &pReq->dbId) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->vgVersion) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->numOfTable) < 0) return -1; - if (tDecodeI64(&decoder, &pReq->stateTs) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->db)); + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->dbId)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->vgVersion)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->numOfTable)); + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->stateTs)); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } int32_t tSerializeSQnodeListReq(void *buf, int32_t bufLen, SQnodeListReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; + tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeI32(&encoder, pReq->rowNum) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->rowNum)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSQnodeListReq(void *buf, int32_t bufLen, SQnodeListReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->rowNum) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->rowNum)); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } int32_t tSerializeSDnodeListReq(void *buf, int32_t bufLen, SDnodeListReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeI32(&encoder, pReq->rowNum) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->rowNum)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tSerializeSServerVerReq(void *buf, int32_t bufLen, SServerVerReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeI32(&encoder, pReq->useless) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->useless)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } -// int32_t tDeserializeSServerVerReq(void *buf, int32_t bufLen, SServerVerReq *pReq) { -// SDecoder decoder = {0}; -// tDecoderInit(&decoder, buf, bufLen); - -// if (tStartDecode(&decoder) < 0) return -1; -// if (tDecodeI32(&decoder, &pReq->useless) < 0) return -1; - -// tEndDecode(&decoder); -// tDecoderClear(&decoder); -// return 0; -// } - int32_t tSerializeSServerVerRsp(void *buf, int32_t bufLen, SServerVerRsp *pRsp) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pRsp->ver) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pRsp->ver)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSServerVerRsp(void *buf, int32_t bufLen, SServerVerRsp *pRsp) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pRsp->ver) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pRsp->ver)); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } int32_t tSerializeSQnodeListRsp(void *buf, int32_t bufLen, SQnodeListRsp *pRsp) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); int32_t num = taosArrayGetSize(pRsp->qnodeList); - if (tEncodeI32(&encoder, num) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI32(&encoder, num)); for (int32_t i = 0; i < num; ++i) { SQueryNodeLoad *pLoad = taosArrayGet(pRsp->qnodeList, i); - if (tEncodeSQueryNodeLoad(&encoder, pLoad) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeSQueryNodeLoad(&encoder, pLoad)); } tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSQnodeListRsp(void *buf, int32_t bufLen, SQnodeListRsp *pRsp) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); int32_t num = 0; - if (tDecodeI32(&decoder, &num) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &num)); if (NULL == pRsp->qnodeList) { pRsp->qnodeList = taosArrayInit(num, sizeof(SQueryNodeLoad)); - if (NULL == pRsp->qnodeList) return -1; + if (NULL == pRsp->qnodeList) { + TAOS_CHECK_EXIT(terrno); + } } for (int32_t i = 0; i < num; ++i) { SQueryNodeLoad load = {0}; - if (tDecodeSQueryNodeLoad(&decoder, &load) < 0) return -1; - if (taosArrayPush(pRsp->qnodeList, &load) == NULL) return -1; + TAOS_CHECK_EXIT(tDecodeSQueryNodeLoad(&decoder, &load)); + if (taosArrayPush(pRsp->qnodeList, &load) == NULL) { + TAOS_CHECK_EXIT(terrno); + } } tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSQnodeListRsp(SQnodeListRsp *pRsp) { taosArrayDestroy(pRsp->qnodeList); } int32_t tSerializeSDnodeListRsp(void *buf, int32_t bufLen, SDnodeListRsp *pRsp) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); int32_t num = taosArrayGetSize(pRsp->dnodeList); - if (tEncodeI32(&encoder, num) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI32(&encoder, num)); for (int32_t i = 0; i < num; ++i) { SEpSet *pEpSet = taosArrayGet(pRsp->dnodeList, i); - if (tEncodeSEpSet(&encoder, pEpSet) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeSEpSet(&encoder, pEpSet)); } tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSDnodeListRsp(void *buf, int32_t bufLen, SDnodeListRsp *pRsp) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); int32_t num = 0; - if (tDecodeI32(&decoder, &num) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &num)); if (NULL == pRsp->dnodeList) { pRsp->dnodeList = taosArrayInit(num, sizeof(SEpSet)); - if (NULL == pRsp->dnodeList) return -1; + if (NULL == pRsp->dnodeList) { + TAOS_CHECK_EXIT(terrno); + } } for (int32_t i = 0; i < num; ++i) { SEpSet epSet = {0}; - if (tDecodeSEpSet(&decoder, &epSet) < 0) return -1; - if (taosArrayPush(pRsp->dnodeList, &epSet) == NULL) return -1; + TAOS_CHECK_EXIT(tDecodeSEpSet(&decoder, &epSet)); + if (taosArrayPush(pRsp->dnodeList, &epSet) == NULL) { + TAOS_CHECK_EXIT(terrno); + } } tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSDnodeListRsp(SDnodeListRsp *pRsp) { taosArrayDestroy(pRsp->dnodeList); } int32_t tSerializeSCompactDbReq(void *buf, int32_t bufLen, SCompactDbReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->db) < 0) return -1; - if (tEncodeI64(&encoder, pReq->timeRange.skey) < 0) return -1; - if (tEncodeI64(&encoder, pReq->timeRange.ekey) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->db)); + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->timeRange.skey)); + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->timeRange.ekey)); ENCODESQL(); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSCompactDbReq(void *buf, int32_t bufLen, SCompactDbReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1; - if (tDecodeI64(&decoder, &pReq->timeRange.skey) < 0) return -1; - if (tDecodeI64(&decoder, &pReq->timeRange.ekey) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->db)); + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->timeRange.skey)); + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->timeRange.ekey)); DECODESQL(); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSCompactDbReq(SCompactDbReq *pReq) { FREESQL(); } int32_t tSerializeSCompactDbRsp(void *buf, int32_t bufLen, SCompactDbRsp *pRsp) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeI32(&encoder, pRsp->compactId) < 0) return -1; - if (tEncodeI8(&encoder, pRsp->bAccepted) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pRsp->compactId)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pRsp->bAccepted)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSCompactDbRsp(void *buf, int32_t bufLen, SCompactDbRsp *pRsp) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeI32(&decoder, &pRsp->compactId) < 0) return -1; - if (tDecodeI8(&decoder, &pRsp->bAccepted) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pRsp->compactId)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pRsp->bAccepted)); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } int32_t tSerializeSKillCompactReq(void *buf, int32_t bufLen, SKillCompactReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - - if (tEncodeI32(&encoder, pReq->compactId) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->compactId)); ENCODESQL(); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSKillCompactReq(void *buf, int32_t bufLen, SKillCompactReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - - if (tDecodeI32(&decoder, &pReq->compactId) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->compactId)); DECODESQL(); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSKillCompactReq(SKillCompactReq *pReq) { FREESQL(); } int32_t tSerializeSUseDbRspImp(SEncoder *pEncoder, const SUseDbRsp *pRsp) { - if (tEncodeCStr(pEncoder, pRsp->db) < 0) return -1; - if (tEncodeI64(pEncoder, pRsp->uid) < 0) return -1; - if (tEncodeI32(pEncoder, pRsp->vgVersion) < 0) return -1; - if (tEncodeI32(pEncoder, pRsp->vgNum) < 0) return -1; - if (tEncodeI16(pEncoder, pRsp->hashPrefix) < 0) return -1; - if (tEncodeI16(pEncoder, pRsp->hashSuffix) < 0) return -1; - if (tEncodeI8(pEncoder, pRsp->hashMethod) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pRsp->db)); + TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pRsp->uid)); + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pRsp->vgVersion)); + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pRsp->vgNum)); + TAOS_CHECK_RETURN(tEncodeI16(pEncoder, pRsp->hashPrefix)); + TAOS_CHECK_RETURN(tEncodeI16(pEncoder, pRsp->hashSuffix)); + TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pRsp->hashMethod)); for (int32_t i = 0; i < pRsp->vgNum; ++i) { SVgroupInfo *pVgInfo = taosArrayGet(pRsp->pVgroupInfos, i); - if (tEncodeI32(pEncoder, pVgInfo->vgId) < 0) return -1; - if (tEncodeU32(pEncoder, pVgInfo->hashBegin) < 0) return -1; - if (tEncodeU32(pEncoder, pVgInfo->hashEnd) < 0) return -1; - if (tEncodeSEpSet(pEncoder, &pVgInfo->epSet) < 0) return -1; - if (tEncodeI32(pEncoder, pVgInfo->numOfTable) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pVgInfo->vgId)); + TAOS_CHECK_RETURN(tEncodeU32(pEncoder, pVgInfo->hashBegin)); + TAOS_CHECK_RETURN(tEncodeU32(pEncoder, pVgInfo->hashEnd)); + TAOS_CHECK_RETURN(tEncodeSEpSet(pEncoder, &pVgInfo->epSet)); + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pVgInfo->numOfTable)); } - if (tEncodeI32(pEncoder, pRsp->errCode) < 0) return -1; - if (tEncodeI64(pEncoder, pRsp->stateTs) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pRsp->errCode)); + TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pRsp->stateTs)); return 0; } int32_t tSerializeSUseDbRsp(void *buf, int32_t bufLen, const SUseDbRsp *pRsp) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tSerializeSUseDbRspImp(&encoder, pRsp) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tSerializeSUseDbRspImp(&encoder, pRsp)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tSerializeSDbHbRspImp(SEncoder *pEncoder, const SDbHbRsp *pRsp) { if (pRsp->useDbRsp) { - if (tEncodeI8(pEncoder, 1) < 0) return -1; - if (tSerializeSUseDbRspImp(pEncoder, pRsp->useDbRsp) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI8(pEncoder, 1)); + TAOS_CHECK_RETURN(tSerializeSUseDbRspImp(pEncoder, pRsp->useDbRsp)); } else { - if (tEncodeI8(pEncoder, 0) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI8(pEncoder, 0)); } if (pRsp->cfgRsp) { - if (tEncodeI8(pEncoder, 1) < 0) return -1; - if (tSerializeSDbCfgRspImpl(pEncoder, pRsp->cfgRsp) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI8(pEncoder, 1)); + TAOS_CHECK_RETURN(tSerializeSDbCfgRspImpl(pEncoder, pRsp->cfgRsp)); } else { - if (tEncodeI8(pEncoder, 0) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI8(pEncoder, 0)); } if (pRsp->pTsmaRsp) { - if (tEncodeI8(pEncoder, 1) < 0) return -1; - if (tEncodeTableTSMAInfoRsp(pEncoder, pRsp->pTsmaRsp) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI8(pEncoder, 1)); + TAOS_CHECK_RETURN(tEncodeTableTSMAInfoRsp(pEncoder, pRsp->pTsmaRsp)); } else { - if (tEncodeI8(pEncoder, 0) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI8(pEncoder, 0)); } - if (tEncodeI32(pEncoder, pRsp->dbTsmaVersion) < 0) return -1; - if (tEncodeCStr(pEncoder, pRsp->db) < 0) return -1; - if (tEncodeI64(pEncoder, pRsp->dbId) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pRsp->dbTsmaVersion)); + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pRsp->db)); + TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pRsp->dbId)); return 0; } int32_t tSerializeSDbHbBatchRsp(void *buf, int32_t bufLen, SDbHbBatchRsp *pRsp) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); int32_t numOfBatch = taosArrayGetSize(pRsp->pArray); - if (tEncodeI32(&encoder, numOfBatch) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI32(&encoder, numOfBatch)); for (int32_t i = 0; i < numOfBatch; ++i) { SDbHbRsp *pDbRsp = taosArrayGet(pRsp->pArray, i); - if (tSerializeSDbHbRspImp(&encoder, pDbRsp) < 0) return -1; + TAOS_CHECK_EXIT(tSerializeSDbHbRspImp(&encoder, pDbRsp)); } tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSUseDbRspImp(SDecoder *pDecoder, SUseDbRsp *pRsp) { - if (tDecodeCStrTo(pDecoder, pRsp->db) < 0) return -1; - if (tDecodeI64(pDecoder, &pRsp->uid) < 0) return -1; - if (tDecodeI32(pDecoder, &pRsp->vgVersion) < 0) return -1; - if (tDecodeI32(pDecoder, &pRsp->vgNum) < 0) return -1; - if (tDecodeI16(pDecoder, &pRsp->hashPrefix) < 0) return -1; - if (tDecodeI16(pDecoder, &pRsp->hashSuffix) < 0) return -1; - if (tDecodeI8(pDecoder, &pRsp->hashMethod) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, pRsp->db)); + TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pRsp->uid)); + TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &pRsp->vgVersion)); + TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &pRsp->vgNum)); + TAOS_CHECK_RETURN(tDecodeI16(pDecoder, &pRsp->hashPrefix)); + TAOS_CHECK_RETURN(tDecodeI16(pDecoder, &pRsp->hashSuffix)); + TAOS_CHECK_RETURN(tDecodeI8(pDecoder, &pRsp->hashMethod)); if (pRsp->vgNum > 0) { pRsp->pVgroupInfos = taosArrayInit(pRsp->vgNum, sizeof(SVgroupInfo)); if (pRsp->pVgroupInfos == NULL) { - return -1; + TAOS_CHECK_RETURN(terrno); } for (int32_t i = 0; i < pRsp->vgNum; ++i) { SVgroupInfo vgInfo = {0}; - if (tDecodeI32(pDecoder, &vgInfo.vgId) < 0) return -1; - if (tDecodeU32(pDecoder, &vgInfo.hashBegin) < 0) return -1; - if (tDecodeU32(pDecoder, &vgInfo.hashEnd) < 0) return -1; - if (tDecodeSEpSet(pDecoder, &vgInfo.epSet) < 0) return -1; - if (tDecodeI32(pDecoder, &vgInfo.numOfTable) < 0) return -1; - if (taosArrayPush(pRsp->pVgroupInfos, &vgInfo) == NULL) return -1; + TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &vgInfo.vgId)); + TAOS_CHECK_RETURN(tDecodeU32(pDecoder, &vgInfo.hashBegin)); + TAOS_CHECK_RETURN(tDecodeU32(pDecoder, &vgInfo.hashEnd)); + TAOS_CHECK_RETURN(tDecodeSEpSet(pDecoder, &vgInfo.epSet)); + TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &vgInfo.numOfTable)); + if (taosArrayPush(pRsp->pVgroupInfos, &vgInfo) == NULL) { + TAOS_CHECK_RETURN(terrno); + } } } - if (tDecodeI32(pDecoder, &pRsp->errCode) < 0) return -1; - if (tDecodeI64(pDecoder, &pRsp->stateTs) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &pRsp->errCode)); + TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pRsp->stateTs)); return 0; } int32_t tDeserializeSUseDbRsp(void *buf, int32_t bufLen, SUseDbRsp *pRsp) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDeserializeSUseDbRspImp(&decoder, pRsp) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDeserializeSUseDbRspImp(&decoder, pRsp)); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } int32_t tDeserializeSDbHbRspImp(SDecoder *decoder, SDbHbRsp *pRsp) { int8_t flag = 0; - if (tDecodeI8(decoder, &flag) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI8(decoder, &flag)); if (flag) { pRsp->useDbRsp = taosMemoryCalloc(1, sizeof(SUseDbRsp)); - if (NULL == pRsp->useDbRsp) return -1; - if (tDeserializeSUseDbRspImp(decoder, pRsp->useDbRsp) < 0) return -1; + if (NULL == pRsp->useDbRsp) { + TAOS_CHECK_RETURN(terrno); + } + TAOS_CHECK_RETURN(tDeserializeSUseDbRspImp(decoder, pRsp->useDbRsp)); } - if (tDecodeI8(decoder, &flag) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI8(decoder, &flag)); if (flag) { pRsp->cfgRsp = taosMemoryCalloc(1, sizeof(SDbCfgRsp)); - if (NULL == pRsp->cfgRsp) return -1; - if (tDeserializeSDbCfgRspImpl(decoder, pRsp->cfgRsp) < 0) return -1; + if (NULL == pRsp->cfgRsp) { + TAOS_CHECK_RETURN(terrno); + } + TAOS_CHECK_RETURN(tDeserializeSDbCfgRspImpl(decoder, pRsp->cfgRsp)); } if (!tDecodeIsEnd(decoder)) { - if (tDecodeI8(decoder, &flag) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI8(decoder, &flag)); if (flag) { pRsp->pTsmaRsp = taosMemoryCalloc(1, sizeof(STableTSMAInfoRsp)); - if (!pRsp->pTsmaRsp) return -1; - if (tDecodeTableTSMAInfoRsp(decoder, pRsp->pTsmaRsp) < 0) return -1; + if (!pRsp->pTsmaRsp) { + TAOS_CHECK_RETURN(terrno); + } + TAOS_CHECK_RETURN(tDecodeTableTSMAInfoRsp(decoder, pRsp->pTsmaRsp)); } } if (!tDecodeIsEnd(decoder)) { - if (tDecodeI32(decoder, &pRsp->dbTsmaVersion) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->dbTsmaVersion)); } if (!tDecodeIsEnd(decoder)) { - if (tDecodeCStrTo(decoder, pRsp->db) < 0) return -1; - if (tDecodeI64(decoder, &pRsp->dbId) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeCStrTo(decoder, pRsp->db)); + TAOS_CHECK_RETURN(tDecodeI64(decoder, &pRsp->dbId)); } return 0; @@ -4162,33 +4517,33 @@ int32_t tDeserializeSDbHbRspImp(SDecoder *decoder, SDbHbRsp *pRsp) { int32_t tDeserializeSDbHbBatchRsp(void *buf, int32_t bufLen, SDbHbBatchRsp *pRsp) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); int32_t numOfBatch = taosArrayGetSize(pRsp->pArray); - if (tDecodeI32(&decoder, &numOfBatch) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &numOfBatch)); pRsp->pArray = taosArrayInit(numOfBatch, sizeof(SDbHbRsp)); if (pRsp->pArray == NULL) { - return -1; + TAOS_CHECK_EXIT(terrno); } for (int32_t i = 0; i < numOfBatch; ++i) { SDbHbRsp rsp = {0}; - if (tDeserializeSDbHbRspImp(&decoder, &rsp) < 0) { - tDecoderClear(&decoder); - return -1; - } + TAOS_CHECK_EXIT(tDeserializeSDbHbRspImp(&decoder, &rsp)); + if (taosArrayPush(pRsp->pArray, &rsp) == NULL) { - tDecoderClear(&decoder); - return -1; + TAOS_CHECK_EXIT(terrno); } } tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSUsedbRsp(SUseDbRsp *pRsp) { taosArrayDestroy(pRsp->pVgroupInfos); } @@ -4225,46 +4580,59 @@ void tFreeSDbHbBatchRsp(SDbHbBatchRsp *pRsp) { int32_t tSerializeSUserAuthBatchRsp(void *buf, int32_t bufLen, SUserAuthBatchRsp *pRsp) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); int32_t numOfBatch = taosArrayGetSize(pRsp->pArray); - if (tEncodeI32(&encoder, numOfBatch) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI32(&encoder, numOfBatch)); for (int32_t i = 0; i < numOfBatch; ++i) { SGetUserAuthRsp *pUserAuthRsp = taosArrayGet(pRsp->pArray, i); - if (tSerializeSGetUserAuthRspImpl(&encoder, pUserAuthRsp) < 0) return -1; + TAOS_CHECK_EXIT(tSerializeSGetUserAuthRspImpl(&encoder, pUserAuthRsp)); } tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSUserAuthBatchRsp(void *buf, int32_t bufLen, SUserAuthBatchRsp *pRsp) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); int32_t numOfBatch = taosArrayGetSize(pRsp->pArray); - if (tDecodeI32(&decoder, &numOfBatch) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &numOfBatch)); pRsp->pArray = taosArrayInit(numOfBatch, sizeof(SGetUserAuthRsp)); if (pRsp->pArray == NULL) { - return -1; + TAOS_CHECK_EXIT(terrno); } for (int32_t i = 0; i < numOfBatch; ++i) { SGetUserAuthRsp rsp = {0}; - if (tDeserializeSGetUserAuthRspImpl(&decoder, &rsp) < 0) return -1; - if (taosArrayPush(pRsp->pArray, &rsp) == NULL) return -1; + TAOS_CHECK_EXIT(tDeserializeSGetUserAuthRspImpl(&decoder, &rsp)); + if (taosArrayPush(pRsp->pArray, &rsp) == NULL) { + TAOS_CHECK_EXIT(terrno); + } } tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSUserAuthBatchRsp(SUserAuthBatchRsp *pRsp) { @@ -4279,27 +4647,38 @@ void tFreeSUserAuthBatchRsp(SUserAuthBatchRsp *pRsp) { int32_t tSerializeSDbCfgReq(void *buf, int32_t bufLen, SDbCfgReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->db) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->db)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSDbCfgReq(void *buf, int32_t bufLen, SDbCfgReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->db)); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } int32_t tSerializeSTrimDbReq(void *buf, int32_t bufLen, STrimDbReq *pReq) { @@ -4318,262 +4697,318 @@ int32_t tSerializeSTrimDbReq(void *buf, int32_t bufLen, STrimDbReq *pReq) { int32_t tDeserializeSTrimDbReq(void *buf, int32_t bufLen, STrimDbReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->maxSpeed) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->db)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->maxSpeed)); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } int32_t tSerializeSVTrimDbReq(void *buf, int32_t bufLen, SVTrimDbReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeI32(&encoder, pReq->timestamp) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->timestamp)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSVTrimDbReq(void *buf, int32_t bufLen, SVTrimDbReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->timestamp) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->timestamp)); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } int32_t tSerializeSS3MigrateDbReq(void *buf, int32_t bufLen, SS3MigrateDbReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->db) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->db)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSS3MigrateDbReq(void *buf, int32_t bufLen, SS3MigrateDbReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->db)); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } int32_t tSerializeSVS3MigrateDbReq(void *buf, int32_t bufLen, SVS3MigrateDbReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeI32(&encoder, pReq->timestamp) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->timestamp)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSVS3MigrateDbReq(void *buf, int32_t bufLen, SVS3MigrateDbReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->timestamp) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->timestamp)); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } int32_t tSerializeSVDropTtlTableReq(void *buf, int32_t bufLen, SVDropTtlTableReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeI32(&encoder, pReq->timestampSec) < 0) return -1; - if (tEncodeI32(&encoder, pReq->ttlDropMaxCount) < 0) return -1; - if (tEncodeI32(&encoder, pReq->nUids) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->timestampSec)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->ttlDropMaxCount)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->nUids)); for (int32_t i = 0; i < pReq->nUids; ++i) { tb_uid_t *pTbUid = taosArrayGet(pReq->pTbUids, i); - if (tEncodeI64(&encoder, *pTbUid) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI64(&encoder, *pTbUid)); } tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSVDropTtlTableReq(void *buf, int32_t bufLen, SVDropTtlTableReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->timestampSec) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->timestampSec)); pReq->ttlDropMaxCount = INT32_MAX; pReq->nUids = 0; pReq->pTbUids = NULL; if (!tDecodeIsEnd(&decoder)) { - if (tDecodeI32(&decoder, &pReq->ttlDropMaxCount) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->nUids) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->ttlDropMaxCount)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->nUids)); if (pReq->nUids > 0) { pReq->pTbUids = taosArrayInit(pReq->nUids, sizeof(tb_uid_t)); if (pReq->pTbUids == NULL) { - return -1; + TAOS_CHECK_EXIT(terrno); } } tb_uid_t tbUid = 0; for (int32_t i = 0; i < pReq->nUids; ++i) { - if (tDecodeI64(&decoder, &tbUid) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &tbUid)); if (taosArrayPush(pReq->pTbUids, &tbUid) == NULL) { - return -1; + TAOS_CHECK_EXIT(terrno); } } } tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } int32_t tSerializeSDbCfgRspImpl(SEncoder *encoder, const SDbCfgRsp *pRsp) { - if (tEncodeCStr(encoder, pRsp->db) < 0) return -1; - if (tEncodeI64(encoder, pRsp->dbId) < 0) return -1; - if (tEncodeI32(encoder, pRsp->cfgVersion) < 0) return -1; - if (tEncodeI32(encoder, pRsp->numOfVgroups) < 0) return -1; - if (tEncodeI32(encoder, pRsp->numOfStables) < 0) return -1; - if (tEncodeI32(encoder, pRsp->buffer) < 0) return -1; - if (tEncodeI32(encoder, pRsp->cacheSize) < 0) return -1; - if (tEncodeI32(encoder, pRsp->pageSize) < 0) return -1; - if (tEncodeI32(encoder, pRsp->pages) < 0) return -1; - if (tEncodeI32(encoder, pRsp->daysPerFile) < 0) return -1; - if (tEncodeI32(encoder, pRsp->daysToKeep0) < 0) return -1; - if (tEncodeI32(encoder, pRsp->daysToKeep1) < 0) return -1; - if (tEncodeI32(encoder, pRsp->daysToKeep2) < 0) return -1; - if (tEncodeI32(encoder, pRsp->minRows) < 0) return -1; - if (tEncodeI32(encoder, pRsp->maxRows) < 0) return -1; - if (tEncodeI32(encoder, pRsp->walFsyncPeriod) < 0) return -1; - if (tEncodeI16(encoder, pRsp->hashPrefix) < 0) return -1; - if (tEncodeI16(encoder, pRsp->hashSuffix) < 0) return -1; - if (tEncodeI8(encoder, pRsp->walLevel) < 0) return -1; - if (tEncodeI8(encoder, pRsp->precision) < 0) return -1; - if (tEncodeI8(encoder, pRsp->compression) < 0) return -1; - if (tEncodeI8(encoder, pRsp->replications) < 0) return -1; - if (tEncodeI8(encoder, pRsp->strict) < 0) return -1; - if (tEncodeI8(encoder, pRsp->cacheLast) < 0) return -1; - if (tEncodeI32(encoder, pRsp->tsdbPageSize) < 0) return -1; - if (tEncodeI32(encoder, pRsp->walRetentionPeriod) < 0) return -1; - if (tEncodeI32(encoder, pRsp->walRollPeriod) < 0) return -1; - if (tEncodeI64(encoder, pRsp->walRetentionSize) < 0) return -1; - if (tEncodeI64(encoder, pRsp->walSegmentSize) < 0) return -1; - if (tEncodeI32(encoder, pRsp->numOfRetensions) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeCStr(encoder, pRsp->db)); + TAOS_CHECK_RETURN(tEncodeI64(encoder, pRsp->dbId)); + TAOS_CHECK_RETURN(tEncodeI32(encoder, pRsp->cfgVersion)); + TAOS_CHECK_RETURN(tEncodeI32(encoder, pRsp->numOfVgroups)); + TAOS_CHECK_RETURN(tEncodeI32(encoder, pRsp->numOfStables)); + TAOS_CHECK_RETURN(tEncodeI32(encoder, pRsp->buffer)); + TAOS_CHECK_RETURN(tEncodeI32(encoder, pRsp->cacheSize)); + TAOS_CHECK_RETURN(tEncodeI32(encoder, pRsp->pageSize)); + TAOS_CHECK_RETURN(tEncodeI32(encoder, pRsp->pages)); + TAOS_CHECK_RETURN(tEncodeI32(encoder, pRsp->daysPerFile)); + TAOS_CHECK_RETURN(tEncodeI32(encoder, pRsp->daysToKeep0)); + TAOS_CHECK_RETURN(tEncodeI32(encoder, pRsp->daysToKeep1)); + TAOS_CHECK_RETURN(tEncodeI32(encoder, pRsp->daysToKeep2)); + TAOS_CHECK_RETURN(tEncodeI32(encoder, pRsp->minRows)); + TAOS_CHECK_RETURN(tEncodeI32(encoder, pRsp->maxRows)); + TAOS_CHECK_RETURN(tEncodeI32(encoder, pRsp->walFsyncPeriod)); + TAOS_CHECK_RETURN(tEncodeI16(encoder, pRsp->hashPrefix)); + TAOS_CHECK_RETURN(tEncodeI16(encoder, pRsp->hashSuffix)); + TAOS_CHECK_RETURN(tEncodeI8(encoder, pRsp->walLevel)); + TAOS_CHECK_RETURN(tEncodeI8(encoder, pRsp->precision)); + TAOS_CHECK_RETURN(tEncodeI8(encoder, pRsp->compression)); + TAOS_CHECK_RETURN(tEncodeI8(encoder, pRsp->replications)); + TAOS_CHECK_RETURN(tEncodeI8(encoder, pRsp->strict)); + TAOS_CHECK_RETURN(tEncodeI8(encoder, pRsp->cacheLast)); + TAOS_CHECK_RETURN(tEncodeI32(encoder, pRsp->tsdbPageSize)); + TAOS_CHECK_RETURN(tEncodeI32(encoder, pRsp->walRetentionPeriod)); + TAOS_CHECK_RETURN(tEncodeI32(encoder, pRsp->walRollPeriod)); + TAOS_CHECK_RETURN(tEncodeI64(encoder, pRsp->walRetentionSize)); + TAOS_CHECK_RETURN(tEncodeI64(encoder, pRsp->walSegmentSize)); + TAOS_CHECK_RETURN(tEncodeI32(encoder, pRsp->numOfRetensions)); for (int32_t i = 0; i < pRsp->numOfRetensions; ++i) { SRetention *pRetension = taosArrayGet(pRsp->pRetensions, i); - if (tEncodeI64(encoder, pRetension->freq) < 0) return -1; - if (tEncodeI64(encoder, pRetension->keep) < 0) return -1; - if (tEncodeI8(encoder, pRetension->freqUnit) < 0) return -1; - if (tEncodeI8(encoder, pRetension->keepUnit) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI64(encoder, pRetension->freq)); + TAOS_CHECK_RETURN(tEncodeI64(encoder, pRetension->keep)); + TAOS_CHECK_RETURN(tEncodeI8(encoder, pRetension->freqUnit)); + TAOS_CHECK_RETURN(tEncodeI8(encoder, pRetension->keepUnit)); } - if (tEncodeI8(encoder, pRsp->schemaless) < 0) return -1; - if (tEncodeI16(encoder, pRsp->sstTrigger) < 0) return -1; - if (tEncodeI32(encoder, pRsp->keepTimeOffset) < 0) return -1; - if (tEncodeI8(encoder, pRsp->withArbitrator) < 0) return -1; - if (tEncodeI8(encoder, pRsp->encryptAlgorithm) < 0) return -1; - if (tEncodeI32(encoder, pRsp->s3ChunkSize) < 0) return -1; - if (tEncodeI32(encoder, pRsp->s3KeepLocal) < 0) return -1; - if (tEncodeI8(encoder, pRsp->s3Compact) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI8(encoder, pRsp->schemaless)); + TAOS_CHECK_RETURN(tEncodeI16(encoder, pRsp->sstTrigger)); + TAOS_CHECK_RETURN(tEncodeI32(encoder, pRsp->keepTimeOffset)); + TAOS_CHECK_RETURN(tEncodeI8(encoder, pRsp->withArbitrator)); + TAOS_CHECK_RETURN(tEncodeI8(encoder, pRsp->encryptAlgorithm)); + TAOS_CHECK_RETURN(tEncodeI32(encoder, pRsp->s3ChunkSize)); + TAOS_CHECK_RETURN(tEncodeI32(encoder, pRsp->s3KeepLocal)); + TAOS_CHECK_RETURN(tEncodeI8(encoder, pRsp->s3Compact)); return 0; } int32_t tSerializeSDbCfgRsp(void *buf, int32_t bufLen, const SDbCfgRsp *pRsp) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tSerializeSDbCfgRspImpl(&encoder, pRsp) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tSerializeSDbCfgRspImpl(&encoder, pRsp)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; + +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSDbCfgRspImpl(SDecoder *decoder, SDbCfgRsp *pRsp) { - if (tDecodeCStrTo(decoder, pRsp->db) < 0) return -1; - if (tDecodeI64(decoder, &pRsp->dbId) < 0) return -1; - if (tDecodeI32(decoder, &pRsp->cfgVersion) < 0) return -1; - if (tDecodeI32(decoder, &pRsp->numOfVgroups) < 0) return -1; - if (tDecodeI32(decoder, &pRsp->numOfStables) < 0) return -1; - if (tDecodeI32(decoder, &pRsp->buffer) < 0) return -1; - if (tDecodeI32(decoder, &pRsp->cacheSize) < 0) return -1; - if (tDecodeI32(decoder, &pRsp->pageSize) < 0) return -1; - if (tDecodeI32(decoder, &pRsp->pages) < 0) return -1; - if (tDecodeI32(decoder, &pRsp->daysPerFile) < 0) return -1; - if (tDecodeI32(decoder, &pRsp->daysToKeep0) < 0) return -1; - if (tDecodeI32(decoder, &pRsp->daysToKeep1) < 0) return -1; - if (tDecodeI32(decoder, &pRsp->daysToKeep2) < 0) return -1; - if (tDecodeI32(decoder, &pRsp->minRows) < 0) return -1; - if (tDecodeI32(decoder, &pRsp->maxRows) < 0) return -1; - if (tDecodeI32(decoder, &pRsp->walFsyncPeriod) < 0) return -1; - if (tDecodeI16(decoder, &pRsp->hashPrefix) < 0) return -1; - if (tDecodeI16(decoder, &pRsp->hashSuffix) < 0) return -1; - if (tDecodeI8(decoder, &pRsp->walLevel) < 0) return -1; - if (tDecodeI8(decoder, &pRsp->precision) < 0) return -1; - if (tDecodeI8(decoder, &pRsp->compression) < 0) return -1; - if (tDecodeI8(decoder, &pRsp->replications) < 0) return -1; - if (tDecodeI8(decoder, &pRsp->strict) < 0) return -1; - if (tDecodeI8(decoder, &pRsp->cacheLast) < 0) return -1; - if (tDecodeI32(decoder, &pRsp->tsdbPageSize) < 0) return -1; - if (tDecodeI32(decoder, &pRsp->walRetentionPeriod) < 0) return -1; - if (tDecodeI32(decoder, &pRsp->walRollPeriod) < 0) return -1; - if (tDecodeI64(decoder, &pRsp->walRetentionSize) < 0) return -1; - if (tDecodeI64(decoder, &pRsp->walSegmentSize) < 0) return -1; - if (tDecodeI32(decoder, &pRsp->numOfRetensions) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeCStrTo(decoder, pRsp->db)); + TAOS_CHECK_RETURN(tDecodeI64(decoder, &pRsp->dbId)); + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->cfgVersion)); + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->numOfVgroups)); + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->numOfStables)); + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->buffer)); + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->cacheSize)); + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->pageSize)); + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->pages)); + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->daysPerFile)); + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->daysToKeep0)); + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->daysToKeep1)); + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->daysToKeep2)); + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->minRows)); + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->maxRows)); + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->walFsyncPeriod)); + TAOS_CHECK_RETURN(tDecodeI16(decoder, &pRsp->hashPrefix)); + TAOS_CHECK_RETURN(tDecodeI16(decoder, &pRsp->hashSuffix)); + TAOS_CHECK_RETURN(tDecodeI8(decoder, &pRsp->walLevel)); + TAOS_CHECK_RETURN(tDecodeI8(decoder, &pRsp->precision)); + TAOS_CHECK_RETURN(tDecodeI8(decoder, &pRsp->compression)); + TAOS_CHECK_RETURN(tDecodeI8(decoder, &pRsp->replications)); + TAOS_CHECK_RETURN(tDecodeI8(decoder, &pRsp->strict)); + TAOS_CHECK_RETURN(tDecodeI8(decoder, &pRsp->cacheLast)); + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->tsdbPageSize)); + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->walRetentionPeriod)); + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->walRollPeriod)); + TAOS_CHECK_RETURN(tDecodeI64(decoder, &pRsp->walRetentionSize)); + TAOS_CHECK_RETURN(tDecodeI64(decoder, &pRsp->walSegmentSize)); + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->numOfRetensions)); if (pRsp->numOfRetensions > 0) { pRsp->pRetensions = taosArrayInit(pRsp->numOfRetensions, sizeof(SRetention)); if (pRsp->pRetensions == NULL) { - return -1; + TAOS_CHECK_RETURN(terrno); } } for (int32_t i = 0; i < pRsp->numOfRetensions; ++i) { SRetention rentension = {0}; - if (tDecodeI64(decoder, &rentension.freq) < 0) return -1; - if (tDecodeI64(decoder, &rentension.keep) < 0) return -1; - if (tDecodeI8(decoder, &rentension.freqUnit) < 0) return -1; - if (tDecodeI8(decoder, &rentension.keepUnit) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI64(decoder, &rentension.freq)); + TAOS_CHECK_RETURN(tDecodeI64(decoder, &rentension.keep)); + TAOS_CHECK_RETURN(tDecodeI8(decoder, &rentension.freqUnit)); + TAOS_CHECK_RETURN(tDecodeI8(decoder, &rentension.keepUnit)); if (taosArrayPush(pRsp->pRetensions, &rentension) == NULL) { - return -1; + TAOS_CHECK_RETURN(terrno); } } - if (tDecodeI8(decoder, &pRsp->schemaless) < 0) return -1; - if (tDecodeI16(decoder, &pRsp->sstTrigger) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI8(decoder, &pRsp->schemaless)); + TAOS_CHECK_RETURN(tDecodeI16(decoder, &pRsp->sstTrigger)); pRsp->keepTimeOffset = TSDB_DEFAULT_KEEP_TIME_OFFSET; if (!tDecodeIsEnd(decoder)) { - if (tDecodeI32(decoder, &pRsp->keepTimeOffset) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->keepTimeOffset)); } pRsp->withArbitrator = TSDB_DEFAULT_DB_WITH_ARBITRATOR; pRsp->encryptAlgorithm = TSDB_DEFAULT_ENCRYPT_ALGO; @@ -4581,11 +5016,11 @@ int32_t tDeserializeSDbCfgRspImpl(SDecoder *decoder, SDbCfgRsp *pRsp) { pRsp->s3KeepLocal = TSDB_DEFAULT_S3_KEEP_LOCAL; pRsp->s3Compact = TSDB_DEFAULT_S3_COMPACT; if (!tDecodeIsEnd(decoder)) { - if (tDecodeI8(decoder, &pRsp->withArbitrator) < 0) return -1; - if (tDecodeI8(decoder, &pRsp->encryptAlgorithm) < 0) return -1; - if (tDecodeI32(decoder, &pRsp->s3ChunkSize) < 0) return -1; - if (tDecodeI32(decoder, &pRsp->s3KeepLocal) < 0) return -1; - if (tDecodeI8(decoder, &pRsp->s3Compact) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI8(decoder, &pRsp->withArbitrator)); + TAOS_CHECK_RETURN(tDecodeI8(decoder, &pRsp->encryptAlgorithm)); + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->s3ChunkSize)); + TAOS_CHECK_RETURN(tDecodeI32(decoder, &pRsp->s3KeepLocal)); + TAOS_CHECK_RETURN(tDecodeI8(decoder, &pRsp->s3Compact)); } return 0; @@ -4593,14 +5028,17 @@ int32_t tDeserializeSDbCfgRspImpl(SDecoder *decoder, SDbCfgRsp *pRsp) { int32_t tDeserializeSDbCfgRsp(void *buf, int32_t bufLen, SDbCfgRsp *pRsp) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDeserializeSDbCfgRspImpl(&decoder, pRsp) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDeserializeSDbCfgRspImpl(&decoder, pRsp)); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSDbCfgRsp(SDbCfgRsp *pRsp) { @@ -4613,97 +5051,130 @@ void tFreeSDbCfgRsp(SDbCfgRsp *pRsp) { int32_t tSerializeSUserIndexReq(void *buf, int32_t bufLen, SUserIndexReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->indexFName) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->indexFName)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSUserIndexReq(void *buf, int32_t bufLen, SUserIndexReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->indexFName) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->indexFName)); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } int32_t tSerializeSUserIndexRsp(void *buf, int32_t bufLen, const SUserIndexRsp *pRsp) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pRsp->dbFName) < 0) return -1; - if (tEncodeCStr(&encoder, pRsp->tblFName) < 0) return -1; - if (tEncodeCStr(&encoder, pRsp->colName) < 0) return -1; - if (tEncodeCStr(&encoder, pRsp->indexType) < 0) return -1; - if (tEncodeCStr(&encoder, pRsp->indexExts) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pRsp->dbFName)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pRsp->tblFName)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pRsp->colName)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pRsp->indexType)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pRsp->indexExts)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSUserIndexRsp(void *buf, int32_t bufLen, SUserIndexRsp *pRsp) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pRsp->dbFName) < 0) return -1; - if (tDecodeCStrTo(&decoder, pRsp->tblFName) < 0) return -1; - if (tDecodeCStrTo(&decoder, pRsp->colName) < 0) return -1; - if (tDecodeCStrTo(&decoder, pRsp->indexType) < 0) return -1; - if (tDecodeCStrTo(&decoder, pRsp->indexExts) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pRsp->dbFName)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pRsp->tblFName)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pRsp->colName)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pRsp->indexType)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pRsp->indexExts)); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } int32_t tSerializeSTableIndexReq(void *buf, int32_t bufLen, STableIndexReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->tbFName) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->tbFName)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSTableIndexReq(void *buf, int32_t bufLen, STableIndexReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->tbFName) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->tbFName)); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } int32_t tSerializeSTableIndexInfo(SEncoder *pEncoder, STableIndexInfo *pInfo) { - if (tEncodeI8(pEncoder, pInfo->intervalUnit) < 0) return -1; - if (tEncodeI8(pEncoder, pInfo->slidingUnit) < 0) return -1; - if (tEncodeI64(pEncoder, pInfo->interval) < 0) return -1; - if (tEncodeI64(pEncoder, pInfo->offset) < 0) return -1; - if (tEncodeI64(pEncoder, pInfo->sliding) < 0) return -1; - if (tEncodeI64(pEncoder, pInfo->dstTbUid) < 0) return -1; - if (tEncodeI32(pEncoder, pInfo->dstVgId) < 0) return -1; - if (tEncodeSEpSet(pEncoder, &pInfo->epSet) < 0) return -1; - if (tEncodeCStr(pEncoder, pInfo->expr) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pInfo->intervalUnit)); + TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pInfo->slidingUnit)); + TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pInfo->interval)); + TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pInfo->offset)); + TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pInfo->sliding)); + TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pInfo->dstTbUid)); + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pInfo->dstVgId)); + TAOS_CHECK_RETURN(tEncodeSEpSet(pEncoder, &pInfo->epSet)); + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pInfo->expr)); return 0; } diff --git a/source/dnode/vnode/src/sma/smaEnv.c b/source/dnode/vnode/src/sma/smaEnv.c index 96992e2fa5..c26708bd68 100644 --- a/source/dnode/vnode/src/sma/smaEnv.c +++ b/source/dnode/vnode/src/sma/smaEnv.c @@ -174,10 +174,14 @@ static void tRSmaInfoHashFreeNode(void *data) { if ((pRSmaInfo = *(SRSmaInfo **)data)) { if ((pItem = RSMA_INFO_ITEM((SRSmaInfo *)pRSmaInfo, 0)) && pItem->level) { - (void)taosHashRemove(smaMgmt.refHash, &pItem, POINTER_BYTES); + if (TSDB_CODE_SUCCESS != taosHashRemove(smaMgmt.refHash, &pItem, POINTER_BYTES)) { + smaError("failed to hash remove %s:%d", __FUNCTION__, __LINE__); + } } if ((pItem = RSMA_INFO_ITEM((SRSmaInfo *)pRSmaInfo, 1)) && pItem->level) { - (void)taosHashRemove(smaMgmt.refHash, &pItem, POINTER_BYTES); + if (TSDB_CODE_SUCCESS != taosHashRemove(smaMgmt.refHash, &pItem, POINTER_BYTES)) { + smaError("failed to hash remove %s:%d", __FUNCTION__, __LINE__); + } } (void)tdFreeRSmaInfo(pRSmaInfo->pSma, pRSmaInfo); } diff --git a/source/dnode/vnode/src/tq/tqStreamTaskSnap.c b/source/dnode/vnode/src/tq/tqStreamTaskSnap.c index 742d165062..a279b58d32 100644 --- a/source/dnode/vnode/src/tq/tqStreamTaskSnap.c +++ b/source/dnode/vnode/src/tq/tqStreamTaskSnap.c @@ -50,10 +50,14 @@ int32_t streamTaskSnapReaderOpen(STQ* pTq, int64_t sver, int64_t ever, SStreamTa } STablePair pair1 = {.tbl = pTq->pStreamMeta->pTaskDb, .type = SNAP_DATA_STREAM_TASK}; - (void)taosArrayPush(pReader->tdbTbList, &pair1); + if (NULL == taosArrayPush(pReader->tdbTbList, &pair1)) { + TAOS_CHECK_GOTO(terrno, NULL, _err); + } STablePair pair2 = {.tbl = pTq->pStreamMeta->pCheckpointDb, .type = SNAP_DATA_STREAM_TASK_CHECKPOINT}; - (void)taosArrayPush(pReader->tdbTbList, &pair2); + if (NULL == taosArrayPush(pReader->tdbTbList, &pair2)) { + TAOS_CHECK_GOTO(terrno, NULL, _err); + } pReader->pos = 0; diff --git a/source/dnode/vnode/src/tsdb/tsdbCache.c b/source/dnode/vnode/src/tsdb/tsdbCache.c index 114a1f7b89..2a321289d1 100644 --- a/source/dnode/vnode/src/tsdb/tsdbCache.c +++ b/source/dnode/vnode/src/tsdb/tsdbCache.c @@ -678,14 +678,14 @@ int32_t tsdbCacheCommitNoLock(STsdb *pTsdb) { static int32_t tsdbCacheGetValuesFromRocks(STsdb *pTsdb, size_t numKeys, const char *const *ppKeysList, size_t *pKeysListSizes, char ***pppValuesList, size_t **ppValuesListSizes) { - char **valuesList = taosMemoryCalloc(numKeys, sizeof(char *)); - if(!valuesList) return terrno; + char **valuesList = taosMemoryCalloc(numKeys, sizeof(char *)); + if (!valuesList) return terrno; size_t *valuesListSizes = taosMemoryCalloc(numKeys, sizeof(size_t)); - if(!valuesListSizes) { + if (!valuesListSizes) { taosMemoryFreeClear(valuesList); return terrno; } - char **errs = taosMemoryCalloc(numKeys, sizeof(char *)); + char **errs = taosMemoryCalloc(numKeys, sizeof(char *)); if (!errs) { taosMemoryFreeClear(valuesList); taosMemoryFreeClear(valuesListSizes); @@ -1178,7 +1178,7 @@ static int32_t tsdbCacheUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, SArray size_t *values_list_sizes = NULL; char **errs = NULL; keys_list = taosMemoryCalloc(num_keys, sizeof(char *)); - if(!keys_list) { + if (!keys_list) { (void)taosThreadMutexUnlock(&pTsdb->lruMutex); return terrno; } @@ -1692,19 +1692,18 @@ static int32_t tsdbCacheLoadFromRocks(STsdb *pTsdb, tb_uid_t uid, SArray *pLastA goto _exit; } + SLastCol lastCol = *pLastCol; + TAOS_CHECK_EXIT(tsdbCacheReallocSLastCol(&lastCol, NULL)); + LRUStatus status = taosLRUCacheInsert(pCache, &idxKey->key, ROCKS_KEY_LEN, pLastCol, charge, tsdbCacheDeleter, NULL, TAOS_LRU_PRIORITY_LOW, &pTsdb->flushState); if (status != TAOS_LRU_STATUS_OK) { code = -1; } - SLastCol lastCol = *pLastCol; - TAOS_CHECK_EXIT(tsdbCacheReallocSLastCol(&lastCol, NULL)); - taosArraySet(pLastArray, idxKey->idx, &lastCol); taosArrayRemove(remainCols, j); taosArrayRemove(ignoreFromRocks, j); - } else { ++j; } diff --git a/source/libs/executor/src/aggregateoperator.c b/source/libs/executor/src/aggregateoperator.c index f0e0f81cf5..20fbf9d32b 100644 --- a/source/libs/executor/src/aggregateoperator.c +++ b/source/libs/executor/src/aggregateoperator.c @@ -82,7 +82,7 @@ int32_t createAggregateOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* pA SAggOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SAggOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } @@ -536,7 +536,7 @@ int32_t doInitAggInfoSup(SAggSupporter* pAggSup, SqlFunctionCtx* pCtx, int32_t n pAggSup->pResultRowHashTable = tSimpleHashInit(100, taosFastHash); if (pAggSup->keyBuf == NULL || pAggSup->pResultRowHashTable == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } uint32_t defaultPgsz = 0; diff --git a/source/libs/executor/src/cachescanoperator.c b/source/libs/executor/src/cachescanoperator.c index c26d193a06..fdf20b4613 100644 --- a/source/libs/executor/src/cachescanoperator.c +++ b/source/libs/executor/src/cachescanoperator.c @@ -107,7 +107,7 @@ int32_t createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SReadHandl SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } diff --git a/source/libs/executor/src/countwindowoperator.c b/source/libs/executor/src/countwindowoperator.c index 28b2c22053..713116d605 100644 --- a/source/libs/executor/src/countwindowoperator.c +++ b/source/libs/executor/src/countwindowoperator.c @@ -302,7 +302,7 @@ int32_t createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* phy SCountWindowOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SCountWindowOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } diff --git a/source/libs/executor/src/eventwindowoperator.c b/source/libs/executor/src/eventwindowoperator.c index 591590a261..a4be2ddf7d 100644 --- a/source/libs/executor/src/eventwindowoperator.c +++ b/source/libs/executor/src/eventwindowoperator.c @@ -68,7 +68,7 @@ int32_t createEventwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* phy SEventWindowOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SEventWindowOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } diff --git a/source/libs/executor/src/exchangeoperator.c b/source/libs/executor/src/exchangeoperator.c index 120dcbc205..f6f3570804 100644 --- a/source/libs/executor/src/exchangeoperator.c +++ b/source/libs/executor/src/exchangeoperator.c @@ -408,7 +408,7 @@ int32_t createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode* pExNo SExchangeInfo* pInfo = taosMemoryCalloc(1, sizeof(SExchangeInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c index c41dda349f..d469afb269 100644 --- a/source/libs/executor/src/executil.c +++ b/source/libs/executor/src/executil.c @@ -322,13 +322,13 @@ int32_t prepareDataBlockBuf(SSDataBlock* pDataBlock, SColMatchInfo* pMatchInfo) if (IS_VAR_DATA_TYPE(pItem->dataType.type)) { pBlockInfo->pks[0].pData = taosMemoryCalloc(1, pInfoData->info.bytes); if (pBlockInfo->pks[0].pData == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } pBlockInfo->pks[1].pData = taosMemoryCalloc(1, pInfoData->info.bytes); if (pBlockInfo->pks[1].pData == NULL) { taosMemoryFreeClear(pBlockInfo->pks[0].pData); - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } pBlockInfo->pks[0].nData = pInfoData->info.bytes; @@ -520,7 +520,6 @@ static EDealRes getColumn(SNode** pNode, void* pContext) { static int32_t createResultData(SDataType* pType, int32_t numOfRows, SScalarParam* pParam) { SColumnInfoData* pColumnData = taosMemoryCalloc(1, sizeof(SColumnInfoData)); if (pColumnData == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; return terrno; } @@ -759,7 +758,7 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf keyBuf = taosMemoryCalloc(1, keyLen); if (keyBuf == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto end; } @@ -1981,7 +1980,7 @@ static int32_t setSelectValueColumnInfo(SqlFunctionCtx* pCtx, int32_t numOfOutpu SqlFunctionCtx* p = NULL; SqlFunctionCtx** pValCtx = taosMemoryCalloc(numOfOutput, POINTER_BYTES); if (pValCtx == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } SHashObj* pSelectFuncs = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_ENTRY_LOCK); diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c index 573b2ab200..797fa6ab86 100644 --- a/source/libs/executor/src/executor.c +++ b/source/libs/executor/src/executor.c @@ -1236,7 +1236,6 @@ int32_t initQueryTableDataCondForTmq(SQueryTableDataCond* pCond, SSnapContext* s if (pCond->colList == NULL || pCond->pSlotList == NULL) { taosMemoryFreeClear(pCond->colList); taosMemoryFreeClear(pCond->pSlotList); - terrno = TSDB_CODE_OUT_OF_MEMORY; return terrno; } diff --git a/source/libs/executor/src/executorInt.c b/source/libs/executor/src/executorInt.c index b48bacd50d..a1bf64a10d 100644 --- a/source/libs/executor/src/executorInt.c +++ b/source/libs/executor/src/executorInt.c @@ -421,7 +421,7 @@ static int32_t doCreateConstantValColumnSMAInfo(SInputColumnInfoData* pInput, SF if (pInput->pData[paramIndex] == NULL) { pInput->pData[paramIndex] = taosMemoryCalloc(1, sizeof(SColumnInfoData)); if (pInput->pData[paramIndex] == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } // Set the correct column info (data type and bytes) @@ -1092,7 +1092,7 @@ int32_t createDataSinkParam(SDataSinkNode* pNode, void** pParam, SExecTaskInfo* case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT: { SInserterParam* pInserterParam = taosMemoryCalloc(1, sizeof(SInserterParam)); if (NULL == pInserterParam) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } pInserterParam->readHandle = readHandle; @@ -1102,7 +1102,7 @@ int32_t createDataSinkParam(SDataSinkNode* pNode, void** pParam, SExecTaskInfo* case QUERY_NODE_PHYSICAL_PLAN_DELETE: { SDeleterParam* pDeleterParam = taosMemoryCalloc(1, sizeof(SDeleterParam)); if (NULL == pDeleterParam) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } SArray* pInfoList = NULL; diff --git a/source/libs/executor/src/filloperator.c b/source/libs/executor/src/filloperator.c index 246a5e2a6d..21b67c8ffb 100644 --- a/source/libs/executor/src/filloperator.c +++ b/source/libs/executor/src/filloperator.c @@ -430,7 +430,7 @@ int32_t createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* pPhyFi SFillOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SFillOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } diff --git a/source/libs/executor/src/groupcacheoperator.c b/source/libs/executor/src/groupcacheoperator.c index f0e0894bd2..6a9482e31c 100644 --- a/source/libs/executor/src/groupcacheoperator.c +++ b/source/libs/executor/src/groupcacheoperator.c @@ -1298,7 +1298,7 @@ static int32_t initGroupCacheExecInfo(SOperatorInfo* pOperator) { SGroupCacheOperatorInfo* pInfo = pOperator->info; pInfo->execInfo.pDownstreamBlkNum = taosMemoryCalloc(pOperator->numOfDownstream, sizeof(int64_t)); if (NULL == pInfo->execInfo.pDownstreamBlkNum) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } return TSDB_CODE_SUCCESS; } @@ -1342,7 +1342,7 @@ static int32_t initGroupCacheDownstreamCtx(SOperatorInfo* pOperator) { SGroupCacheOperatorInfo* pInfo = pOperator->info; pInfo->pDownstreams = taosMemoryCalloc(pOperator->numOfDownstream, sizeof(*pInfo->pDownstreams)); if (NULL == pInfo->pDownstreams) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } pInfo->downstreamNum = pOperator->numOfDownstream; @@ -1450,7 +1450,7 @@ int32_t createGroupCacheOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfD SGroupCacheOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SGroupCacheOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pOperator == NULL || pInfo == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } diff --git a/source/libs/executor/src/groupoperator.c b/source/libs/executor/src/groupoperator.c index 9b46db609f..47b35fe9f3 100644 --- a/source/libs/executor/src/groupoperator.c +++ b/source/libs/executor/src/groupoperator.c @@ -112,7 +112,7 @@ static int32_t initGroupOptrInfo(SArray** pGroupColVals, int32_t* keyLen, char** key.isNull = false; key.pData = taosMemoryCalloc(1, pCol->bytes); if (key.pData == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } void* tmp = taosArrayPush((*pGroupColVals), &key); @@ -126,7 +126,7 @@ static int32_t initGroupOptrInfo(SArray** pGroupColVals, int32_t* keyLen, char** (*keyBuf) = taosMemoryCalloc(1, (*keyLen)); if ((*keyBuf) == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } return TSDB_CODE_SUCCESS; @@ -1675,7 +1675,7 @@ int32_t createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStreamPart SStreamPartitionOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamPartitionOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } diff --git a/source/libs/executor/src/hashjoinoperator.c b/source/libs/executor/src/hashjoinoperator.c index f253aefe95..4e630dbd18 100644 --- a/source/libs/executor/src/hashjoinoperator.c +++ b/source/libs/executor/src/hashjoinoperator.c @@ -388,7 +388,7 @@ static int32_t hJoinBuildResColsMap(SHJoinOperatorInfo* pInfo, SHashJoinPhysiNod pInfo->pResColNum = pJoinNode->pTargets->length; pInfo->pResColMap = taosMemoryCalloc(pJoinNode->pTargets->length, sizeof(int8_t)); if (NULL == pInfo->pResColMap) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } SNode* pNode = NULL; @@ -1188,7 +1188,7 @@ int32_t createHashJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDow SHJoinOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SHJoinOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pOperator == NULL || pInfo == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _return; } diff --git a/source/libs/executor/src/mergeoperator.c b/source/libs/executor/src/mergeoperator.c index c12bfd8798..93bddb0787 100644 --- a/source/libs/executor/src/mergeoperator.c +++ b/source/libs/executor/src/mergeoperator.c @@ -565,7 +565,7 @@ int32_t createMultiwayMergeOperatorInfo(SOperatorInfo** downStreams, size_t numS SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); SDataBlockDescNode* pDescNode = pPhyNode->pOutputDataBlockDesc; if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } diff --git a/source/libs/executor/src/operator.c b/source/libs/executor/src/operator.c index f11b796feb..2605a1ceeb 100644 --- a/source/libs/executor/src/operator.c +++ b/source/libs/executor/src/operator.c @@ -63,7 +63,7 @@ int32_t optrDummyOpenFn(SOperatorInfo* pOperator) { int32_t appendDownstream(SOperatorInfo* p, SOperatorInfo** pDownstream, int32_t num) { p->pDownstream = taosMemoryCalloc(1, num * POINTER_BYTES); if (p->pDownstream == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } memcpy(p->pDownstream, pDownstream, num * POINTER_BYTES); @@ -826,7 +826,7 @@ int32_t setOperatorParams(struct SOperatorInfo* pOperator, SOperatorParam* pInpu if (NULL == *pppDownstramParam) { *pppDownstramParam = taosMemoryCalloc(pOperator->numOfDownstream, POINTER_BYTES); if (NULL == *pppDownstramParam) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } } diff --git a/source/libs/executor/src/projectoperator.c b/source/libs/executor/src/projectoperator.c index a9ba57e1d4..a3772c958c 100644 --- a/source/libs/executor/src/projectoperator.c +++ b/source/libs/executor/src/projectoperator.c @@ -99,7 +99,7 @@ int32_t createProjectOperatorInfo(SOperatorInfo* downstream, SProjectPhysiNode* SProjectOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SProjectOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } @@ -450,7 +450,7 @@ int32_t createIndefinitOutputOperatorInfo(SOperatorInfo* downstream, SPhysiNode* SIndefOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SIndefOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } diff --git a/source/libs/executor/src/querytask.c b/source/libs/executor/src/querytask.c index b050143ac0..67b05af120 100644 --- a/source/libs/executor/src/querytask.c +++ b/source/libs/executor/src/querytask.c @@ -43,7 +43,7 @@ int32_t doCreateTask(uint64_t queryId, uint64_t taskId, int32_t vgId, EOPTR_EXEC SExecTaskInfo* p = taosMemoryCalloc(1, sizeof(SExecTaskInfo)); if (p == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } setTaskStatus(p, TASK_NOT_COMPLETED); @@ -217,6 +217,7 @@ SSchemaWrapper* extractQueriedColumnSchema(SScanPhysiNode* pScanNode) { pqSw->pSchema = taosMemoryCalloc(numOfCols + numOfTags, sizeof(SSchema)); if (pqSw->pSchema == NULL) { + taosMemoryFree(pqSw); return NULL; } diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c index 28829b6043..260e74f7f2 100644 --- a/source/libs/executor/src/scanoperator.c +++ b/source/libs/executor/src/scanoperator.c @@ -1450,7 +1450,7 @@ int32_t createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHa STableScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableScanInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } @@ -1549,7 +1549,7 @@ int32_t createTableSeqScanOperatorInfo(void* pReadHandle, SExecTaskInfo* pTaskIn STableScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableScanInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _end; } @@ -3299,7 +3299,7 @@ int32_t streamScanOperatorEncode(SStreamScanInfo* pInfo, void** pBuff, int32_t* len += encodeSTimeWindowAggSupp(NULL, &pInfo->twAggSup); *pBuff = taosMemoryCalloc(1, len); if (!(*pBuff)) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; QUERY_CHECK_CODE(code, lino, _end); } void* buf = *pBuff; @@ -4035,7 +4035,7 @@ int32_t createRawScanOperatorInfo(SReadHandle* pHandle, SExecTaskInfo* pTaskInfo SStreamRawScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamRawScanInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; lino = __LINE__; goto _end; } @@ -4118,7 +4118,7 @@ void streamScanReleaseState(SOperatorInfo* pOperator) { pBuff = taosMemoryCalloc(1, len); if (!pBuff) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; QUERY_CHECK_CODE(code, lino, _end); } @@ -4154,7 +4154,7 @@ void streamScanReloadState(SOperatorInfo* pOperator) { SUpdateInfo* pUpInfo = taosMemoryCalloc(1, sizeof(SUpdateInfo)); if (!pUpInfo) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; QUERY_CHECK_CODE(code, lino, _end); } @@ -4231,7 +4231,7 @@ int32_t createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* const char* idstr = pTaskInfo->id.str; if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } @@ -4536,7 +4536,6 @@ static void tagScanFreeUidTag(void* p) { static int32_t tagScanCreateResultData(SDataType* pType, int32_t numOfRows, SScalarParam* pParam) { SColumnInfoData* pColumnData = taosMemoryCalloc(1, sizeof(SColumnInfoData)); if (pColumnData == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; return terrno; } @@ -4945,7 +4944,7 @@ int32_t createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysiNode* p STagScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STagScanInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } @@ -5225,7 +5224,7 @@ static int32_t initSubTablesMergeInfo(STableMergeScanInfo* pInfo) { } STmsSubTablesMergeInfo* pSubTblsInfo = taosMemoryCalloc(1, sizeof(STmsSubTablesMergeInfo)); if (pSubTblsInfo == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } pSubTblsInfo->pTsOrderInfo = taosArrayGet(pInfo->pSortInfo, 0); if (!pSubTblsInfo->pTsOrderInfo) { @@ -5245,7 +5244,7 @@ static int32_t initSubTablesMergeInfo(STableMergeScanInfo* pInfo) { pSubTblsInfo->aInputs = taosMemoryCalloc(pSubTblsInfo->numSubTables, sizeof(STmsSubTableInput)); if (pSubTblsInfo->aInputs == NULL) { taosMemoryFree(pSubTblsInfo); - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } int32_t bufPageSize = pInfo->bufPageSize; int32_t inMemSize = (pSubTblsInfo->numSubTables - pSubTblsInfo->numTableBlocksInMem) * bufPageSize; @@ -6170,7 +6169,7 @@ int32_t createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SR STableMergeScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableMergeScanInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } @@ -6413,7 +6412,7 @@ int32_t createTableCountScanOperatorInfo(SReadHandle* readHandle, STableCountSca STableCountScanOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STableCountScanOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (!pInfo || !pOperator) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } diff --git a/source/libs/executor/src/sortoperator.c b/source/libs/executor/src/sortoperator.c index 8b50cd20ae..bb494cacfa 100644 --- a/source/libs/executor/src/sortoperator.c +++ b/source/libs/executor/src/sortoperator.c @@ -63,7 +63,7 @@ int32_t createSortOperatorInfo(SOperatorInfo* downstream, SSortPhysiNode* pSortN SSortOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SSortOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } @@ -108,7 +108,7 @@ int32_t createSortOperatorInfo(SOperatorInfo* downstream, SSortPhysiNode* pSortN int32_t keyLen; SSortOpGroupIdCalc* pGroupIdCalc = pInfo->pGroupIdCalc = taosMemoryCalloc(1, sizeof(SSortOpGroupIdCalc)); if (!pGroupIdCalc) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } SNodeList* pSortColsNodeArr = makeColsNodeArrFromSortKeys(pSortNode->pSortKeys); @@ -784,7 +784,7 @@ int32_t createGroupSortOperatorInfo(SOperatorInfo* downstream, SGroupSortPhysiNo SGroupSortOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SGroupSortOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } diff --git a/source/libs/executor/src/streamcountwindowoperator.c b/source/libs/executor/src/streamcountwindowoperator.c index de9473b5c4..e2ac909b8b 100644 --- a/source/libs/executor/src/streamcountwindowoperator.c +++ b/source/libs/executor/src/streamcountwindowoperator.c @@ -484,7 +484,7 @@ void doStreamCountSaveCheckpoint(SOperatorInfo* pOperator) { int32_t len = doStreamCountEncodeOpState(NULL, 0, pOperator, true); pBuf = taosMemoryCalloc(1, len); if (!pBuf) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; QUERY_CHECK_CODE(code, lino, _end); } void* pTmpBuf = pBuf; @@ -816,7 +816,7 @@ int32_t createStreamCountAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* SStreamCountAggOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamCountAggOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; QUERY_CHECK_CODE(code, lino, _error); } diff --git a/source/libs/executor/src/streameventwindowoperator.c b/source/libs/executor/src/streameventwindowoperator.c index a63e0f18d3..5ae0aa861e 100644 --- a/source/libs/executor/src/streameventwindowoperator.c +++ b/source/libs/executor/src/streameventwindowoperator.c @@ -867,7 +867,7 @@ int32_t createStreamEventAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* SStreamEventAggOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamEventAggOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } diff --git a/source/libs/executor/src/streamfilloperator.c b/source/libs/executor/src/streamfilloperator.c index 61d3fca345..5e3c4561b4 100644 --- a/source/libs/executor/src/streamfilloperator.c +++ b/source/libs/executor/src/streamfilloperator.c @@ -1169,7 +1169,7 @@ static SStreamFillSupporter* initStreamFillSup(SStreamFillPhysiNode* pPhyFillNod int32_t lino = 0; SStreamFillSupporter* pFillSup = taosMemoryCalloc(1, sizeof(SStreamFillSupporter)); if (!pFillSup) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; QUERY_CHECK_CODE(code, lino, _end); } pFillSup->numOfFillCols = numOfFillCols; @@ -1222,7 +1222,7 @@ SStreamFillInfo* initStreamFillInfo(SStreamFillSupporter* pFillSup, SSDataBlock* int32_t lino = 0; SStreamFillInfo* pFillInfo = taosMemoryCalloc(1, sizeof(SStreamFillInfo)); if (!pFillInfo) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; QUERY_CHECK_CODE(code, lino, _end); } @@ -1233,7 +1233,7 @@ SStreamFillInfo* initStreamFillInfo(SStreamFillSupporter* pFillSup, SSDataBlock* pFillInfo->needFill = false; pFillInfo->pLinearInfo = taosMemoryCalloc(1, sizeof(SStreamFillLinearInfo)); if (!pFillInfo) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; QUERY_CHECK_CODE(code, lino, _end); } @@ -1285,14 +1285,14 @@ SStreamFillInfo* initStreamFillInfo(SStreamFillSupporter* pFillSup, SSDataBlock* pFillSup->type == TSDB_FILL_NULL || pFillSup->type == TSDB_FILL_NULL_F) { pFillInfo->pResRow = taosMemoryCalloc(1, sizeof(SResultRowData)); if (!pFillInfo->pResRow) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; QUERY_CHECK_CODE(code, lino, _end); } pFillInfo->pResRow->key = INT64_MIN; pFillInfo->pResRow->pRowVal = taosMemoryCalloc(1, pFillSup->rowSize); if (!pFillInfo->pResRow->pRowVal) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; QUERY_CHECK_CODE(code, lino, _end); } @@ -1371,7 +1371,7 @@ int32_t createStreamFillOperatorInfo(SOperatorInfo* downstream, SStreamFillPhysi SStreamFillOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamFillOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; QUERY_CHECK_CODE(code, lino, _error); } diff --git a/source/libs/executor/src/streamtimewindowoperator.c b/source/libs/executor/src/streamtimewindowoperator.c index 7631d9096a..476fcde076 100644 --- a/source/libs/executor/src/streamtimewindowoperator.c +++ b/source/libs/executor/src/streamtimewindowoperator.c @@ -1896,7 +1896,7 @@ int32_t createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream, SPhysiN SStreamIntervalOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamIntervalOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; QUERY_CHECK_CODE(code, lino, _error); } @@ -3771,7 +3771,7 @@ int32_t createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode SStreamSessionAggOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamSessionAggOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } @@ -4950,7 +4950,7 @@ int32_t createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* SStreamStateAggOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamStateAggOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; QUERY_CHECK_CODE(code, lino, _error); } @@ -5267,7 +5267,7 @@ int32_t createStreamIntervalOperatorInfo(SOperatorInfo* downstream, SPhysiNode* SStreamIntervalOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamIntervalOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; QUERY_CHECK_CODE(code, lino, _error); } diff --git a/source/libs/executor/src/sysscanoperator.c b/source/libs/executor/src/sysscanoperator.c index 439782253f..7e22e38c95 100644 --- a/source/libs/executor/src/sysscanoperator.c +++ b/source/libs/executor/src/sysscanoperator.c @@ -2236,7 +2236,7 @@ int32_t createSysTableScanOperatorInfo(void* readHandle, SSystemTableScanPhysiNo SSysTableScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SSysTableScanInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; lino = __LINE__; goto _error; } @@ -2832,7 +2832,6 @@ static int32_t initTableblockDistQueryCond(uint64_t uid, SQueryTableDataCond* pC pCond->colList = taosMemoryCalloc(1, sizeof(SColumnInfo)); pCond->pSlotList = taosMemoryMalloc(sizeof(int32_t)); if (pCond->colList == NULL || pCond->pSlotList == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; return terrno; } @@ -2862,7 +2861,7 @@ int32_t createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDistScanP SBlockDistInfo* pInfo = taosMemoryCalloc(1, sizeof(SBlockDistInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - pTaskInfo->code = code = TSDB_CODE_OUT_OF_MEMORY; + pTaskInfo->code = code = terrno; goto _error; } diff --git a/source/libs/executor/src/timesliceoperator.c b/source/libs/executor/src/timesliceoperator.c index 1030ed867f..c6c8e6db35 100644 --- a/source/libs/executor/src/timesliceoperator.c +++ b/source/libs/executor/src/timesliceoperator.c @@ -652,7 +652,7 @@ static int32_t initGroupKeyKeeper(STimeSliceOperatorInfo* pInfo, SExprSupp* pExp pInfo->pPrevGroupKey = taosMemoryCalloc(1, sizeof(SGroupKeys)); if (pInfo->pPrevGroupKey == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } for (int32_t i = 0; i < pExprSup->numOfExprs; ++i) { @@ -1112,7 +1112,7 @@ int32_t createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyN SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pOperator == NULL || pInfo == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c index 5499fa3026..fc91877b66 100644 --- a/source/libs/executor/src/timewindowoperator.c +++ b/source/libs/executor/src/timewindowoperator.c @@ -1327,7 +1327,7 @@ int32_t createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPhysiNode SIntervalAggOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SIntervalAggOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } @@ -1623,7 +1623,7 @@ int32_t createStatewindowOperatorInfo(SOperatorInfo* downstream, SStateWinodwPhy SStateWindowOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStateWindowOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } @@ -1734,7 +1734,7 @@ int32_t createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionWinodwPh SSessionAggOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SSessionAggOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } @@ -2034,7 +2034,7 @@ int32_t createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, SMerge SMergeAlignedIntervalAggOperatorInfo* miaInfo = taosMemoryCalloc(1, sizeof(SMergeAlignedIntervalAggOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (miaInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } @@ -2372,7 +2372,7 @@ int32_t createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SMergeInterva SMergeIntervalAggOperatorInfo* pMergeIntervalInfo = taosMemoryCalloc(1, sizeof(SMergeIntervalAggOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pMergeIntervalInfo == NULL || pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _error; } diff --git a/source/libs/executor/src/tlinearhash.c b/source/libs/executor/src/tlinearhash.c index 83716d72ad..763fc6a412 100644 --- a/source/libs/executor/src/tlinearhash.c +++ b/source/libs/executor/src/tlinearhash.c @@ -260,7 +260,7 @@ static int32_t doAddNewBucket(SLHashObj* pHashObj) { SLHashObj* tHashInit(int32_t inMemPages, int32_t pageSize, _hash_fn_t fn, int32_t numOfTuplePerPage) { SLHashObj* pHashObj = taosMemoryCalloc(1, sizeof(SLHashObj)); if (pHashObj == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; + terrno = terrno; return NULL; } diff --git a/source/libs/executor/src/tsort.c b/source/libs/executor/src/tsort.c index 5a6428a30e..2792e6a197 100644 --- a/source/libs/executor/src/tsort.c +++ b/source/libs/executor/src/tsort.c @@ -1357,7 +1357,7 @@ static int32_t createSortMemFile(SSortHandle* pHandle) { int32_t code = TSDB_CODE_SUCCESS; SSortMemFile* pMemFile = taosMemoryCalloc(1, sizeof(SSortMemFile)); if (pMemFile == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; } if (code == TSDB_CODE_SUCCESS) { taosGetTmpfilePath(tsTempDir, "sort-ext-mem", pMemFile->memFilePath); diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index 76da8adc57..9065ff7525 100755 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -409,16 +409,19 @@ static int32_t addNamespace(STranslateContext* pCxt, void* pTable) { return TSDB_CODE_OUT_OF_MEMORY; } if (pCxt->currLevel == currTotalLevel) { - (void)taosArrayPush(pTables, &pTable); + if (NULL == taosArrayPush(pTables, &pTable)) { + taosArrayDestroy(pTables); + return terrno; + } if (hasSameTableAlias(pTables)) { - (void)taosArrayDestroy(pTables); + taosArrayDestroy(pTables); return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_NOT_UNIQUE_TABLE_ALIAS, "Not unique table/alias: '%s'", ((STableNode*)pTable)->tableAlias); } } if (NULL == taosArrayPush(pCxt->pNsLevel, &pTables)) { code = TSDB_CODE_OUT_OF_MEMORY; - (void)taosArrayDestroy(pTables); + taosArrayDestroy(pTables); break; } ++currTotalLevel; @@ -820,7 +823,7 @@ static int32_t resetHighLevelTranslateNamespace(STranslateContext* pCxt) { } for (int32_t i = size - 1; i >= pCxt->currLevel; --i) { - (void)taosArrayDestroy(taosArrayGetP(pCxt->pNsLevel, i)); + taosArrayDestroy(taosArrayGetP(pCxt->pNsLevel, i)); } taosArrayPopTailBatch(pCxt->pNsLevel, levelNum); @@ -837,9 +840,9 @@ static int32_t resetTranslateNamespace(STranslateContext* pCxt) { if (NULL != pCxt->pNsLevel) { size_t size = taosArrayGetSize(pCxt->pNsLevel); for (size_t i = 0; i < size; ++i) { - (void)taosArrayDestroy(taosArrayGetP(pCxt->pNsLevel, i)); + taosArrayDestroy(taosArrayGetP(pCxt->pNsLevel, i)); } - (void)taosArrayDestroy(pCxt->pNsLevel); + taosArrayDestroy(pCxt->pNsLevel); } pCxt->pNsLevel = taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES); if (NULL == pCxt->pNsLevel) { @@ -852,9 +855,9 @@ static void destroyTranslateContext(STranslateContext* pCxt) { if (NULL != pCxt->pNsLevel) { size_t size = taosArrayGetSize(pCxt->pNsLevel); for (size_t i = 0; i < size; ++i) { - (void)taosArrayDestroy(taosArrayGetP(pCxt->pNsLevel, i)); + taosArrayDestroy(taosArrayGetP(pCxt->pNsLevel, i)); } - (void)taosArrayDestroy(pCxt->pNsLevel); + taosArrayDestroy(pCxt->pNsLevel); } if (NULL != pCxt->pCmdMsg) { @@ -1208,7 +1211,9 @@ static int32_t setColumnInfoByExpr(STempTableNode* pTable, SExprNode* pExpr, SCo SAssociationNode assNode; assNode.pPlace = (SNode**)pColRef; assNode.pAssociationNode = (SNode*)*pColRef; - (void)taosArrayPush(pExpr->pAssociation, &assNode); + if (NULL == taosArrayPush(pExpr->pAssociation, &assNode)) { + return terrno; + } strcpy(pCol->tableAlias, pTable->table.tableAlias); pCol->isPrimTs = isPrimaryKeyImpl((SNode*)pExpr); @@ -3882,7 +3887,7 @@ static int32_t setVnodeSysTableVgroupList(STranslateContext* pCxt, SName* pName, if (TSDB_CODE_SUCCESS == code) { code = toVgroupsInfo(pVgs, &pRealTable->pVgroupList); } - (void)taosArrayDestroy(pVgs); + taosArrayDestroy(pVgs); return code; } @@ -3893,7 +3898,7 @@ static int32_t setDnodeSysTableVgroupList(STranslateContext* pCxt, SName* pName, if (TSDB_CODE_SUCCESS == code) { code = dnodeToVgroupsInfo(pDnodes, &pRealTable->pVgroupList); } - (void)taosArrayDestroy(pDnodes); + taosArrayDestroy(pDnodes); return code; } @@ -3913,7 +3918,7 @@ static int32_t setSuperTableVgroupList(STranslateContext* pCxt, SName* pName, SR if (TSDB_CODE_SUCCESS == code) { code = toVgroupsInfo(vgroupList, &pRealTable->pVgroupList); } - (void)taosArrayDestroy(vgroupList); + taosArrayDestroy(vgroupList); return code; } @@ -4033,7 +4038,10 @@ static int32_t setTableTsmas(STranslateContext* pCxt, SName* pName, SRealTableNo } pVgpsInfo->numOfVgroups = 1; pVgpsInfo->vgroups[0] = vgInfo; - (void)taosArrayPush(pRealTable->tsmaTargetTbVgInfo, &pVgpsInfo); + if (NULL == taosArrayPush(pRealTable->tsmaTargetTbVgInfo, &pVgpsInfo)) { + code = terrno; + break; + } } else { break; } @@ -4062,7 +4070,10 @@ static int32_t setTableTsmas(STranslateContext* pCxt, SName* pName, SRealTableNo // ignore table not exists error code = TSDB_CODE_SUCCESS; } - (void)taosArrayPush(pRealTable->tsmaTargetTbInfo, &ctbInfo); + if (NULL == taosArrayPush(pRealTable->tsmaTargetTbInfo, &ctbInfo)) { + code = terrno; + break; + } } } } @@ -6003,20 +6014,28 @@ static int32_t isOperatorEqTbnameCond(STranslateContext* pCxt, SOperatorNode* pO return TSDB_CODE_SUCCESS; } + char* pTableAlias = NULL; if (LIST_LENGTH(pTbnameFunc->pParameterList) == 0) { - *ppTableAlias = NULL; } else if (LIST_LENGTH(pTbnameFunc->pParameterList) == 1) { SNode* pQualNode = nodesListGetNode(pTbnameFunc->pParameterList, 0); if (nodeType(pQualNode) != QUERY_NODE_VALUE) return false; SValueNode* pQualValNode = (SValueNode*)pQualNode; - *ppTableAlias = pQualValNode->literal; + pTableAlias = pQualValNode->literal; } else { *pRet = false; return TSDB_CODE_SUCCESS; } - *ppTabNames = taosArrayInit(1, sizeof(void*)); - if (!*ppTabNames) return TSDB_CODE_OUT_OF_MEMORY; - (void)taosArrayPush(*ppTabNames, &(pValueNode->literal)); + SArray* pTabNames = NULL; + pTabNames = taosArrayInit(1, sizeof(void*)); + if (!pTabNames) { + return terrno; + } + if (NULL == taosArrayPush(pTabNames, &(pValueNode->literal))) { + taosArrayDestroy(pTabNames); + return terrno; + } + *ppTableAlias = pTableAlias; + *ppTabNames = pTabNames; *pRet = true; return TSDB_CODE_SUCCESS; } @@ -6054,7 +6073,11 @@ static int32_t isOperatorTbnameInCond(STranslateContext* pCxt, SOperatorNode* pO *pRet = false; return TSDB_CODE_SUCCESS; } - (void)taosArrayPush(*ppTbNames, &((SValueNode*)pValNode)->literal); + if (NULL == taosArrayPush(*ppTbNames, &((SValueNode*)pValNode)->literal)) { + taosArrayDestroy(*ppTbNames); + *ppTbNames = NULL; + return terrno; + } } *pRet = true; return TSDB_CODE_SUCCESS; @@ -6082,7 +6105,7 @@ static int32_t findEqCondTbNameInOperatorNode(STranslateContext* pCxt, SNode* pW *pRet = true; return TSDB_CODE_SUCCESS; } - (void)taosArrayDestroy(pInfo->aTbnames); + taosArrayDestroy(pInfo->aTbnames); pInfo->aTbnames = NULL; } *pRet = false; @@ -6116,7 +6139,7 @@ static int32_t findEqualCondTbnameInLogicCondAnd(STranslateContext* pCxt, SNode* break; } } else { - (void)taosArrayDestroy(info.aTbnames); + taosArrayDestroy(info.aTbnames); } } } @@ -6135,7 +6158,7 @@ static int32_t unionEqualCondTbnamesOfSameTable(SArray* aTableTbnames, SEqCondTb code = TSDB_CODE_OUT_OF_MEMORY; break; } - (void)taosArrayDestroy(pInfo->aTbnames); + taosArrayDestroy(pInfo->aTbnames); pInfo->aTbnames = NULL; bFoundTable = true; break; @@ -6175,7 +6198,7 @@ static int32_t findEqualCondTbnameInLogicCondOr(STranslateContext* pCxt, SNode* if (TSDB_CODE_SUCCESS == code && !bAllTbName) { for (int i = 0; i < taosArrayGetSize(aTableTbnames); ++i) { SEqCondTbNameTableInfo* pInfo = taosArrayGet(aTableTbnames, i); - (void)taosArrayDestroy(pInfo->aTbnames); + taosArrayDestroy(pInfo->aTbnames); pInfo->aTbnames = NULL; } taosArrayClear(aTableTbnames); @@ -6338,7 +6361,10 @@ static int32_t setEqualTbnameTableVgroups(STranslateContext* pCxt, SSelectStmt* code = TSDB_CODE_OUT_OF_MEMORY; break; } - (void)taosArrayPush(pTbNames, &pNewTbName); + if (NULL == taosArrayPush(pTbNames, &pNewTbName)) { + code = terrno; + break; + } sprintf(pNewTbName, "%s.%s_%s", pTsma->dbFName, pTsma->name, pTbName); int32_t len = taosCreateMD5Hash(pNewTbName, strlen(pNewTbName)); } @@ -6349,7 +6375,9 @@ static int32_t setEqualTbnameTableVgroups(STranslateContext* pCxt, SSelectStmt* if (TSDB_CODE_SUCCESS == code) { findVgroupsFromEqualTbname(pCxt, pTbNames, pInfo->pRealTable->table.dbName, numOfVgs, vgsInfo); if (vgsInfo->numOfVgroups != 0) { - (void)taosArrayPush(pInfo->pRealTable->tsmaTargetTbVgInfo, &vgsInfo); + if (NULL == taosArrayPush(pInfo->pRealTable->tsmaTargetTbVgInfo, &vgsInfo)) { + code = terrno; + } } else { taosMemoryFree(vgsInfo); } @@ -6378,9 +6406,9 @@ static int32_t setTableVgroupsFromEqualTbnameCond(STranslateContext* pCxt, SSele } for (int i = 0; i < taosArrayGetSize(aTables); ++i) { SEqCondTbNameTableInfo* pInfo = taosArrayGet(aTables, i); - (void)taosArrayDestroy(pInfo->aTbnames); + taosArrayDestroy(pInfo->aTbnames); } - (void)taosArrayDestroy(aTables); + taosArrayDestroy(aTables); return code; } @@ -7980,7 +8008,7 @@ static int32_t columnDefNodeToField(SNodeList* pList, SArray** pArray, bool calB } } if (TSDB_CODE_SUCCESS != code) { - (void)taosArrayDestroy(*pArray); + taosArrayDestroy(*pArray); *pArray = NULL; } return code; @@ -8004,7 +8032,11 @@ static int32_t tagDefNodeToField(SNodeList* pList, SArray** pArray, bool calByte if (pCol->sma) { field.flags |= COL_SMA_ON; } - (void)taosArrayPush(*pArray, &field); + if (NULL == taosArrayPush(*pArray, &field)) { + taosArrayDestroy(*pArray); + *pArray = NULL; + return terrno; + } } return TSDB_CODE_SUCCESS; } @@ -8746,7 +8778,13 @@ static int32_t buildRollupFuncs(SNodeList* pFuncs, SArray** pArray) { *pArray = taosArrayInit(LIST_LENGTH(pFuncs), TSDB_FUNC_NAME_LEN); if (!*pArray) return TSDB_CODE_OUT_OF_MEMORY; SNode* pNode; - FOREACH(pNode, pFuncs) { (void)taosArrayPush(*pArray, ((SFunctionNode*)pNode)->functionName); } + FOREACH(pNode, pFuncs) { + if (NULL == taosArrayPush(*pArray, ((SFunctionNode*)pNode)->functionName)) { + taosArrayDestroy(*pArray); + *pArray = NULL; + return terrno; + } + } return TSDB_CODE_SUCCESS; } @@ -8911,7 +8949,7 @@ static int32_t buildAlterSuperTableReq(STranslateContext* pCxt, SAlterTableStmt* break; } case TSDB_ALTER_TABLE_ADD_COLUMN_WITH_COMPRESS_OPTION: { - (void)taosArrayDestroy(pAlterReq->pFields); + taosArrayDestroy(pAlterReq->pFields); pAlterReq->pFields = taosArrayInit(1, sizeof(SFieldWithOptions)); if (!pAlterReq->pFields) return TSDB_CODE_OUT_OF_MEMORY; @@ -10678,7 +10716,7 @@ static int32_t adjustOrderOfProjections(STranslateContext* pCxt, SNodeList** ppC } if (TSDB_CODE_SUCCESS == code) { - (void)taosArrayDestroy(pProjColPos); + taosArrayDestroy(pProjColPos); nodesDestroyList(*pProjections); nodesDestroyList(*ppCols); *pProjections = pNewProjections; @@ -10790,7 +10828,7 @@ static int32_t adjustOrderOfTags(STranslateContext* pCxt, SNodeList* pTags, cons } if (TSDB_CODE_SUCCESS == code) { - (void)taosArrayDestroy(pTagPos); + taosArrayDestroy(pTagPos); nodesDestroyList(*pTagExprs); *pTagExprs = pNewTagExprs; } else { @@ -13416,7 +13454,7 @@ static void destroyCreateTbReqBatch(void* data) { tdDestroySVCreateTbReq(pTableReq); } - (void)taosArrayDestroy(pTbBatch->req.pArray); + taosArrayDestroy(pTbBatch->req.pArray); } int32_t rewriteToVnodeModifyOpStmt(SQuery* pQuery, SArray* pBufArray) { @@ -13439,7 +13477,7 @@ static void destroyCreateTbReqArray(SArray* pArray) { taosMemoryFreeClear(pVg->pData); taosMemoryFreeClear(pVg); } - (void)taosArrayDestroy(pArray); + taosArrayDestroy(pArray); } static int32_t buildCreateTableDataBlock(int32_t acctId, const SCreateTableStmt* pStmt, const SVgroupInfo* pInfo, @@ -13528,12 +13566,12 @@ static int32_t addCreateTbReqIntoVgroup(SHashObj* pVgroupHashmap, const char* db if (!tBatch.req.pArray) { code = terrno; } else if (NULL == taosArrayPush(tBatch.req.pArray, &req)) { - (void)taosArrayDestroy(tBatch.req.pArray); + taosArrayDestroy(tBatch.req.pArray); code = TSDB_CODE_OUT_OF_MEMORY; } else { code = taosHashPut(pVgroupHashmap, &pVgInfo->vgId, sizeof(pVgInfo->vgId), &tBatch, sizeof(tBatch)); if (TSDB_CODE_SUCCESS != code) { - (void)taosArrayDestroy(tBatch.req.pArray); + taosArrayDestroy(tBatch.req.pArray); } } } else { // add to the correct vgroup @@ -13630,7 +13668,7 @@ static int32_t buildKVRowForBindTags(STranslateContext* pCxt, SCreateSubTableCla taosMemoryFreeClear(p->pData); } } - (void)taosArrayDestroy(pTagArray); + taosArrayDestroy(pTagArray); return code; } @@ -13693,7 +13731,7 @@ static int32_t buildKVRowForAllTags(STranslateContext* pCxt, SCreateSubTableClau taosMemoryFreeClear(p->pData); } } - (void)taosArrayDestroy(pTagArray); + taosArrayDestroy(pTagArray); return code; } @@ -13744,7 +13782,7 @@ static int32_t rewriteCreateSubTable(STranslateContext* pCxt, SCreateSubTableCla taosMemoryFree(pTag); } - (void)taosArrayDestroy(tagName); + taosArrayDestroy(tagName); taosMemoryFreeClear(pSuperTableMeta); return code; } @@ -14151,10 +14189,9 @@ _ERR: return code; } -static int32_t resetParseFileContext(SParseFileContext* pParFileCxt) { +static void resetParseFileContext(SParseFileContext* pParFileCxt) { taosArrayClear(pParFileCxt->aCreateTbData); taosArrayClearEx(pParFileCxt->aTagVals, clearTagValArrayFp); - return TSDB_CODE_SUCCESS; } static int32_t createSubTableFromFile(SMsgBuf* pMsgBuf, SParseContext* pParseCxt, SVnodeModifyOpStmt* pModifyStmt) { @@ -14189,7 +14226,7 @@ static int32_t createSubTableFromFile(SMsgBuf* pMsgBuf, SParseContext* pParseCxt } } - (void)resetParseFileContext(pModifyStmt->pParFileCxt); + resetParseFileContext(pModifyStmt->pParFileCxt); return code; } @@ -14217,7 +14254,7 @@ int32_t serializeVgroupsCreateTableBatch(SHashObj* pVgroupHashmap, SArray** pOut } while (true); if (TSDB_CODE_SUCCESS != code) { - (void)taosArrayDestroy(pBufArray); + taosArrayDestroy(pBufArray); } else { *pOut = pBufArray; } @@ -14343,14 +14380,14 @@ static int32_t addDropTbReqIntoVgroup(SHashObj* pVgroupHashmap, SVgroupInfo* pVg tBatch.info = *pVgInfo; tBatch.req.pArray = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SVDropTbReq)); if (NULL == taosArrayPush(tBatch.req.pArray, pReq)) { - (void)taosArrayDestroy(tBatch.req.pArray); + taosArrayDestroy(tBatch.req.pArray); tBatch.req.pArray = NULL; return TSDB_CODE_OUT_OF_MEMORY; } code = taosHashPut(pVgroupHashmap, &pVgInfo->vgId, sizeof(pVgInfo->vgId), &tBatch, sizeof(tBatch)); if (TSDB_CODE_SUCCESS != code) { - (void)taosArrayDestroy(tBatch.req.pArray); + taosArrayDestroy(tBatch.req.pArray); tBatch.req.pArray = NULL; return code; } @@ -14397,7 +14434,7 @@ over: static void destroyDropTbReqBatch(void* data) { SVgroupDropTableBatch* pTbBatch = (SVgroupDropTableBatch*)data; - (void)taosArrayDestroy(pTbBatch->req.pArray); + taosArrayDestroy(pTbBatch->req.pArray); } static int32_t serializeVgroupDropTableBatch(SVgroupDropTableBatch* pTbBatch, SArray* pBufArray) { @@ -14459,7 +14496,7 @@ int32_t serializeVgroupsDropTableBatch(SHashObj* pVgroupHashmap, SArray** pOut) code = serializeVgroupDropTableBatch(pTbBatch, pBufArray); if (TSDB_CODE_SUCCESS != code) { taosHashCancelIterate(pVgroupHashmap, pTbBatch); - (void)taosArrayDestroy(pBufArray); + taosArrayDestroy(pBufArray); break; } } while (true); @@ -14537,7 +14574,7 @@ static int32_t rewriteDropTable(STranslateContext* pCxt, SQuery* pQuery) { if (TSDB_CODE_SUCCESS == code) { code = buildCmdMsg(pCxt, TDMT_MND_DROP_TB_WITH_TSMA, (FSerializeFunc)tSerializeSMDropTbsReq, &req); } - (void)taosArrayDestroy(req.pVgReqs); + taosArrayDestroy(req.pVgReqs); } taosHashCleanup(pVgroupHashmap); return code; @@ -14902,7 +14939,7 @@ static int32_t buildModifyVnodeArray(STranslateContext* pCxt, SAlterTableStmt* p if (TSDB_CODE_SUCCESS == code) { *pArray = pTmpArray; } else { - (void)taosArrayDestroy(pTmpArray); + taosArrayDestroy(pTmpArray); } return code; @@ -14920,7 +14957,7 @@ static void destoryAlterTbReq(SVAlterTbReq* pReq) { taosMemoryFreeClear(p->pData); } } - (void)taosArrayDestroy(pReq->pTagArray); + taosArrayDestroy(pReq->pTagArray); if (pReq->tagFree) tTagFree((STag*)pReq->pTagVal); } @@ -15005,7 +15042,7 @@ static int32_t serializeFlushDb(SArray* pVgs, SArray** pOutput) { for (int32_t i = 0; i < numOfVgs; ++i) { int32_t code = serializeFlushVgroup((SVgroupInfo*)taosArrayGet(pVgs, i), pBufArray); if (TSDB_CODE_SUCCESS != code) { - (void)taosArrayDestroy(pBufArray); + taosArrayDestroy(pBufArray); return code; } } @@ -15027,9 +15064,9 @@ static int32_t rewriteFlushDatabase(STranslateContext* pCxt, SQuery* pQuery) { code = rewriteToVnodeModifyOpStmt(pQuery, pBufArray); } if (TSDB_CODE_SUCCESS != code) { - (void)taosArrayDestroy(pBufArray); + taosArrayDestroy(pBufArray); } - (void)taosArrayDestroy(pVgs); + taosArrayDestroy(pVgs); return code; } @@ -15662,7 +15699,7 @@ static int32_t toMsgType(ENodeType type) { static int32_t setRefreshMeta(STranslateContext* pCxt, SQuery* pQuery) { if (NULL != pCxt->pDbs) { - (void)taosArrayDestroy(pQuery->pDbList); + taosArrayDestroy(pQuery->pDbList); pQuery->pDbList = taosArrayInit(taosHashGetSize(pCxt->pDbs), TSDB_DB_FNAME_LEN); if (NULL == pQuery->pDbList) { return TSDB_CODE_OUT_OF_MEMORY; @@ -15678,7 +15715,7 @@ static int32_t setRefreshMeta(STranslateContext* pCxt, SQuery* pQuery) { } if (NULL != pCxt->pTables) { - (void)taosArrayDestroy(pQuery->pTableList); + taosArrayDestroy(pQuery->pTableList); pQuery->pTableList = taosArrayInit(taosHashGetSize(pCxt->pTables), sizeof(SName)); if (NULL == pQuery->pTableList) { return TSDB_CODE_OUT_OF_MEMORY; @@ -15694,7 +15731,7 @@ static int32_t setRefreshMeta(STranslateContext* pCxt, SQuery* pQuery) { } if (NULL != pCxt->pTargetTables) { - (void)taosArrayDestroy(pQuery->pTargetTableList); + taosArrayDestroy(pQuery->pTargetTableList); pQuery->pTargetTableList = taosArrayInit(taosHashGetSize(pCxt->pTargetTables), sizeof(SName)); if (NULL == pQuery->pTargetTableList) { return TSDB_CODE_OUT_OF_MEMORY; diff --git a/source/libs/scalar/src/filter.c b/source/libs/scalar/src/filter.c index fb3845c032..382b83012d 100644 --- a/source/libs/scalar/src/filter.c +++ b/source/libs/scalar/src/filter.c @@ -1706,7 +1706,9 @@ EDealRes fltTreeToGroup(SNode *pNode, void *pContext) { cell = cell->pNext; } - (void)taosArrayAddAll(ctx->group, preGroup); + if (NULL == taosArrayAddAll(ctx->group, preGroup)) { + FLT_ERR_JRET(terrno); + } taosArrayDestroy(preGroup); diff --git a/tests/army/frame/taosadapter.py b/tests/army/frame/taosadapter.py index 7830aab08c..e52f555ace 100644 --- a/tests/army/frame/taosadapter.py +++ b/tests/army/frame/taosadapter.py @@ -64,7 +64,7 @@ class TAdapter: "enable" : True }, "node_exporter" : { - "enable" : True + "enable" : False }, "prometheus" : { "enable" : True diff --git a/tests/army/win-test-file b/tests/army/win-test-file new file mode 100644 index 0000000000..b4f5c9312d --- /dev/null +++ b/tests/army/win-test-file @@ -0,0 +1,29 @@ +python3 ./test.py -f multi-level/mlevel_basic.py -N 3 -L 3 -D 2 +python3 ./test.py -f db-encrypt/basic.py +python3 ./test.py -f s3/s3Basic.py -N 3 +python3 ./test.py -f cluster/snapshot.py -N 3 -L 3 -D 2 +python3 ./test.py -f query/function/test_func_elapsed.py +python3 ./test.py -f query/function/concat.py +python3 ./test.py -f query/function/cast.py +python3 ./test.py -f query/test_join.py +python3 ./test.py -f query/test_compare.py +python3 ./test.py -f insert/test_column_tag_boundary.py +python3 ./test.py -f query/fill/fill_desc.py -N 3 -L 3 -D 2 +python3 ./test.py -f query/fill/fill_null.py +python3 ./test.py -f cluster/incSnapshot.py -N 3 +python3 ./test.py -f query/query_basic.py -N 3 +python3 ./test.py -f query/accuracy/test_query_accuracy.py +python3 ./test.py -f insert/insert_basic.py -N 3 +python3 ./test.py -f cluster/splitVgroupByLearner.py -N 3 +python3 ./test.py -f authorith/authBasic.py -N 3 +python3 ./test.py -f cmdline/fullopt.py +python3 ./test.py -f query/show.py -N 3 +python3 ./test.py -f alter/alterConfig.py -N 3 +python3 ./test.py -f query/subquery/subqueryBugs.py -N 3 +python3 ./test.py -f storage/oneStageComp.py -N 3 -L 3 -D 1 +python3 ./test.py -f storage/compressBasic.py -N 3 +python3 ./test.py -f grant/grantBugs.py -N 3 +python3 ./test.py -f query/queryBugs.py -N 3 +python3 ./test.py -f tmq/tmqBugs.py -N 3 +python3 ./test.py -f query/fill/fill_compare_asc_desc.py +python3 ./test.py -f query/last/test_last.py diff --git a/tests/ci/count_assert.py b/tests/ci/count_assert.py index 2b51596403..aecc57578d 100644 --- a/tests/ci/count_assert.py +++ b/tests/ci/count_assert.py @@ -32,7 +32,9 @@ source_dirs = [ # List of directories to exclude exclude_dirs = [ - f"{TD_project_path}/community/source/client/jni" + f"{TD_project_path}/community/source/client/jni", + f"{TD_project_path}/enterprise/src/plugins/taosx", + f"{TD_project_path}/enterprise/src/plugins/explorer", ] # List of files to exclude diff --git a/tests/parallel_test/split_case.sh b/tests/parallel_test/split_case.sh index e237cbf984..3d9bd612d1 100755 --- a/tests/parallel_test/split_case.sh +++ b/tests/parallel_test/split_case.sh @@ -5,20 +5,35 @@ parm_path=$(pwd ${parm_path}) echo "execute path:${parm_path}" cd ${parm_path} cp cases.task ${case_file} -# comment udf and stream case in windows +# comment udf and stream and sma case in windows sed -i '/udf/d' ${case_file} sed -i '/Udf/d' ${case_file} sed -i '/stream/d' ${case_file} sed -i '/^$/d' ${case_file} sed -i '$a\%%FINISHED%%' ${case_file} +#unsupported case:sma +sed -i '/tsim\/sync\/vnodesnapshot-rsma-test.sim/d' ${case_file} +sed -i '/tsim\/sma/d' ${case_file} +sed -i '/tsim\/tagindex\/sma_and_tag_index.sim/d' ${case_file} +#unsupported case:to_char +sed -i '/tsim\/query\/sort-pre-cols.sim/d' ${case_file} +sed -i '/2-query\/nestedQueryInterval.py/d' ${case_file} +#unsupported case:stream +sed -i '/database_pre_suf/d' ${case_file} +sed -i '/tsma/d' ${case_file} + utest="unit-test" tsimtest="script" systest="system-test" devtest="develop-test" doctest="docs-examples-test" -rm -rf win-${utest}.log win-${tsimtest}.log win-${systest}.log win-${devtest}.log win-${doctest}.log -rm -rf ${parm_path}/../${utest}/win-test-file ${parm_path}/../${tsimtest}/win-test-file ${parm_path}/../${systest}/win-test-file ${parm_path}/../${devtest}/win-test-file +armytest="army" + +rm -rf win-${utest}.log win-${tsimtest}.log win-${systest}.log win-${devtest}.log win-${doctest}.log win-${armytest}.log + +rm -rf ${parm_path}/../${utest}/win-test-file ${parm_path}/../${tsimtest}/win-test-file ${parm_path}/../${systest}/win-test-file ${parm_path}/../${devtest}/win-test-file ${parm_path}/../${doctest}/win-test-file ${parm_path}/../${armytest}/win-test-file + while read -r line do echo "$line"|grep -q "^#" @@ -44,6 +59,15 @@ do fi continue fi + if [[ "${exec_dir}" == "${armytest}" ]]; then + if [[ "${case_cmd}" =~ "pytest.sh" ]]; then + case_cmd=$(echo "$case_cmd"|cut -d ' ' -f 2-) + echo "${case_cmd}" >> win-${armytest}.log + else + echo "${case_cmd}" >> win-${armytest}.log + fi + continue + fi if [[ "${exec_dir}" == "${devtest}" ]]; then echo ${case_cmd} >> win-${devtest}.log continue @@ -57,6 +81,7 @@ mv win-${utest}.log ${parm_path}/../${utest}/win-test-file mv win-${tsimtest}.log ${parm_path}/../${tsimtest}/win-test-file mv win-${systest}.log ${parm_path}/../${systest}/win-test-file mv win-${devtest}.log ${parm_path}/../${devtest}/win-test-file - +mv win-${armytest}.log ${parm_path}/../${armytest}/win-test-file +mv win-${doctest}.log ${parm_path}/../${armytest}/win-test-file rm -rf ${case_file} diff --git a/tests/pytest/util/common.py b/tests/pytest/util/common.py index 1141ca403d..1dfcf8b5dd 100644 --- a/tests/pytest/util/common.py +++ b/tests/pytest/util/common.py @@ -979,6 +979,155 @@ class TDCom: for stream_name in stream_name_list: tdSql.execute(f'drop stream if exists {stream_name};') + + def check_stream_wal_info(self, wal_info): + # This method is defined for the 'info' column of the 'information_schema.ins_stream_tasks'. + # Define the regular expression pattern to match the required format + # This pattern looks for a number followed by an optional space and then a pair of square brackets + # containing two numbers separated by a comma. + pattern = r'(\d+)\s*\[(\d+),\s*(\d+)\]' + + # Use the search function from the re module to find a match in the string + match = re.search(pattern, wal_info) + + # Check if a match was found + if match: + # Extract the numbers from the matching groups + first_number = int(match.group(1)) # The number before the brackets + second_number = int(match.group(3)) # The second number inside the brackets + + # Compare the extracted numbers and return the result + if second_number >=5 : + if first_number >= second_number-5 and first_number <= second_number: + return True + elif second_number < 5: + if first_number >= second_number-1 and first_number <= second_number: + return True + + # If no match was found, or the pattern does not match the expected format, return False + return False + + def check_stream_task_status(self, stream_name, vgroups, stream_timeout=None): + """check stream status + + Args: + stream_name (str): stream_name + vgroups (int): vgroups + Returns: + str: status + """ + timeout = self.stream_timeout if stream_timeout is None else stream_timeout + + #check stream task rows + sql_task_all = f"select `task_id`,node_id,stream_name,status,info,history_task_id from information_schema.ins_stream_tasks where stream_name='{stream_name}' and `level`='source';" + sql_task_status = f"select distinct(status) from information_schema.ins_stream_tasks where stream_name='{stream_name}' and `level`='source';" + sql_task_history = f"select distinct(history_task_id) from information_schema.ins_stream_tasks where stream_name='{stream_name}' and `level`='source';" + tdSql.query(sql_task_all) + tdSql.checkRows(vgroups) + + #check stream task status + checktimes = 1 + check_stream_success = 0 + vgroup_num = 0 + while checktimes <= timeout: + tdLog.notice(f"checktimes:{checktimes}") + try: + result_task_alll = tdSql.query(sql_task_all,row_tag=True) + result_task_alll_rows = tdSql.query(sql_task_all) + result_task_status = tdSql.query(sql_task_status,row_tag=True) + result_task_status_rows = tdSql.query(sql_task_status) + result_task_history = tdSql.query(sql_task_history,row_tag=True) + result_task_history_rows = tdSql.query(sql_task_history) + + tdLog.notice(f"Try to check stream status, check times: {checktimes} and stream task list[{check_stream_success}]") + print(f"result_task_status:{result_task_status},result_task_history:{result_task_history},result_task_alll:{result_task_alll}") + if result_task_status_rows == 1 and result_task_status ==[('ready',)] : + if result_task_history_rows == 1 and result_task_history == [(None,)] : + for vgroup_num in range(vgroups): + if self.check_stream_wal_info(result_task_alll[vgroup_num][4]) : + check_stream_success += 1 + tdLog.info(f"check stream task list[{check_stream_success}] sucessfully :") + else: + check_stream_success = 0 + break + + if check_stream_success == vgroups: + break + time.sleep(1) + checktimes += 1 + vgroup_num = vgroup_num + except Exception as e: + tdLog.notice(f"Try to check stream status again, check times: {checktimes}") + checktimes += 1 + tdSql.print_error_frame_info(result_task_alll[vgroup_num],"status is ready,info is finished and history_task_id is NULL",sql_task_all) + else: + checktimes_end = checktimes - 1 + tdLog.notice(f"it has spend {checktimes_end} for checking stream task status but it failed") + if checktimes_end == timeout: + tdSql.print_error_frame_info(result_task_alll[vgroup_num],"status is ready,info is finished and history_task_id is NULL",sql_task_all) + + # def check_stream_task_status(self, stream_name, vgroups, stream_timeout=None): + # """check stream status + + # Args: + # stream_name (str): stream_name + # vgroups (int): vgroups + # Returns: + # str: status + # """ + # timeout = self.stream_timeout if stream_timeout is None else stream_timeout + + # #check stream task rows + # sql_task_all = f"select `task_id`,node_id,stream_name,status,info,history_task_id from information_schema.ins_stream_tasks where stream_name='{stream_name}' and `level`='source';" + # sql_task_status = f"select distinct(status) from information_schema.ins_stream_tasks where stream_name='{stream_name}' and `level`='source';" + # sql_task_history = f"select distinct(history_task_id) from information_schema.ins_stream_tasks where stream_name='{stream_name}' and `level`='source';" + # tdSql.query(sql_task_all) + # tdSql.checkRows(vgroups) + + # #check stream task status + # checktimes = 1 + # check_stream_success = 0 + # vgroup_num = 0 + # while checktimes <= timeout: + # print(f"checktimes:{checktimes}") + # try: + # result_task_alll = tdSql.query(sql_task_all,row_tag=True) + # result_task_alll_rows = tdSql.query(sql_task_all) + # result_task_status = tdSql.query(sql_task_status,row_tag=True) + # result_task_status_rows = tdSql.query(sql_task_status) + # result_task_history = tdSql.query(sql_task_history,row_tag=True) + # result_task_history_rows = tdSql.query(sql_task_history) + + # tdLog.notice(f"Try to check stream status, check times: {checktimes} and stream task list[{check_stream_success}]") + # print(f"result_task_status:{result_task_status},result_task_history:{result_task_history},result_task_alll:{result_task_alll}") + # for vgroup_num in range(vgroups): + # if result_task_alll[vgroup_num][3] == "ready" and self.check_stream_wal_info(result_task_alll[vgroup_num][4]) and result_task_alll[vgroup_num][5] == None: + # check_stream_success += 1 + # tdLog.info(f"check stream task list[{check_stream_success}] sucessfully :") + # else: + # check_stream_success = 0 + # break + + # if check_stream_success == vgroups: + # break + # time.sleep(1) + # checktimes += 1 + # vgroup_num = vgroup_num + # except Exception as e: + # tdLog.notice(f"Try to check stream status again, check times: {checktimes}") + # checktimes += 1 + # tdSql.print_error_frame_info(result_task_alll[vgroup_num],"status is ready,info is finished and history_task_id is NULL",sql_task_all) + + # else: + # checktimes_end = checktimes - 1 + # tdLog.notice(f"it has spend {checktimes_end} for checking stream task status but it failed") + # if checktimes_end == timeout: + # tdSql.print_error_frame_info(result_task_alll[vgroup_num],"status is ready,info is finished and history_task_id is NULL",sql_task_all) + + + + + def drop_db(self, dbname="test"): """drop a db diff --git a/tests/pytest/util/sql.py b/tests/pytest/util/sql.py index 7f6b129bb9..90d3f2fe6c 100644 --- a/tests/pytest/util/sql.py +++ b/tests/pytest/util/sql.py @@ -61,6 +61,13 @@ class TDSql: def close(self): self.cursor.close() + def print_error_frame_info(self, elm, expect_elm, sql=None): + caller = inspect.getframeinfo(inspect.stack()[1][0]) + print_sql = self.sql if sql is None else sql + args = (caller.filename, caller.lineno, print_sql, elm, expect_elm) + # tdLog.info("%s(%d) failed: sql:%s, elm:%s != expect_elm:%s" % args) + raise Exception("%s(%d) failed: sql:%s, elm:%s != expect_elm:%s" % args) + def prepare(self, dbname="db", drop=True, **kwargs): tdLog.info(f"prepare database:{dbname}") s = 'reset query cache' @@ -331,13 +338,14 @@ class TDSql: return self.queryRows def checkRows(self, expectedRows): - if self.queryRows == expectedRows: - tdLog.info("sql:%s, queryRows:%d == expect:%d" % (self.sql, self.queryRows, expectedRows)) - return True - else: - caller = inspect.getframeinfo(inspect.stack()[1][0]) - args = (caller.filename, caller.lineno, self.sql, self.queryRows, expectedRows) - tdLog.exit("%s(%d) failed: sql:%s, queryRows:%d != expect:%d" % args) + return self.checkEqual(self.queryRows, expectedRows) + # if self.queryRows == expectedRows: + # tdLog.info("sql:%s, queryRows:%d == expect:%d" % (self.sql, self.queryRows, expectedRows)) + # return True + # else: + # caller = inspect.getframeinfo(inspect.stack()[1][0]) + # args = (caller.filename, caller.lineno, self.sql, self.queryRows, expectedRows) + # tdLog.exit("%s(%d) failed: sql:%s, queryRows:%d != expect:%d" % args) def checkRows_not_exited(self, expectedRows): """ @@ -636,16 +644,12 @@ class TDSql: def checkEqual(self, elm, expect_elm): if elm == expect_elm: tdLog.info("sql:%s, elm:%s == expect_elm:%s" % (self.sql, elm, expect_elm)) - return + return True if self.__check_equal(elm, expect_elm): tdLog.info("sql:%s, elm:%s == expect_elm:%s" % (self.sql, elm, expect_elm)) - return - - caller = inspect.getframeinfo(inspect.stack()[1][0]) - args = (caller.filename, caller.lineno, self.sql, elm, expect_elm) - # tdLog.info("%s(%d) failed: sql:%s, elm:%s != expect_elm:%s" % args) - raise Exception("%s(%d) failed: sql:%s, elm:%s != expect_elm:%s" % args) - + return True + self.print_error_frame_info(elm, expect_elm) + def checkNotEqual(self, elm, expect_elm): if elm != expect_elm: tdLog.info("sql:%s, elm:%s != expect_elm:%s" % (self.sql, elm, expect_elm)) diff --git a/tests/script/sh/checkAsan.sh b/tests/script/sh/checkAsan.sh index aa73d4cb23..7cba62560d 100755 --- a/tests/script/sh/checkAsan.sh +++ b/tests/script/sh/checkAsan.sh @@ -97,6 +97,6 @@ else if [ $python_error -ne 0 ] || [ $python_taos_error -ne 0 ] ; then cat ${LOG_DIR}/*.info |grep "#" | grep -w "TDinternal" fi - cat ${LOG_DIR}/*.asan + cat ${LOG_DIR}/*.asan |grep "#" | grep -w "TDinternal" exit 1 fi \ No newline at end of file diff --git a/tests/script/sh/stop_dnodes.bat b/tests/script/sh/stop_dnodes.bat index 65aee26ed4..6b82fb4d1d 100644 --- a/tests/script/sh/stop_dnodes.bat +++ b/tests/script/sh/stop_dnodes.bat @@ -4,5 +4,5 @@ rem echo taskkill /F /IM taosd.exe wmic process where "name='taosd.exe'" call terminate > NUL 2>&1 taskkill /F /IM taosd.exe > NUL 2>&1 - +sleep 2 rem echo taskkill /F /IM taosd.exe finished \ No newline at end of file diff --git a/tests/script/sh/stop_dnodes.sh b/tests/script/sh/stop_dnodes.sh index b447a7325e..c462442fa2 100755 --- a/tests/script/sh/stop_dnodes.sh +++ b/tests/script/sh/stop_dnodes.sh @@ -15,42 +15,42 @@ fi PID=`ps -ef|grep -w taosd | grep -v grep | awk '{print $2}'` while [ -n "$PID" ]; do - echo kill -15 $PID - #pkill -15 taosd - kill -15 $PID + echo kill -9 $PID + #pkill -9 taosd + kill -9 $PID echo "Killing taosd processes" if [ "$OS_TYPE" != "Darwin" ]; then fuser -k -n tcp 6030 else - lsof -nti:6030 | xargs kill -15 + lsof -nti:6030 | xargs kill -9 fi PID=`ps -ef|grep -w taosd | grep -v grep | awk '{print $2}'` done PID=`ps -ef|grep -w taos | grep -v grep | awk '{print $2}'` while [ -n "$PID" ]; do - echo kill -15 $PID + echo kill -9 $PID #pkill -9 taos - kill -15 $PID + kill -9 $PID echo "Killing taos processes" if [ "$OS_TYPE" != "Darwin" ]; then fuser -k -n tcp 6030 else - lsof -nti:6030 | xargs kill -15 + lsof -nti:6030 | xargs kill -9 fi PID=`ps -ef|grep -w taos | grep -v grep | awk '{print $2}'` done PID=`ps -ef|grep -w tmq_sim | grep -v grep | awk '{print $2}'` while [ -n "$PID" ]; do - echo kill -15 $PID - #pkill -15 tmq_sim - kill -15 $PID + echo kill -9 $PID + #pkill -9 tmq_sim + kill -9 $PID echo "Killing tmq_sim processes" if [ "$OS_TYPE" != "Darwin" ]; then fuser -k -n tcp 6030 else - lsof -nti:6030 | xargs kill -15 + lsof -nti:6030 | xargs kill -9 fi PID=`ps -ef|grep -w tmq_sim | grep -v grep | awk '{print $2}'` done \ No newline at end of file diff --git a/tests/script/tsim/query/sys_tbname.sim b/tests/script/tsim/query/sys_tbname.sim index 7739ea5373..dabe4fcdde 100644 --- a/tests/script/tsim/query/sys_tbname.sim +++ b/tests/script/tsim/query/sys_tbname.sim @@ -308,4 +308,4 @@ if $rows != 2 then return -1 endi -#system sh/exec.sh -n dnode1 -s stop -x SIGINT +system sh/exec.sh -n dnode1 -s stop -x SIGINT diff --git a/tests/script/win-test-file b/tests/script/win-test-file index 8c96722c9f..ff69e91967 100644 --- a/tests/script/win-test-file +++ b/tests/script/win-test-file @@ -200,7 +200,6 @@ ./test.sh -f tsim/query/unionall_as_table.sim ./test.sh -f tsim/query/multi_order_by.sim ./test.sh -f tsim/query/sys_tbname.sim -./test.sh -f tsim/query/sort-pre-cols.sim ./test.sh -f tsim/query/groupby.sim ./test.sh -f tsim/query/groupby_distinct.sim ./test.sh -f tsim/query/event.sim @@ -289,12 +288,6 @@ ./test.sh -f tsim/stable/tag_rename.sim ./test.sh -f tsim/stable/values.sim ./test.sh -f tsim/stable/vnode3.sim -./test.sh -f tsim/sma/drop_sma.sim -./test.sh -f tsim/sma/sma_leak.sim -./test.sh -f tsim/sma/tsmaCreateInsertQuery.sim -./test.sh -f tsim/sma/rsmaCreateInsertQuery.sim -./test.sh -f tsim/sma/rsmaCreateInsertQueryDelete.sim -./test.sh -f tsim/sync/vnodesnapshot-rsma-test.sim ./test.sh -f tsim/valgrind/checkError1.sim ./test.sh -f tsim/valgrind/checkError2.sim ./test.sh -f tsim/valgrind/checkError3.sim @@ -406,7 +399,6 @@ ./test.sh -f tsim/tag/tbNameIn.sim ./test.sh -f tmp/monitor.sim ./test.sh -f tsim/tagindex/add_index.sim -./test.sh -f tsim/tagindex/sma_and_tag_index.sim ./test.sh -f tsim/tagindex/indexOverflow.sim ./test.sh -f tsim/view/view.sim ./test.sh -f tsim/query/cache_last.sim diff --git a/tests/system-test/0-others/backquote_check.py b/tests/system-test/0-others/backquote_check.py index 2858373ced..8cb268fb3d 100644 --- a/tests/system-test/0-others/backquote_check.py +++ b/tests/system-test/0-others/backquote_check.py @@ -42,19 +42,19 @@ class TDTestCase: type = 'stable' tdSql.execute(f'create topic if not exists {name} as {type} {name}') tdSql.query('show topics') - tdSql.checkEqual(tdSql.queryResult[0][0],name) + tdSql.checkData(0, 0, name) tdSql.execute(f'drop topic {name}') tdSql.execute(f'create topic if not exists `{name}` as {type} {name}') tdSql.query('show topics') - tdSql.checkEqual(tdSql.queryResult[0][0],name) + tdSql.checkData(0, 0, name) tdSql.execute(f'drop topic {name}') tdSql.execute(f'create topic if not exists `{name}` as {type} `{name}`') tdSql.query('show topics') - tdSql.checkEqual(tdSql.queryResult[0][0],name) + tdSql.checkData(0, 0, name) tdSql.execute(f'drop topic {name}') tdSql.execute(f'create topic if not exists `{name}` as {type} `{name}`') tdSql.query('show topics') - tdSql.checkEqual(tdSql.queryResult[0][0],name) + tdSql.checkData(0, 0, name) tdSql.execute(f'drop topic `{name}`') def db_name_check(self): @@ -70,14 +70,14 @@ class TDTestCase: time.sleep(15) tdSql.query('show streams') - tdSql.checkEqual(tdSql.queryResult[0][0],self.streamname) + tdSql.checkData(0, 0, self.streamname) tdSql.execute(f'drop stream {self.streamname}') tdSql.execute(f'drop stable {self.streamtb}') tdSql.execute(f'create stream {self.streamname} into `{self.streamtb}` as select count(*) from {self.stbname} interval(10s);') time.sleep(10) tdSql.query('show streams') - tdSql.checkEqual(tdSql.queryResult[0][0],self.streamname) + tdSql.checkData(0, 0, self.streamname) tdSql.execute(f'drop stream `{self.streamname}`') tdSql.execute(f'drop database {self.dbname}') @@ -89,17 +89,17 @@ class TDTestCase: tdSql.execute(f'insert into {self.ntbname1} values(now(),1,1)') tdSql.execute(f'insert into {self.ntbname2} values(now(),2,2)') tdSql.query(f'select `{self.ntbname1}`.`c0`, `{self.ntbname1}`.`c1` from `{self.ntbname1}`') - tdSql.checkEqual(tdSql.queryResult[0][0], 1) + tdSql.checkData(0, 0, 1) tdSql.query(f'select `{self.ntbname1}`.`c0`, `{self.ntbname1}`.`c1` from `{self.dbname}`.`{self.ntbname1}`') - tdSql.checkEqual(tdSql.queryResult[0][0], 1) + tdSql.checkData(0, 0, 1) tdSql.query(f'select `{self.ntbname1}`.`c0` from `{self.ntbname2}` `{self.ntbname1}`') - tdSql.checkEqual(tdSql.queryResult[0][0], 2) + tdSql.checkData(0, 0, 2) tdSql.query(f'select `{self.ntbname1}`.`c0` from (select * from `{self.ntbname2}`) `{self.ntbname1}`') - tdSql.checkEqual(tdSql.queryResult[0][0], 2) + tdSql.checkData(0, 0, 2) # select `t1`.`col1`, `col2`, `col3` from (select ts `col1`, 123 `col2`, c0 + c1 as `col3` from t2) `t1`; tdSql.query(f'select `{self.ntbname1}`.`col1`, `col2`, `col3` from (select ts `col1`, 123 `col2`, c0 + c1 as `col3` from {self.ntbname2}) `{self.ntbname1}`') - tdSql.checkEqual(tdSql.queryResult[0][1], 123) - tdSql.checkEqual(tdSql.queryResult[0][2], 4) + tdSql.checkData(0, 1, 123) + tdSql.checkData(0, 2, 4) # tdSql.execute(f'drop database {self.dbname}') @@ -117,15 +117,15 @@ class TDTestCase: tdSql.query(f'select `t1`.`ts`, `t1`.`c0` + `t2`.`c0` as `c0`, `t1`.`c1` * `t2`.`c1` as `c1` from `{self.ntbname1}` `t1` join `{self.ntbname2}` `t2` on timetruncate(`t1`.`ts`, 1s) = timetruncate(`t2`.`ts`, 1s);') tdSql.checkRows(1) - tdSql.checkEqual(tdSql.queryResult[0][1], 3) + tdSql.checkData(0, 1, 3) tdSql.query(f'select `t1`.`ts`, `t1`.`c1`, `t1`.`c2` from (select `ts`, `c0` + 1 as `c1`, `c1` + 2 as `c2` from `{self.ntbname1}`) `t1`;') - tdSql.checkEqual(tdSql.queryResult[0][1], 2) - tdSql.checkEqual(tdSql.queryResult[0][2], 3) + tdSql.checkData(0, 1, 2) + tdSql.checkData(0, 2, 3) tdSql.query(f'select `t`.`ts`, cast(`t`.`v1` as int) + `t`.`c0` as `v` from (select `ts`, "12" as `v1`, `c0`, `c1` from `ntb1`) `t`;') tdSql.checkRows(1) - tdSql.checkEqual(tdSql.queryResult[0][1], 13) + tdSql.checkData(0, 1, 13) tdSql.query(f'select count(`t1`.`ts`) from (select `t`.`ts` from `{self.ntbname1}` `t`) `t1`;') tdSql.checkRows(1) @@ -133,7 +133,8 @@ class TDTestCase: def run(self): self.topic_name_check() self.db_name_check() - self.stream_name_check() + if platform.system().lower() == 'windows': + self.stream_name_check() self.table_name_check() self.view_name_check() self.query_check() diff --git a/tests/system-test/0-others/splitVGroup.py b/tests/system-test/0-others/splitVGroup.py index c49713fc6d..df52828a6e 100644 --- a/tests/system-test/0-others/splitVGroup.py +++ b/tests/system-test/0-others/splitVGroup.py @@ -16,7 +16,7 @@ import random import time import copy import string - +import platform import taos from util.log import * from util.cases import * @@ -380,14 +380,15 @@ class TDTestCase: # forbid def checkForbid(self): # stream - tdLog.info("check forbid split having stream...") - tdSql.execute("create database streamdb;") - tdSql.execute("use streamdb;") - tdSql.execute("create table ta(ts timestamp, age int);") - tdSql.execute("create stream ma into sta as select count(*) from ta interval(1s);") - self.expectSplitError("streamdb") - tdSql.execute("drop stream ma;") - self.expectSplitOk("streamdb") + if platform.system().lower() != 'windows': + tdLog.info("check forbid split having stream...") + tdSql.execute("create database streamdb;") + tdSql.execute("use streamdb;") + tdSql.execute("create table ta(ts timestamp, age int);") + tdSql.execute("create stream ma into sta as select count(*) from ta interval(1s);") + self.expectSplitError("streamdb") + tdSql.execute("drop stream ma;") + self.expectSplitOk("streamdb") # topic tdLog.info("check forbid split having topic...") diff --git a/tests/system-test/0-others/splitVGroupWal.py b/tests/system-test/0-others/splitVGroupWal.py index d11d63b5a9..ecffd0f7c6 100644 --- a/tests/system-test/0-others/splitVGroupWal.py +++ b/tests/system-test/0-others/splitVGroupWal.py @@ -16,7 +16,7 @@ import random import time import copy import string - +import platform import taos from util.log import * from util.cases import * @@ -380,14 +380,15 @@ class TDTestCase: # forbid def checkForbid(self): # stream - tdLog.info("check forbid split having stream...") - tdSql.execute("create database streamdb;") - tdSql.execute("use streamdb;") - tdSql.execute("create table ta(ts timestamp, age int);") - tdSql.execute("create stream ma into sta as select count(*) from ta interval(1s);") - self.expectSplitError("streamdb") - tdSql.execute("drop stream ma;") - self.expectSplitOk("streamdb") + if platform.system().lower() != 'windows': + tdLog.info("check forbid split having stream...") + tdSql.execute("create database streamdb;") + tdSql.execute("use streamdb;") + tdSql.execute("create table ta(ts timestamp, age int);") + tdSql.execute("create stream ma into sta as select count(*) from ta interval(1s);") + self.expectSplitError("streamdb") + tdSql.execute("drop stream ma;") + self.expectSplitOk("streamdb") # topic tdLog.info("check forbid split having topic...") diff --git a/tests/system-test/0-others/taosdShell.py b/tests/system-test/0-others/taosdShell.py index 3d1162c370..9b0628ec12 100644 --- a/tests/system-test/0-others/taosdShell.py +++ b/tests/system-test/0-others/taosdShell.py @@ -154,7 +154,10 @@ class TDTestCase: tdSql.query("use source_db") tdSql.query("create table if not exists source_db.stb (ts timestamp, k int) tags (a int);") tdSql.query("create table source_db.ct1 using source_db.stb tags(1000);create table source_db.ct2 using source_db.stb tags(2000);create table source_db.ct3 using source_db.stb tags(3000);") - tdSql.query("create stream s1 into source_db.output_stb as select _wstart AS startts, min(k), max(k), sum(k) from source_db.stb interval(10m);") + if platform.system().lower() == 'windows': + pass + else: + tdSql.query("create stream s1 into source_db.output_stb as select _wstart AS startts, min(k), max(k), sum(k) from source_db.stb interval(10m);") #TD-19944 -Q=3 diff --git a/tests/system-test/1-insert/alter_database.py b/tests/system-test/1-insert/alter_database.py index e3ff797baa..f58bb7517e 100644 --- a/tests/system-test/1-insert/alter_database.py +++ b/tests/system-test/1-insert/alter_database.py @@ -17,7 +17,10 @@ class TDTestCase: self.replicaVar = int(replicaVar) tdLog.debug("start to execute %s" % __file__) tdSql.init(conn.cursor(), logSql) - self.buffer_boundary = [3, 4097, 8193, 12289, 16384] + if platform.system().lower() == 'windows': + self.buffer_boundary = [3, 4097] + else: + self.buffer_boundary = [3, 4097, 8193, 12289, 16384] # remove the value > free_memory, 70% is the weight to calculate the max value # if platform.system() == "Linux" and platform.machine() == "aarch64": # mem = psutil.virtual_memory() diff --git a/tests/system-test/1-insert/database_pre_suf.py b/tests/system-test/1-insert/database_pre_suf.py index 2e993b9a40..2bef94081e 100755 --- a/tests/system-test/1-insert/database_pre_suf.py +++ b/tests/system-test/1-insert/database_pre_suf.py @@ -22,6 +22,7 @@ from util.cases import tdCases from util.sql import tdSql from util.dnodes import tdDnodes from util.dnodes import * +from util.common import * class TDTestCase: updatecfgDict = {'maxSQLLength':1048576,'debugFlag': 135} @@ -158,7 +159,8 @@ class TDTestCase: fake.pystr() ,fake.pystr() ,fake.pyfloat(),fake.pyfloat(),fake.random_int(min=-2147483647, max=2147483647, step=1))) # create stream - tdSql.execute('''create stream current_stream trigger at_once IGNORE EXPIRED 0 into stream_max_stable_1 as select _wstart as startts, _wend as wend, max(q_int) as max_int, min(q_bigint) as min_int from stable_1 where ts is not null interval (5s);''') + stream_name="current_stream" + tdSql.execute(f'''create stream {stream_name} trigger at_once IGNORE EXPIRED 0 into stream_max_stable_1 as select _wstart as startts, _wend as wend, max(q_int) as max_int, min(q_bigint) as min_int from stable_1 where ts is not null interval (5s);''') # insert data positive for i in range(num_random*n): @@ -287,8 +289,8 @@ class TDTestCase: tdSql.query("select count(*) from hn_table_1_r;") tdSql.checkData(0,0,num_random*n) - sleep(5) # stream data check + tdCom.check_stream_task_status(stream_name,vgroups,90) tdSql.query("select startts,wend,max_int from stream_max_stable_1 ;") tdSql.checkRows(20) tdSql.query("select sum(max_int) from stream_max_stable_1 ;") diff --git a/tests/system-test/1-insert/drop.py b/tests/system-test/1-insert/drop.py index b467276fce..bd5e4cab49 100644 --- a/tests/system-test/1-insert/drop.py +++ b/tests/system-test/1-insert/drop.py @@ -162,7 +162,8 @@ class TDTestCase: self.drop_ntb_check() self.drop_stb_ctb_check() self.drop_topic_check() - self.drop_stream_check() + if platform.system().lower() == 'windows': + self.drop_stream_check() pass def stop(self): tdSql.close() diff --git a/tests/system-test/1-insert/precisionNS.py b/tests/system-test/1-insert/precisionNS.py index 3de60b718a..8302f6ed28 100644 --- a/tests/system-test/1-insert/precisionNS.py +++ b/tests/system-test/1-insert/precisionNS.py @@ -14,7 +14,7 @@ import sys import random import time - +import platform import taos from util.log import * from util.cases import * @@ -149,9 +149,10 @@ class TDTestCase: tdSql.execute(sql) # create stream - sql = "create stream ma into sta as select count(ts) from st interval(100b)" - tdLog.info(sql) - tdSql.execute(sql) + if platform.system().lower() != 'windows': + sql = "create stream ma into sta as select count(ts) from st interval(100b)" + tdLog.info(sql) + tdSql.execute(sql) # insert data self.insertData() @@ -315,7 +316,8 @@ class TDTestCase: self.checkWhere() # check stream - self.checkStream() + if platform.system().lower() != 'windows': + self.checkStream() # stop def stop(self): diff --git a/tests/system-test/1-insert/precisionUS.py b/tests/system-test/1-insert/precisionUS.py index 25171ddd88..bce51dddb2 100644 --- a/tests/system-test/1-insert/precisionUS.py +++ b/tests/system-test/1-insert/precisionUS.py @@ -14,7 +14,7 @@ import sys import random import time - +import platform import taos from util.log import * from util.cases import * @@ -149,9 +149,10 @@ class TDTestCase: tdSql.execute(sql) # create stream - sql = "create stream ma into sta as select count(ts) from st interval(100u)" - tdLog.info(sql) - tdSql.execute(sql) + if platform.system().lower() != 'windows': + sql = "create stream ma into sta as select count(ts) from st interval(100u)" + tdLog.info(sql) + tdSql.execute(sql) # insert data self.insertData() @@ -289,7 +290,8 @@ class TDTestCase: self.checkWhere() # check stream - self.checkStream() + if platform.system().lower() != 'windows': + self.checkStream() # stop def stop(self): diff --git a/tests/system-test/1-insert/ts-4272.py b/tests/system-test/1-insert/ts-4272.py index f2bacd0c2b..4aaab11346 100644 --- a/tests/system-test/1-insert/ts-4272.py +++ b/tests/system-test/1-insert/ts-4272.py @@ -25,7 +25,9 @@ class TDTestCase: self.tag2 = f'using {self.stable0}(groupId) tags(2)' self.file1 = f"{self.testcasePath}/b.csv" self.file2 = f"{self.testcasePath}/c.csv" - + if platform.system().lower() == 'windows': + self.file1 = self.file1.replace("\\","\\\\") + self.file2 = self.file2.replace("\\","\\\\") tdLog.debug(f"start to excute {__file__}") tdSql.init(conn.cursor(), logSql) diff --git a/tests/system-test/2-query/last+last_row.py b/tests/system-test/2-query/last+last_row.py index 1ee1b4afa7..e1b4fe68dd 100644 --- a/tests/system-test/2-query/last+last_row.py +++ b/tests/system-test/2-query/last+last_row.py @@ -56,26 +56,33 @@ class TDTestCase(TDTestCase): def check_sql_result_include(self, sql,include_result): - result = os.popen("taos -s 'reset query cache; %s'" %sql) + result = os.popen(f"taos -s \"reset query cache; {sql}\"" ) res = result.read() - #tdLog.info(res) - if (include_result in res): - tdLog.info(f"check_sql_result_include : checkEqual success") - else : - tdLog.info(res) + if res is None or res == '': tdLog.info(sql) - tdLog.exit(f"check_sql_result_include : checkEqual error") + tdLog.exit(f"check_sql_result_include : taos -s return null") + else: + if (include_result in res): + tdLog.info(f"check_sql_result_include : checkEqual success") + else : + tdLog.info(res) + tdLog.info(sql) + tdLog.exit(f"check_sql_result_include : checkEqual error") def check_sql_result_not_include(self, sql,not_include_result): - result = os.popen("taos -s 'reset query cache; %s'" %sql) + result = os.popen(f"taos -s \"reset query cache; {sql}\"" ) res = result.read() #tdLog.info(res) - if (not_include_result in res): - tdLog.info(res) + if res is None or res == '': tdLog.info(sql) - tdLog.exit(f"check_sql_result_not_include : checkEqual error") - else : - tdLog.info(f"check_sql_result_not_include : checkEqual success") + tdLog.exit(f"check_sql_result_not_include : taos -s return null") + else: + if (not_include_result in res): + tdLog.info(res) + tdLog.info(sql) + tdLog.exit(f"check_sql_result_not_include : checkEqual error") + else : + tdLog.info(f"check_sql_result_not_include : checkEqual success") def cachemodel_none(self, dbname="nested"): @@ -325,6 +332,7 @@ class TDTestCase(TDTestCase): for i in range(2): self.cachemodel_none() + tdLog.info("last_row") tdSql.query("alter database nested cachemodel 'last_row' ") tdSql.query("reset query cache;") self.cachemodel_last_row() diff --git a/tests/system-test/7-tmq/tmq3mnodeSwitch.py b/tests/system-test/7-tmq/tmq3mnodeSwitch.py index 8c5dc5e693..17eed3bd5c 100644 --- a/tests/system-test/7-tmq/tmq3mnodeSwitch.py +++ b/tests/system-test/7-tmq/tmq3mnodeSwitch.py @@ -65,9 +65,12 @@ class TDTestCase: while count < self.mnodeCheckCnt: time.sleep(1) tdSql.query("select * from information_schema.ins_mnodes;") + rst = tdSql.checkRows(self.mnodes) + print(f"rst: {rst}") if tdSql.checkRows(self.mnodes) : tdLog.debug("mnode is three nodes") else: + tdSql.print_error_frame_info(tdSql.queryRows,3) tdLog.exit("mnode number is correct") roleOfMnode0 = tdSql.queryResult[0][self.roleIndex] diff --git a/tests/system-test/failed.txt b/tests/system-test/failed.txt index 59c4d625d9..d34f8b7fb5 100644 --- a/tests/system-test/failed.txt +++ b/tests/system-test/failed.txt @@ -1,2 +1,19 @@ -#python3 ./test.py -f 2-query/last.py -Q 3 -#./test.sh -f tsim/mnode/basic4.sim +python3 ./test.py -f 2-query/match.py +python3 ./test.py -f 0-others/splitVGroup.py -N 3 -n 1 +python3 ./test.py -f 2-query/tsma.py +python3 ./test.py -f 2-query/tsma2.py +python3 ./test.py -f 1-insert/database_pre_suf.py +python3 ./test.py -f 0-others/splitVGroup.py -N 3 -n 1 +python3 ./test.py -f 0-others/splitVGroupWal.py -N 3 -n 1 +python3 ./test.py -f 0-others/delete_check.py +python3 ./test.py -f 1-insert/alter_database.py +python3 ./test.py -f 1-insert/db_tb_name_check.py +python3 ./test.py -f 1-insert/precisionUS.py +python3 ./test.py -f 1-insert/precisionNS.py +python3 ./test.py -f 1-insert/ts-4272.py +python3 ./test.py -f 2-query/last+last_row.py +python3 ./test.py -f 2-query/normal.py +python3 ./test.py -f 2-query/To_iso8601.py +python3 ./test.py -f 2-query/normal.py +python3 ./test.py -f 5-taos-tools/taosbenchmark/insertMix.py -N 3 +python3 ./test.py -f 7-tmq/tmq_taosx.py \ No newline at end of file diff --git a/tests/system-test/test.py b/tests/system-test/test.py index ad5e1a06f3..9defcd083a 100644 --- a/tests/system-test/test.py +++ b/tests/system-test/test.py @@ -44,7 +44,7 @@ def checkRunTimeError(): time.sleep(1) timeCount = timeCount + 1 print("checkRunTimeError",timeCount) - if (timeCount>600): + if (timeCount>1200): print("stop the test.") os.system("TASKKILL /F /IM taosd.exe") os.system("TASKKILL /F /IM taos.exe") diff --git a/tests/system-test/win-test-file b/tests/system-test/win-test-file index 41eb28e071..1f2b3f476c 100644 --- a/tests/system-test/win-test-file +++ b/tests/system-test/win-test-file @@ -104,7 +104,6 @@ python3 ./test.py -f 2-query/insert_null_none.py -R python3 ./test.py -f 2-query/insert_null_none.py -Q 2 python3 ./test.py -f 2-query/insert_null_none.py -Q 3 python3 ./test.py -f 2-query/insert_null_none.py -Q 4 -python3 ./test.py -f 1-insert/database_pre_suf.py python3 ./test.py -f 2-query/concat.py -Q 3 python3 ./test.py -f 2-query/out_of_order.py -Q 2 python3 ./test.py -f 2-query/out_of_order.py -Q 4 @@ -572,7 +571,6 @@ python3 ./test.py -f 2-query/join2.py python3 ./test.py -f 2-query/union1.py python3 ./test.py -f 2-query/concat2.py python3 ./test.py -f 2-query/json_tag.py -python3 ./test.py -f 2-query/nestedQueryInterval.py python3 ./test.py -f 2-query/systable_func.py python3 ./test.py -f 2-query/test_ts4382.py python3 ./test.py -f 2-query/test_ts4403.py @@ -687,7 +685,6 @@ python3 ./test.py -f 2-query/arctan.py -Q 2 python3 ./test.py -f 2-query/query_cols_tags_and_or.py -Q 2 python3 ./test.py -f 2-query/interp.py -Q 2 python3 ./test.py -f 2-query/fill.py -Q 2 -python3 ./test.py -f 2-query/nestedQueryInterval.py -Q 2 python3 ./test.py -f 2-query/stablity.py -Q 2 python3 ./test.py -f 2-query/stablity_1.py -Q 2 python3 ./test.py -f 2-query/avg.py -Q 2 @@ -783,7 +780,6 @@ python3 ./test.py -f 2-query/arcsin.py -Q 3 python3 ./test.py -f 2-query/arccos.py -Q 3 python3 ./test.py -f 2-query/arctan.py -Q 3 python3 ./test.py -f 2-query/query_cols_tags_and_or.py -Q 3 -python3 ./test.py -f 2-query/nestedQueryInterval.py -Q 3 python3 ./test.py -f 2-query/stablity.py -Q 3 python3 ./test.py -f 2-query/stablity_1.py -Q 3 python3 ./test.py -f 2-query/avg.py -Q 3 @@ -881,7 +877,6 @@ python3 ./test.py -f 2-query/arcsin.py -Q 4 python3 ./test.py -f 2-query/arccos.py -Q 4 python3 ./test.py -f 2-query/arctan.py -Q 4 python3 ./test.py -f 2-query/query_cols_tags_and_or.py -Q 4 -python3 ./test.py -f 2-query/nestedQueryInterval.py -Q 4 python3 ./test.py -f 2-query/stablity.py -Q 4 python3 ./test.py -f 2-query/stablity_1.py -Q 4 python3 ./test.py -f 2-query/avg.py -Q 4 @@ -914,7 +909,6 @@ python3 ./test.py -f 2-query/last_row.py -Q 4 python3 ./test.py -f 2-query/tsbsQuery.py -Q 4 python3 ./test.py -f 2-query/sml.py -Q 4 python3 ./test.py -f 2-query/interp.py -Q 4 -python3 ./test.py -f 2-query/fill.py -Q 4 python3 ./test.py -f 2-query/case_when.py -Q 4 python3 ./test.py -f 2-query/insert_select.py python3 ./test.py -f 2-query/insert_select.py -R