xxq250
/
homework-jianmu
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Merge pull request #27658 from taosdata/enh/TD-31803-6 

enh: error handle in message encode and decode
This commit is contained in:
Hongze Cheng 2024-09-04 14:58:33 +08:00 committed by GitHub
parent abfa7a1279 e3ded1cf75
commit fccb0806c2
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
1 changed files with 344 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

610
source/common/src/tmsg.c
View File

@ -5180,25 +5180,33 @@ int32_t tSerializeSTableIndexInfo(SEncoder *pEncoder, STableIndexInfo *pInfo) {
int32_t tSerializeSTableIndexRsp(void *buf, int32_t bufLen, const STableIndexRsp *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->dbFName) < 0) return -1;
if (tEncodeU64(&encoder, pRsp->suid) < 0) return -1;
if (tEncodeI32(&encoder, pRsp->version) < 0) return -1;
if (tEncodeI32(&encoder, pRsp->indexSize) < 0) return -1;
TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pRsp->tbName));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pRsp->dbFName));
TAOS_CHECK_EXIT(tEncodeU64(&encoder, pRsp->suid));
TAOS_CHECK_EXIT(tEncodeI32(&encoder, pRsp->version));
TAOS_CHECK_EXIT(tEncodeI32(&encoder, pRsp->indexSize));
int32_t num = taosArrayGetSize(pRsp->pIndex);
if (tEncodeI32(&encoder, num) < 0) return -1;
TAOS_CHECK_EXIT(tEncodeI32(&encoder, num));
if (num > 0) {
for (int32_t i = 0; i < num; ++i) {
STableIndexInfo *pInfo = (STableIndexInfo *)taosArrayGet(pRsp->pIndex, i);
if (tSerializeSTableIndexInfo(&encoder, pInfo) < 0) return -1;
TAOS_CHECK_EXIT(tSerializeSTableIndexInfo(&encoder, pInfo));
}
}
tEndEncode(&encoder);
int32_t tlen = encoder.pos;
_exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
@ -5211,47 +5219,51 @@ void tFreeSerializeSTableIndexRsp(STableIndexRsp *pRsp) {
}
int32_t tDeserializeSTableIndexInfo(SDecoder *pDecoder, STableIndexInfo *pInfo) {
if (tDecodeI8(pDecoder, &pInfo->intervalUnit) < 0) return -1;
if (tDecodeI8(pDecoder, &pInfo->slidingUnit) < 0) return -1;
if (tDecodeI64(pDecoder, &pInfo->interval) < 0) return -1;
if (tDecodeI64(pDecoder, &pInfo->offset) < 0) return -1;
if (tDecodeI64(pDecoder, &pInfo->sliding) < 0) return -1;
if (tDecodeI64(pDecoder, &pInfo->dstTbUid) < 0) return -1;
if (tDecodeI32(pDecoder, &pInfo->dstVgId) < 0) return -1;
if (tDecodeSEpSet(pDecoder, &pInfo->epSet) < 0) return -1;
if (tDecodeCStrAlloc(pDecoder, &pInfo->expr) < 0) return -1;
TAOS_CHECK_RETURN(tDecodeI8(pDecoder, &pInfo->intervalUnit));
TAOS_CHECK_RETURN(tDecodeI8(pDecoder, &pInfo->slidingUnit));
TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pInfo->interval));
TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pInfo->offset));
TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pInfo->sliding));
TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pInfo->dstTbUid));
TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &pInfo->dstVgId));
TAOS_CHECK_RETURN(tDecodeSEpSet(pDecoder, &pInfo->epSet));
TAOS_CHECK_RETURN(tDecodeCStrAlloc(pDecoder, &pInfo->expr));
return 0;
}
int32_t tDeserializeSTableIndexRsp(void *buf, int32_t bufLen, STableIndexRsp *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->dbFName) < 0) return -1;
if (tDecodeU64(&decoder, &pRsp->suid) < 0) return -1;
if (tDecodeI32(&decoder, &pRsp->version) < 0) return -1;
if (tDecodeI32(&decoder, &pRsp->indexSize) < 0) return -1;
TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pRsp->tbName));
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pRsp->dbFName));
TAOS_CHECK_EXIT(tDecodeU64(&decoder, &pRsp->suid));
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pRsp->version));
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pRsp->indexSize));
int32_t num = 0;
if (tDecodeI32(&decoder, &num) < 0) return -1;
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &num));
if (num > 0) {
pRsp->pIndex = taosArrayInit(num, sizeof(STableIndexInfo));
if (NULL == pRsp->pIndex) return -1;
if (NULL == pRsp->pIndex) {
TAOS_CHECK_EXIT(terrno);
}
STableIndexInfo info;
for (int32_t i = 0; i < num; ++i) {
if (tDeserializeSTableIndexInfo(&decoder, &info) < 0) return -1;
TAOS_CHECK_EXIT(tDeserializeSTableIndexInfo(&decoder, &info));
if (NULL == taosArrayPush(pRsp->pIndex, &info)) {
taosMemoryFree(info.expr);
return -1;
TAOS_CHECK_EXIT(terrno);
}
}
}
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return 0;
return code;
}
void tFreeSTableIndexInfo(void *info) {
@ -5266,81 +5278,92 @@ void tFreeSTableIndexInfo(void *info) {
int32_t tSerializeSShowVariablesReq(void *buf, int32_t bufLen, SShowVariablesReq *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 tDeserializeSShowVariablesReq(void *buf, int32_t bufLen, SShowVariablesReq *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 tEncodeSVariablesInfo(SEncoder *pEncoder, SVariablesInfo *pInfo) {
if (tEncodeCStr(pEncoder, pInfo->name) < 0) return -1;
if (tEncodeCStr(pEncoder, pInfo->value) < 0) return -1;
if (tEncodeCStr(pEncoder, pInfo->scope) < 0) return -1;
TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pInfo->name));
TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pInfo->value));
TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pInfo->scope));
return 0;
}
int32_t tDecodeSVariablesInfo(SDecoder *pDecoder, SVariablesInfo *pInfo) {
if (tDecodeCStrTo(pDecoder, pInfo->name) < 0) return -1;
if (tDecodeCStrTo(pDecoder, pInfo->value) < 0) return -1;
if (tDecodeCStrTo(pDecoder, pInfo->scope) < 0) return -1;
TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, pInfo->name));
TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, pInfo->value));
TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, pInfo->scope));
return 0;
}
int32_t tSerializeSShowVariablesRsp(void *buf, int32_t bufLen, SShowVariablesRsp *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 varNum = taosArrayGetSize(pRsp->variables);
if (tEncodeI32(&encoder, varNum) < 0) return -1;
TAOS_CHECK_EXIT(tEncodeI32(&encoder, varNum));
for (int32_t i = 0; i < varNum; ++i) {
SVariablesInfo *pInfo = taosArrayGet(pRsp->variables, i);
if (tEncodeSVariablesInfo(&encoder, pInfo) < 0) return -1;
TAOS_CHECK_EXIT(tEncodeSVariablesInfo(&encoder, pInfo));
}
tEndEncode(&encoder);
int32_t tlen = encoder.pos;
_exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
int32_t tDeserializeSShowVariablesRsp(void *buf, int32_t bufLen, SShowVariablesRsp *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 varNum = 0;
if (tDecodeI32(&decoder, &varNum) < 0) return -1;
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &varNum));
if (varNum > 0) {
pRsp->variables = taosArrayInit(varNum, sizeof(SVariablesInfo));
if (NULL == pRsp->variables) return -1;
if (NULL == pRsp->variables) {
TAOS_CHECK_EXIT(terrno);
}
for (int32_t i = 0; i < varNum; ++i) {
SVariablesInfo info = {0};
if (tDecodeSVariablesInfo(&decoder, &info) < 0) return -1;
if (NULL == taosArrayPush(pRsp->variables, &info)) return -1;
TAOS_CHECK_EXIT(tDecodeSVariablesInfo(&decoder, &info));
if (NULL == taosArrayPush(pRsp->variables, &info)) {
TAOS_CHECK_EXIT(terrno);
}
}
}
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return 0;
return code;
}
void tFreeSShowVariablesRsp(SShowVariablesRsp *pRsp) {
@ -5353,108 +5376,109 @@ void tFreeSShowVariablesRsp(SShowVariablesRsp *pRsp) {
int32_t tSerializeSShowReq(void *buf, int32_t bufLen, SShowReq *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->type) < 0) return -1;
if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
if (tEncodeI32(&encoder, pReq->payloadLen) < 0) return -1;
TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->type));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->db));
TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->payloadLen));
if (pReq->payloadLen > 0) {
if (tEncodeBinary(&encoder, pReq->payload, pReq->payloadLen) < 0) return -1;
TAOS_CHECK_EXIT(tEncodeBinary(&encoder, pReq->payload, pReq->payloadLen));
}
tEndEncode(&encoder);
int32_t tlen = encoder.pos;
_exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
// int32_t tDeserializeSShowReq(void *buf, int32_t bufLen, SShowReq *pReq) {
// SDecoder decoder = {0};
// tDecoderInit(&decoder, buf, bufLen);
// if (tStartDecode(&decoder) < 0) return -1;
// if (tDecodeI32(&decoder, &pReq->type) < 0) return -1;
// if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
// if (tDecodeI32(&decoder, &pReq->payloadLen) < 0) return -1;
// if (pReq->payloadLen > 0) {
// pReq->payload = taosMemoryMalloc(pReq->payloadLen);
// if (pReq->payload == NULL) return -1;
// if (tDecodeCStrTo(&decoder, pReq->payload) < 0) return -1;
// }
// tEndDecode(&decoder);
// tDecoderClear(&decoder);
// return 0;
// }
void tFreeSShowReq(SShowReq *pReq) { taosMemoryFreeClear(pReq->payload); }
int32_t tSerializeSRetrieveTableReq(void *buf, int32_t bufLen, SRetrieveTableReq *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 (tEncodeI64(&encoder, pReq->showId) < 0) return -1;
if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
if (tEncodeCStr(&encoder, pReq->tb) < 0) return -1;
if (tEncodeCStr(&encoder, pReq->filterTb) < 0) return -1;
if (tEncodeCStr(&encoder, pReq->user) < 0) return -1;
if (tEncodeI64(&encoder, pReq->compactId) < 0) return -1;
if (tEncodeI8(&encoder, pReq->withFull) < 0) return -1;
TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->showId));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->db));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->tb));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->filterTb));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->user));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->compactId));
TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->withFull));
tEndEncode(&encoder);
int32_t tlen = encoder.pos;
_exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
int32_t tDeserializeSRetrieveTableReq(void *buf, int32_t bufLen, SRetrieveTableReq *pReq) {
SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1;
if (tDecodeI64(&decoder, &pReq->showId) < 0) return -1;
if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
if (tDecodeCStrTo(&decoder, pReq->tb) < 0) return -1;
if (tDecodeCStrTo(&decoder, pReq->filterTb) < 0) return -1;
if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1;
TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->showId));
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->db));
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->tb));
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->filterTb));
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->user));
if (!tDecodeIsEnd(&decoder)) {
if (tDecodeI64(&decoder, &pReq->compactId) < 0) return -1;
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->compactId));
} else {
pReq->compactId = -1;
}
if (!tDecodeIsEnd(&decoder)) {
if (tDecodeI8(&decoder, (int8_t *)&pReq->withFull) < 0) return -1;
TAOS_CHECK_EXIT(tDecodeI8(&decoder, (int8_t *)&pReq->withFull));
}
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return 0;
return code;
}
static int32_t tEncodeSTableMetaRsp(SEncoder *pEncoder, STableMetaRsp *pRsp) {
if (tEncodeCStr(pEncoder, pRsp->tbName) < 0) return -1;
if (tEncodeCStr(pEncoder, pRsp->stbName) < 0) return -1;
if (tEncodeCStr(pEncoder, pRsp->dbFName) < 0) return -1;
if (tEncodeI64(pEncoder, pRsp->dbId) < 0) return -1;
if (tEncodeI32(pEncoder, pRsp->numOfTags) < 0) return -1;
if (tEncodeI32(pEncoder, pRsp->numOfColumns) < 0) return -1;
if (tEncodeI8(pEncoder, pRsp->precision) < 0) return -1;
if (tEncodeI8(pEncoder, pRsp->tableType) < 0) return -1;
if (tEncodeI32(pEncoder, pRsp->sversion) < 0) return -1;
if (tEncodeI32(pEncoder, pRsp->tversion) < 0) return -1;
if (tEncodeU64(pEncoder, pRsp->suid) < 0) return -1;
if (tEncodeU64(pEncoder, pRsp->tuid) < 0) return -1;
if (tEncodeI32(pEncoder, pRsp->vgId) < 0) return -1;
TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pRsp->tbName));
TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pRsp->stbName));
TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pRsp->dbFName));
TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pRsp->dbId));
TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pRsp->numOfTags));
TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pRsp->numOfColumns));
TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pRsp->precision));
TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pRsp->tableType));
TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pRsp->sversion));
TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pRsp->tversion));
TAOS_CHECK_RETURN(tEncodeU64(pEncoder, pRsp->suid));
TAOS_CHECK_RETURN(tEncodeU64(pEncoder, pRsp->tuid));
TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pRsp->vgId));
for (int32_t i = 0; i < pRsp->numOfColumns + pRsp->numOfTags; ++i) {
SSchema *pSchema = &pRsp->pSchemas[i];
if (tEncodeSSchema(pEncoder, pSchema) < 0) return -1;
TAOS_CHECK_RETURN(tEncodeSSchema(pEncoder, pSchema));
}
if (useCompress(pRsp->tableType)) {
for (int32_t i = 0; i < pRsp->numOfColumns; ++i) {
SSchemaExt *pSchemaExt = &pRsp->pSchemaExt[i];
if (tEncodeSSchemaExt(pEncoder, pSchemaExt) < 0) return -1;
TAOS_CHECK_RETURN(tEncodeSSchemaExt(pEncoder, pSchemaExt));
}
}
@ -5462,28 +5486,30 @@ static int32_t tEncodeSTableMetaRsp(SEncoder *pEncoder, STableMetaRsp *pRsp) {
}
static int32_t tDecodeSTableMetaRsp(SDecoder *pDecoder, STableMetaRsp *pRsp) {
if (tDecodeCStrTo(pDecoder, pRsp->tbName) < 0) return -1;
if (tDecodeCStrTo(pDecoder, pRsp->stbName) < 0) return -1;
if (tDecodeCStrTo(pDecoder, pRsp->dbFName) < 0) return -1;
if (tDecodeI64(pDecoder, &pRsp->dbId) < 0) return -1;
if (tDecodeI32(pDecoder, &pRsp->numOfTags) < 0) return -1;
if (tDecodeI32(pDecoder, &pRsp->numOfColumns) < 0) return -1;
if (tDecodeI8(pDecoder, &pRsp->precision) < 0) return -1;
if (tDecodeI8(pDecoder, &pRsp->tableType) < 0) return -1;
if (tDecodeI32(pDecoder, &pRsp->sversion) < 0) return -1;
if (tDecodeI32(pDecoder, &pRsp->tversion) < 0) return -1;
if (tDecodeU64(pDecoder, &pRsp->suid) < 0) return -1;
if (tDecodeU64(pDecoder, &pRsp->tuid) < 0) return -1;
if (tDecodeI32(pDecoder, &pRsp->vgId) < 0) return -1;
TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, pRsp->tbName));
TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, pRsp->stbName));
TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, pRsp->dbFName));
TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pRsp->dbId));
TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &pRsp->numOfTags));
TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &pRsp->numOfColumns));
TAOS_CHECK_RETURN(tDecodeI8(pDecoder, &pRsp->precision));
TAOS_CHECK_RETURN(tDecodeI8(pDecoder, &pRsp->tableType));
TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &pRsp->sversion));
TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &pRsp->tversion));
TAOS_CHECK_RETURN(tDecodeU64(pDecoder, &pRsp->suid));
TAOS_CHECK_RETURN(tDecodeU64(pDecoder, &pRsp->tuid));
TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &pRsp->vgId));
int32_t totalCols = pRsp->numOfTags + pRsp->numOfColumns;
if (totalCols > 0) {
pRsp->pSchemas = taosMemoryMalloc(sizeof(SSchema) * totalCols);
if (pRsp->pSchemas == NULL) return -1;
if (pRsp->pSchemas == NULL) {
TAOS_CHECK_RETURN(terrno);
}
for (int32_t i = 0; i < totalCols; ++i) {
SSchema *pSchema = &pRsp->pSchemas[i];
if (tDecodeSSchema(pDecoder, pSchema) < 0) return -1;
TAOS_CHECK_RETURN(tDecodeSSchema(pDecoder, pSchema));
}
} else {
pRsp->pSchemas = NULL;
@ -5492,11 +5518,13 @@ static int32_t tDecodeSTableMetaRsp(SDecoder *pDecoder, STableMetaRsp *pRsp) {
if (!tDecodeIsEnd(pDecoder)) {
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_RETURN(terrno);
}
for (int32_t i = 0; i < pRsp->numOfColumns; ++i) {
SSchemaExt *pSchemaExt = &pRsp->pSchemaExt[i];
if (tDecodeSSchemaExt(pDecoder, pSchemaExt) < 0) return -1;
TAOS_CHECK_RETURN(tDecodeSSchemaExt(pDecoder, pSchemaExt));
}
} else {
pRsp->pSchemaExt = NULL;
@ -5508,128 +5536,155 @@ static int32_t tDecodeSTableMetaRsp(SDecoder *pDecoder, STableMetaRsp *pRsp) {
int32_t tSerializeSTableMetaRsp(void *buf, int32_t bufLen, STableMetaRsp *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 (tEncodeSTableMetaRsp(&encoder, pRsp) < 0) return -1;
TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tEncodeSTableMetaRsp(&encoder, pRsp));
tEndEncode(&encoder);
int32_t tlen = encoder.pos;
_exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
int32_t tSerializeSSTbHbRsp(void *buf, int32_t bufLen, SSTbHbRsp *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 numOfMeta = taosArrayGetSize(pRsp->pMetaRsp);
if (tEncodeI32(&encoder, numOfMeta) < 0) return -1;
TAOS_CHECK_EXIT(tEncodeI32(&encoder, numOfMeta));
for (int32_t i = 0; i < numOfMeta; ++i) {
STableMetaRsp *pMetaRsp = taosArrayGet(pRsp->pMetaRsp, i);
if (tEncodeSTableMetaRsp(&encoder, pMetaRsp) < 0) return -1;
TAOS_CHECK_EXIT(tEncodeSTableMetaRsp(&encoder, pMetaRsp));
}
int32_t numOfIndex = taosArrayGetSize(pRsp->pIndexRsp);
if (tEncodeI32(&encoder, numOfIndex) < 0) return -1;
TAOS_CHECK_EXIT(tEncodeI32(&encoder, numOfIndex));
for (int32_t i = 0; i < numOfIndex; ++i) {
STableIndexRsp *pIndexRsp = taosArrayGet(pRsp->pIndexRsp, i);
if (tEncodeCStr(&encoder, pIndexRsp->tbName) < 0) return -1;
if (tEncodeCStr(&encoder, pIndexRsp->dbFName) < 0) return -1;
if (tEncodeU64(&encoder, pIndexRsp->suid) < 0) return -1;
if (tEncodeI32(&encoder, pIndexRsp->version) < 0) return -1;
if (tEncodeI32(&encoder, pIndexRsp->indexSize) < 0) return -1;
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pIndexRsp->tbName));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pIndexRsp->dbFName));
TAOS_CHECK_EXIT(tEncodeU64(&encoder, pIndexRsp->suid));
TAOS_CHECK_EXIT(tEncodeI32(&encoder, pIndexRsp->version));
TAOS_CHECK_EXIT(tEncodeI32(&encoder, pIndexRsp->indexSize));
int32_t num = taosArrayGetSize(pIndexRsp->pIndex);
if (tEncodeI32(&encoder, num) < 0) return -1;
TAOS_CHECK_EXIT(tEncodeI32(&encoder, num));
for (int32_t j = 0; j < num; ++j) {
STableIndexInfo *pInfo = (STableIndexInfo *)taosArrayGet(pIndexRsp->pIndex, j);
if (tSerializeSTableIndexInfo(&encoder, pInfo) < 0) return -1;
TAOS_CHECK_EXIT(tSerializeSTableIndexInfo(&encoder, pInfo));
}
}
tEndEncode(&encoder);
int32_t tlen = encoder.pos;
_exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
int32_t tDeserializeSTableMetaRsp(void *buf, int32_t bufLen, STableMetaRsp *pRsp) {
SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1;
if (tDecodeSTableMetaRsp(&decoder, pRsp) < 0) return -1;
TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDecodeSTableMetaRsp(&decoder, pRsp));
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return 0;
return code;
}
int32_t tDeserializeSSTbHbRsp(void *buf, int32_t bufLen, SSTbHbRsp *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 numOfMeta = 0;
if (tDecodeI32(&decoder, &numOfMeta) < 0) return -1;
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &numOfMeta));
pRsp->pMetaRsp = taosArrayInit(numOfMeta, sizeof(STableMetaRsp));
if (pRsp->pMetaRsp == NULL) {
return -1;
TAOS_CHECK_EXIT(terrno);
}
for (int32_t i = 0; i < numOfMeta; ++i) {
STableMetaRsp tableMetaRsp = {0};
if (tDecodeSTableMetaRsp(&decoder, &tableMetaRsp) < 0) return -1;
TAOS_CHECK_EXIT(tDecodeSTableMetaRsp(&decoder, &tableMetaRsp));
if (taosArrayPush(pRsp->pMetaRsp, &tableMetaRsp) == NULL) {
taosMemoryFree(tableMetaRsp.pSchemas);
taosMemoryFree(tableMetaRsp.pSchemaExt);
return -1;
TAOS_CHECK_EXIT(terrno);
}
}
int32_t numOfIndex = 0;
if (tDecodeI32(&decoder, &numOfIndex) < 0) return -1;
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &numOfIndex));
pRsp->pIndexRsp = taosArrayInit(numOfIndex, sizeof(STableIndexRsp));
if (pRsp->pIndexRsp == NULL) {
return -1;
TAOS_CHECK_EXIT(terrno);
}
for (int32_t i = 0; i < numOfIndex; ++i) {
STableIndexRsp tableIndexRsp = {0};
if (tDecodeCStrTo(&decoder, tableIndexRsp.tbName) < 0) return -1;
if (tDecodeCStrTo(&decoder, tableIndexRsp.dbFName) < 0) return -1;
if (tDecodeU64(&decoder, &tableIndexRsp.suid) < 0) return -1;
if (tDecodeI32(&decoder, &tableIndexRsp.version) < 0) return -1;
if (tDecodeI32(&decoder, &tableIndexRsp.indexSize) < 0) return -1;
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, tableIndexRsp.tbName));
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, tableIndexRsp.dbFName));
TAOS_CHECK_EXIT(tDecodeU64(&decoder, &tableIndexRsp.suid));
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &tableIndexRsp.version));
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &tableIndexRsp.indexSize));
int32_t num = 0;
if (tDecodeI32(&decoder, &num) < 0) return -1;
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &num));
if (num > 0) {
tableIndexRsp.pIndex = taosArrayInit(num, sizeof(STableIndexInfo));
if (NULL == tableIndexRsp.pIndex) return -1;
if (NULL == tableIndexRsp.pIndex) {
TAOS_CHECK_EXIT(terrno);
}
STableIndexInfo info;
for (int32_t j = 0; j < num; ++j) {
if (tDeserializeSTableIndexInfo(&decoder, &info) < 0) return -1;
TAOS_CHECK_EXIT(tDeserializeSTableIndexInfo(&decoder, &info));
if (NULL == taosArrayPush(tableIndexRsp.pIndex, &info)) {
taosMemoryFree(info.expr);
return -1;
TAOS_CHECK_EXIT(terrno);
}
}
}
if (taosArrayPush(pRsp->pIndexRsp, &tableIndexRsp) == NULL) {
taosArrayDestroyEx(tableIndexRsp.pIndex, tFreeSTableIndexInfo);
return -1;
TAOS_CHECK_EXIT(terrno);
}
}
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return 0;
return code;
}
void tFreeSTableMetaRsp(void *pRsp) {
@ -5669,35 +5724,6 @@ void tFreeSSTbHbRsp(SSTbHbRsp *pRsp) {
taosArrayDestroy(pRsp->pIndexRsp);
}
// int32_t tSerializeSShowRsp(void *buf, int32_t bufLen, SShowRsp *pRsp) {
// SEncoder encoder = {0};
// tEncoderInit(&encoder, buf, bufLen);
// if (tStartEncode(&encoder) < 0) return -1;
// if (tEncodeI64(&encoder, pRsp->showId) < 0) return -1;
// if (tEncodeSTableMetaRsp(&encoder, &pRsp->tableMeta) < 0) return -1;
// tEndEncode(&encoder);
// int32_t tlen = encoder.pos;
// tEncoderClear(&encoder);
// return tlen;
// }
// int32_t tDeserializeSShowRsp(void *buf, int32_t bufLen, SShowRsp *pRsp) {
// SDecoder decoder = {0};
// tDecoderInit(&decoder, buf, bufLen);
// if (tStartDecode(&decoder) < 0) return -1;
// if (tDecodeI64(&decoder, &pRsp->showId) < 0) return -1;
// if (tDecodeSTableMetaRsp(&decoder, &pRsp->tableMeta) < 0) return -1;
// tEndDecode(&decoder);
// tDecoderClear(&decoder);
// return 0;
// }
// void tFreeSShowRsp(SShowRsp *pRsp) { tFreeSTableMetaRsp(&pRsp->tableMeta); }
int32_t tSerializeSTableInfoReq(void *buf, int32_t bufLen, STableInfoReq *pReq) {
int32_t headLen = sizeof(SMsgHead);
if (buf != NULL) {
@ -5746,92 +5772,123 @@ int32_t tDeserializeSTableInfoReq(void *buf, int32_t bufLen, STableInfoReq *pReq
int32_t tSerializeSMDropTopicReq(void *buf, int32_t bufLen, SMDropTopicReq *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));
ENCODESQL();
tEndEncode(&encoder);
int32_t tlen = encoder.pos;
_exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
int32_t tDeserializeSMDropTopicReq(void *buf, int32_t bufLen, SMDropTopicReq *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));
DECODESQL();
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return 0;
return code;
}
void tFreeSMDropTopicReq(SMDropTopicReq *pReq) { FREESQL(); }
int32_t tSerializeSMDropCgroupReq(void *buf, int32_t bufLen, SMDropCgroupReq *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->topic) < 0) return -1;
if (tEncodeCStr(&encoder, pReq->cgroup) < 0) return -1;
if (tEncodeI8(&encoder, pReq->igNotExists) < 0) return -1;
TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->topic));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->cgroup));
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 tDeserializeSMDropCgroupReq(void *buf, int32_t bufLen, SMDropCgroupReq *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->topic) < 0) return -1;
if (tDecodeCStrTo(&decoder, pReq->cgroup) < 0) return -1;
if (tDecodeI8(&decoder, &pReq->igNotExists) < 0) return -1;
TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->topic));
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->cgroup));
TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->igNotExists));
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return 0;
return code;
}
int32_t tSerializeSCMCreateTopicReq(void *buf, int32_t bufLen, const SCMCreateTopicReq *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->subType) < 0) return -1;
if (tEncodeI8(&encoder, pReq->withMeta) < 0) return -1;
if (tEncodeCStr(&encoder, pReq->subDbName) < 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->subType));
TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->withMeta));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->subDbName));
if (TOPIC_SUB_TYPE__DB == pReq->subType) {
} else {
if (TOPIC_SUB_TYPE__TABLE == pReq->subType) {
if (tEncodeCStr(&encoder, pReq->subStbName) < 0) return -1;
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->subStbName));
}
if (pReq->ast && strlen(pReq->ast) > 0) {
if (tEncodeI32(&encoder, strlen(pReq->ast)) < 0) return -1;
if (tEncodeCStr(&encoder, pReq->ast) < 0) return -1;
TAOS_CHECK_EXIT(tEncodeI32(&encoder, strlen(pReq->ast)));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->ast));
} else {
if (tEncodeI32(&encoder, 0) < 0) return -1;
TAOS_CHECK_EXIT(tEncodeI32(&encoder, 0));
}
}
if (tEncodeI32(&encoder, strlen(pReq->sql)) < 0) return -1;
if (tEncodeCStr(&encoder, pReq->sql) < 0) return -1;
TAOS_CHECK_EXIT(tEncodeI32(&encoder, strlen(pReq->sql)));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->sql));
tEndEncode(&encoder);
int32_t tlen = encoder.pos;
_exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
@ -5839,39 +5896,45 @@ int32_t tSerializeSCMCreateTopicReq(void *buf, int32_t bufLen, const SCMCreateTo
int32_t tDeserializeSCMCreateTopicReq(void *buf, int32_t bufLen, SCMCreateTopicReq *pReq) {
int32_t sqlLen = 0;
int32_t astLen = 0;
int32_t code = 0;
int32_t lino;
SDecoder decoder = {0};
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->subType) < 0) return -1;
if (tDecodeI8(&decoder, &pReq->withMeta) < 0) return -1;
if (tDecodeCStrTo(&decoder, pReq->subDbName) < 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->subType));
TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->withMeta));
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->subDbName));
if (TOPIC_SUB_TYPE__DB == pReq->subType) {
} else {
if (TOPIC_SUB_TYPE__TABLE == pReq->subType) {
if (tDecodeCStrTo(&decoder, pReq->subStbName) < 0) return -1;
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->subStbName));
}
if (tDecodeI32(&decoder, &astLen) < 0) return -1;
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &astLen));
if (astLen > 0) {
pReq->ast = taosMemoryCalloc(1, astLen + 1);
if (pReq->ast == NULL) return -1;
if (tDecodeCStrTo(&decoder, pReq->ast) < 0) return -1;
if (pReq->ast == NULL) {
TAOS_CHECK_EXIT(terrno);
}
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->ast));
}
}
if (tDecodeI32(&decoder, &sqlLen) < 0) return -1;
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &sqlLen));
if (sqlLen > 0) {
pReq->sql = taosMemoryCalloc(1, sqlLen + 1);
if (pReq->sql == NULL) return -1;
if (tDecodeCStrTo(&decoder, pReq->sql) < 0) return -1;
if (pReq->sql == NULL) {
TAOS_CHECK_EXIT(terrno);
}
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->sql));
}
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return 0;
return code;
}
void tFreeSCMCreateTopicReq(SCMCreateTopicReq *pReq) {
@ -5883,46 +5946,57 @@ void tFreeSCMCreateTopicReq(SCMCreateTopicReq *pReq) {
int32_t tSerializeSConnectReq(void *buf, int32_t bufLen, SConnectReq *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 (tEncodeI8(&encoder, pReq->connType) < 0) return -1;
if (tEncodeI32(&encoder, pReq->pid) < 0) return -1;
if (tEncodeCStr(&encoder, pReq->app) < 0) return -1;
if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
if (tEncodeCStr(&encoder, pReq->user) < 0) return -1;
if (tEncodeCStrWithLen(&encoder, pReq->passwd, TSDB_PASSWORD_LEN) < 0) return -1;
if (tEncodeI64(&encoder, pReq->startTime) < 0) return -1;
if (tEncodeCStr(&encoder, pReq->sVer) < 0) return -1;
TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->connType));
TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->pid));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->app));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->db));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->user));
TAOS_CHECK_EXIT(tEncodeCStrWithLen(&encoder, pReq->passwd, TSDB_PASSWORD_LEN));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->startTime));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->sVer));
tEndEncode(&encoder);
int32_t tlen = encoder.pos;
_exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
int32_t tDeserializeSConnectReq(void *buf, int32_t bufLen, SConnectReq *pReq) {
SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1;
if (tDecodeI8(&decoder, &pReq->connType) < 0) return -1;
if (tDecodeI32(&decoder, &pReq->pid) < 0) return -1;
if (tDecodeCStrTo(&decoder, pReq->app) < 0) return -1;
if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1;
if (tDecodeCStrTo(&decoder, pReq->passwd) < 0) return -1;
if (tDecodeI64(&decoder, &pReq->startTime) < 0) return -1;
TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->connType));
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->pid));
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->app));
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->db));
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->user));
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->passwd));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->startTime));
// Check the client version from version 3.0.3.0
if (tDecodeIsEnd(&decoder)) {
tDecoderClear(&decoder);
return TSDB_CODE_VERSION_NOT_COMPATIBLE;
TAOS_CHECK_EXIT(TSDB_CODE_VERSION_NOT_COMPATIBLE);
}
if (tDecodeCStrTo(&decoder, pReq->sVer) < 0) return -1;
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->sVer));
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return 0;
return code;
}
int32_t tSerializeSConnectRsp(void *buf, int32_t bufLen, SConnectRsp *pRsp) {