Elgato_dark/TDengine
1
0
Fork 0
mirror of https://github.com/taosdata/TDengine synced 2026-05-24 10:09:01 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4
TDengine/source/common/src/msg/streamMsg.c

4743 lines
161 KiB
C
Raw Blame History

/*
* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
*
* This program is free software: you can use, redistribute, and/or modify
* it under the terms of the GNU Affero General Public License, version 3
* or later ("AGPL"), as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "streamMsg.h"
#include "taos.h"
#include "tarray.h"
#include "tdatablock.h"
#include "thash.h"
#include "tlist.h"
#include "tmsg.h"
#include "os.h"
#include "tcommon.h"
#include "tsimplehash.h"
int32_t tEncodeSStreamMgmtReq(SEncoder* pEncoder, const SStreamMgmtReq* pReq) {
int32_t code = 0;
int32_t lino = 0;
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pReq->reqId));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->type));
switch (pReq->type) {
case STREAM_MGMT_REQ_TRIGGER_ORIGTBL_READER: {
if (pReq->cont.pReqs) {
int32_t num = taosArrayGetSize(pReq->cont.pReqs);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, num));
for (int32_t i = 0; i < num; ++i) {
SStreamDbTableName* pName = taosArrayGet(pReq->cont.pReqs, i);
TAOS_CHECK_EXIT(tEncodeCStrWithLen(pEncoder, pName->dbFName, strlen(pName->dbFName) + 1));
TAOS_CHECK_EXIT(tEncodeCStrWithLen(pEncoder, pName->tbName, strlen(pName->tbName) + 1));
}
} else {
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, 0));
}
break;
}
case STREAM_MGMT_REQ_RUNNER_ORIGTBL_READER: {
if (pReq->cont.pReqs) {
int32_t num = taosArrayGetSize(pReq->cont.pReqs);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, num));
for (int32_t i = 0; i < num; ++i) {
SStreamOReaderDeployReq* pDeploy = taosArrayGet(pReq->cont.pReqs, i);
int32_t vgIdNum = taosArrayGetSize(pDeploy->vgIds);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pDeploy->execId));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pDeploy->uid));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, vgIdNum));
for (int32_t n = 0; n < vgIdNum; ++n) {
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, *(int32_t*)taosArrayGet(pDeploy->vgIds, n)));
}
}
} else {
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, 0));
}
break;
}
default:
code = TSDB_CODE_STREAM_INVALID_TASK_TYPE;
break;
}
_exit:
return code;
}
void tFreeRunnerOReaderDeployReq(void* param) {
SStreamOReaderDeployReq* pReq = (SStreamOReaderDeployReq*)param;
if (pReq) {
taosArrayDestroy(pReq->vgIds);
}
}
void tFreeSStreamMgmtReq(SStreamMgmtReq* pReq) {
if (NULL == pReq) {
return;
}
switch (pReq->type) {
case STREAM_MGMT_REQ_TRIGGER_ORIGTBL_READER:
taosArrayDestroy(pReq->cont.pReqs);
break;
case STREAM_MGMT_REQ_RUNNER_ORIGTBL_READER:
taosArrayDestroyEx(pReq->cont.pReqs, tFreeRunnerOReaderDeployReq);
break;
default:
break;
}
}
int32_t tCloneSStreamMgmtReq(SStreamMgmtReq* pSrc, SStreamMgmtReq** ppDst) {
*ppDst = NULL;
if (NULL == pSrc) {
return TSDB_CODE_SUCCESS;
}
int32_t code = 0, lino = 0;
*ppDst = taosMemoryCalloc(1, sizeof(SStreamMgmtReq));
TSDB_CHECK_NULL(*ppDst, code, lino, _exit, terrno);
memcpy(*ppDst, pSrc, sizeof(*pSrc));
if (pSrc->cont.pReqs) {
switch (pSrc->type) {
case STREAM_MGMT_REQ_TRIGGER_ORIGTBL_READER:
(*ppDst)->cont.pReqs = taosArrayDup(pSrc->cont.pReqs, NULL);
TSDB_CHECK_NULL((*ppDst)->cont.pReqs, code, lino, _exit, terrno);
break;
case STREAM_MGMT_REQ_RUNNER_ORIGTBL_READER: {
int32_t reqNum = taosArrayGetSize(pSrc->cont.pReqs);
(*ppDst)->cont.pReqs = taosArrayInit_s(sizeof(SStreamOReaderDeployReq), reqNum);
TSDB_CHECK_NULL((*ppDst)->cont.pReqs, code, lino, _exit, terrno);
for (int32_t i = 0; i < reqNum; ++i) {
SStreamOReaderDeployReq* pNew = taosArrayGet((*ppDst)->cont.pReqs, i);
SStreamOReaderDeployReq* pReq = taosArrayGet(pSrc->cont.pReqs, i);
pNew->vgIds = taosArrayDup(pReq->vgIds, NULL);
TSDB_CHECK_NULL(pNew->vgIds, code, lino, _exit, terrno);
pNew->execId = pReq->execId;
pNew->uid = pReq->uid;
}
break;
}
default:
break;
}
}
_exit:
if (code) {
tFreeSStreamMgmtReq(*ppDst);
taosMemoryFreeClear(*ppDst);
uError("%s failed at line %d since %s", __FUNCTION__, lino, tstrerror(code));
}
return code;
}
int32_t tDecodeSStreamMgmtReq(SDecoder* pDecoder, SStreamMgmtReq* pReq) {
int32_t code = 0;
int32_t lino = 0;
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->reqId));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, (int32_t*)&pReq->type));
switch (pReq->type) {
case STREAM_MGMT_REQ_TRIGGER_ORIGTBL_READER: {
int32_t num = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &num));
if (num > 0) {
pReq->cont.pReqs = taosArrayInit(num, sizeof(SStreamDbTableName));
TSDB_CHECK_NULL(pReq->cont.pReqs, code, lino, _exit, terrno);
for (int32_t i = 0; i < num; ++i) {
SStreamDbTableName* p = taosArrayReserve(pReq->cont.pReqs, 1);
TAOS_CHECK_EXIT(tDecodeCStrTo(pDecoder, p->dbFName));
TAOS_CHECK_EXIT(tDecodeCStrTo(pDecoder, p->tbName));
}
}
break;
}
case STREAM_MGMT_REQ_RUNNER_ORIGTBL_READER: {
int32_t num = 0, vgIdNum = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &num));
if (num > 0) {
pReq->cont.pReqs = taosArrayInit_s(sizeof(SStreamOReaderDeployReq), num);
TSDB_CHECK_NULL(pReq->cont.pReqs, code, lino, _exit, terrno);
for (int32_t i = 0; i < num; ++i) {
SStreamOReaderDeployReq* p = taosArrayGet(pReq->cont.pReqs, i);
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &p->execId));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &p->uid));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgIdNum));
if (vgIdNum > 0) {
p->vgIds = taosArrayInit_s(sizeof(int32_t), vgIdNum);
TSDB_CHECK_NULL(p->vgIds, code, lino, _exit, terrno);
}
for (int32_t n = 0; n < vgIdNum; ++n) {
int32_t* vgId = taosArrayGet(p->vgIds, n);
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, vgId));
}
}
}
break;
}
default:
code = TSDB_CODE_STREAM_INVALID_TASK_TYPE;
break;
}
_exit:
return code;
}
int32_t tEncodeStreamTask(SEncoder* pEncoder, const SStreamTask* pTask) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->type));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->streamId));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->taskId));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->flags));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->seriousId));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->deployId));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->nodeId));
// SKIP SESSIONID
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->taskIdx));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->status));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->detailStatus));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->errorCode));
if (pTask->pMgmtReq) {
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, 1));
TAOS_CHECK_EXIT(tEncodeSStreamMgmtReq(pEncoder, pTask->pMgmtReq));
} else {
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, 0));
}
_exit:
return code;
}
int32_t tDecodeStreamTask(SDecoder* pDecoder, SStreamTask* pTask) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, (int32_t*)&pTask->type));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->streamId));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->taskId));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->flags));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->seriousId));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pTask->deployId));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pTask->nodeId));
// SKIP SESSIONID
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pTask->taskIdx));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, (int32_t*)&pTask->status));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pTask->detailStatus));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pTask->errorCode));
int32_t req = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &req));
if (req) {
pTask->pMgmtReq = taosMemoryCalloc(1, sizeof(SStreamMgmtReq));
TSDB_CHECK_NULL(pTask->pMgmtReq, code, lino, _exit, terrno);
TAOS_CHECK_EXIT(tDecodeSStreamMgmtReq(pDecoder, pTask->pMgmtReq));
}
_exit:
return code;
}
int32_t tEncodeSSTriggerRecalcProgress(SEncoder* pEncoder, const SSTriggerRecalcProgress* pProgress) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pProgress->recalcId));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pProgress->progress));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pProgress->start));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pProgress->end));
_exit:
return code;
}
int32_t tDecodeSSTriggerRecalcProgress(SDecoder* pDecoder, SSTriggerRecalcProgress* pProgress) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pProgress->recalcId));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pProgress->progress));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pProgress->start));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pProgress->end));
_exit:
return code;
}
int32_t tEncodeSSTriggerRuntimeStatus(SEncoder* pEncoder, const SSTriggerRuntimeStatus* pStatus) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pStatus->autoRecalcNum));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pStatus->realtimeSessionNum));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pStatus->historySessionNum));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pStatus->recalcSessionNum));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pStatus->histroyProgress));
int32_t recalcNum = (int32_t)taosArrayGetSize(pStatus->userRecalcs);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, recalcNum));
for (int32_t i = 0; i < recalcNum; ++i) {
SSTriggerRecalcProgress* pProgress = taosArrayGet(pStatus->userRecalcs, i);
TAOS_CHECK_EXIT(tEncodeSSTriggerRecalcProgress(pEncoder, pProgress));
}
_exit:
return code;
}
int32_t tDecodeSSTriggerRuntimeStatus(SDecoder* pDecoder, SSTriggerRuntimeStatus* pStatus) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pStatus->autoRecalcNum));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pStatus->realtimeSessionNum));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pStatus->historySessionNum));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pStatus->realtimeSessionNum));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pStatus->histroyProgress));
int32_t recalcNum = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &recalcNum));
if (recalcNum > 0) {
pStatus->userRecalcs = taosArrayInit_s(sizeof(SSTriggerRecalcProgress), recalcNum);
if (NULL == pStatus->userRecalcs) {
code = terrno;
goto _exit;
}
}
for (int32_t i = 0; i < recalcNum; ++i) {
SSTriggerRecalcProgress* pProgress = taosArrayGet(pStatus->userRecalcs, i);
TAOS_CHECK_EXIT(tDecodeSSTriggerRecalcProgress(pDecoder, pProgress));
}
_exit:
return code;
}
int32_t tEncodeStreamHbMsg(SEncoder* pEncoder, const SStreamHbMsg* pReq) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tStartEncode(pEncoder));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->dnodeId));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->streamGId));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->snodeId));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->runnerThreadNum));
int32_t vgLeaderNum = taosArrayGetSize(pReq->pVgLeaders);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, vgLeaderNum));
for (int32_t i = 0; i < vgLeaderNum; ++i) {
int32_t* vgId = taosArrayGet(pReq->pVgLeaders, i);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, *vgId));
}
int32_t statusNum = taosArrayGetSize(pReq->pStreamStatus);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, statusNum));
for (int32_t i = 0; i < statusNum; ++i) {
SStmTaskStatusMsg* pStatus = taosArrayGet(pReq->pStreamStatus, i);
TAOS_CHECK_EXIT(tEncodeStreamTask(pEncoder, (SStreamTask*)pStatus));
}
int32_t reqNum = taosArrayGetSize(pReq->pStreamReq);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, reqNum));
for (int32_t i = 0; i < reqNum; ++i) {
int32_t* idx = taosArrayGet(pReq->pStreamReq, i);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, *idx));
}
int32_t triggerNum = taosArrayGetSize(pReq->pTriggerStatus);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, triggerNum));
for (int32_t i = 0; i < triggerNum; ++i) {
SSTriggerRuntimeStatus* pTrigger = taosArrayGet(pReq->pTriggerStatus, i);
TAOS_CHECK_EXIT(tEncodeSSTriggerRuntimeStatus(pEncoder, pTrigger));
}
tEndEncode(pEncoder);
_exit:
if (code) {
return code;
} else {
return pEncoder->pos;
}
}
int32_t tDecodeStreamHbMsg(SDecoder* pDecoder, SStreamHbMsg* pReq) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tStartDecode(pDecoder));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->dnodeId));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->streamGId));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->snodeId));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->runnerThreadNum));
int32_t vgLearderNum = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgLearderNum));
if (vgLearderNum > 0) {
pReq->pVgLeaders = taosArrayInit(vgLearderNum, sizeof(int32_t));
if (NULL == pReq->pVgLeaders) {
code = terrno;
goto _exit;
}
}
for (int32_t i = 0; i < vgLearderNum; ++i) {
int32_t vgId = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgId));
if (NULL == taosArrayPush(pReq->pVgLeaders, &vgId)) {
code = terrno;
goto _exit;
}
}
int32_t statusNum = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &statusNum));
if (statusNum > 0) {
pReq->pStreamStatus = taosArrayInit_s(sizeof(SStmTaskStatusMsg), statusNum);
if (NULL == pReq->pStreamStatus) {
code = terrno;
goto _exit;
}
}
for (int32_t i = 0; i < statusNum; ++i) {
SStmTaskStatusMsg* pTask = taosArrayGet(pReq->pStreamStatus, i);
if (NULL == pTask) {
code = terrno;
goto _exit;
}
TAOS_CHECK_EXIT(tDecodeStreamTask(pDecoder, (SStreamTask*)pTask));
}
int32_t reqNum = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &reqNum));
if (reqNum > 0) {
pReq->pStreamReq = taosArrayInit_s(sizeof(int32_t), reqNum);
if (NULL == pReq->pStreamReq) {
code = terrno;
goto _exit;
}
}
for (int32_t i = 0; i < reqNum; ++i) {
int32_t* pIdx = taosArrayGet(pReq->pStreamReq, i);
if (NULL == pIdx) {
code = terrno;
goto _exit;
}
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, pIdx));
}
int32_t triggerNum = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &triggerNum));
if (triggerNum > 0) {
pReq->pTriggerStatus = taosArrayInit_s(sizeof(SSTriggerRuntimeStatus), triggerNum);
if (NULL == pReq->pTriggerStatus) {
code = terrno;
goto _exit;
}
}
for (int32_t i = 0; i < triggerNum; ++i) {
SSTriggerRuntimeStatus* pStatus = taosArrayGet(pReq->pTriggerStatus, i);
if (NULL == pStatus) {
code = terrno;
goto _exit;
}
TAOS_CHECK_EXIT(tDecodeSSTriggerRuntimeStatus(pDecoder, pStatus));
}
tEndDecode(pDecoder);
_exit:
return code;
}
void tFreeSSTriggerRuntimeStatus(void* param) {
SSTriggerRuntimeStatus* pStatus = (SSTriggerRuntimeStatus*)param;
if (NULL == pStatus) {
return;
}
taosArrayDestroy(pStatus->userRecalcs);
}
void tCleanupStreamHbMsg(SStreamHbMsg* pMsg, bool deepClean) {
if (pMsg == NULL) {
return;
}
taosArrayDestroy(pMsg->pVgLeaders);
if (deepClean) {
int32_t reqNum = taosArrayGetSize(pMsg->pStreamReq);
for (int32_t i = 0; i < reqNum; ++i) {
int32_t* idx = taosArrayGet(pMsg->pStreamReq, i);
SStmTaskStatusMsg* pTask = taosArrayGet(pMsg->pStreamStatus, *idx);
if (NULL == pTask) {
continue;
}
tFreeSStreamMgmtReq(pTask->pMgmtReq);
taosMemoryFree(pTask->pMgmtReq);
}
}
taosArrayDestroy(pMsg->pStreamReq);
taosArrayDestroy(pMsg->pStreamStatus);
taosArrayDestroyEx(pMsg->pTriggerStatus, tFreeSSTriggerRuntimeStatus);
}
int32_t tEncodeSStreamReaderDeployFromTrigger(SEncoder* pEncoder, const SStreamReaderDeployFromTrigger* pMsg) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, (const uint8_t*)pMsg->triggerTblName, pMsg->triggerTblName == NULL ? 0 : (int32_t)strlen(pMsg->triggerTblName) + 1));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->triggerTblUid));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->triggerTblSuid));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->triggerTblType));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->isTriggerTblVirt));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->deleteReCalc));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->deleteOutTbl));
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->partitionCols, pMsg->partitionCols == NULL ? 0 : (int32_t)strlen(pMsg->partitionCols) + 1));
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->triggerCols, pMsg->triggerCols == NULL ? 0 : (int32_t)strlen(pMsg->triggerCols) + 1));
//TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->triggerPrevFilter, pMsg->triggerPrevFilter == NULL ? 0 : (int32_t)strlen(pMsg->triggerPrevFilter) + 1));
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->triggerScanPlan, pMsg->triggerScanPlan == NULL ? 0 : (int32_t)strlen(pMsg->triggerScanPlan) + 1));
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->calcCacheScanPlan, pMsg->calcCacheScanPlan == NULL ? 0 : (int32_t)strlen(pMsg->calcCacheScanPlan) + 1));
_exit:
return code;
}
int32_t tEncodeSStreamReaderDeployFromCalc(SEncoder* pEncoder, const SStreamReaderDeployFromCalc* pMsg) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->execReplica));
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->calcScanPlan, pMsg->calcScanPlan == NULL ? 0 : (int32_t)strlen(pMsg->calcScanPlan) + 1));
_exit:
return code;
}
int32_t tEncodeSStreamReaderDeployMsg(SEncoder* pEncoder, const SStreamReaderDeployMsg* pMsg) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->triggerReader));
if (pMsg->triggerReader) {
TAOS_CHECK_EXIT(tEncodeSStreamReaderDeployFromTrigger(pEncoder, &pMsg->msg.trigger));
} else {
TAOS_CHECK_EXIT(tEncodeSStreamReaderDeployFromCalc(pEncoder, &pMsg->msg.calc));
}
_exit:
return code;
}
int32_t tEncodeSStreamTaskAddr(SEncoder* pEncoder, const SStreamTaskAddr* pMsg) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->taskId));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->nodeId));
TAOS_CHECK_EXIT(tEncodeSEpSet(pEncoder, &pMsg->epset));
_exit:
return code;
}
int32_t tEncodeSStreamRunnerTarget(SEncoder* pEncoder, const SStreamRunnerTarget* pMsg) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tEncodeSStreamTaskAddr(pEncoder, &pMsg->addr));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->execReplica));
_exit:
return code;
}
int32_t tEncodeSStreamTriggerDeployMsg(SEncoder* pEncoder, const SStreamTriggerDeployMsg* pMsg) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->triggerType));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->igDisorder));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->fillHistory));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->fillHistoryFirst));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->lowLatencyCalc));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->igNoDataTrigger));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->enableMultiGroupCalc));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->isTriggerTblVirt));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->triggerHasPF));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->isTriggerTblStb));
int32_t partitionColsLen = pMsg->partitionCols == NULL ? 0 : (int32_t)strlen((char*)pMsg->partitionCols) + 1;
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->partitionCols, partitionColsLen));
int32_t addrSize = (int32_t)taosArrayGetSize(pMsg->pNotifyAddrUrls);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, addrSize));
for (int32_t i = 0; i < addrSize; ++i) {
const char *url = taosArrayGetP(pMsg->pNotifyAddrUrls, i);
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, url, NULL == url ? 0 : (int32_t)strlen(url) + 1));
}
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->notifyEventTypes));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->addOptions));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->notifyHistory));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->maxDelay));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->fillHistoryStartTime));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->watermark));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->expiredTime));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->idleTimeoutMs));
switch (pMsg->triggerType) {
case WINDOW_TYPE_SESSION: {
// session trigger
TAOS_CHECK_EXIT(tEncodeI16(pEncoder, pMsg->trigger.session.slotId));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.session.sessionVal));
break;
}
case WINDOW_TYPE_STATE: {
// state trigger
TAOS_CHECK_EXIT(tEncodeI16(pEncoder, pMsg->trigger.stateWin.slotId));
TAOS_CHECK_EXIT(tEncodeI16(pEncoder, pMsg->trigger.stateWin.extend));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->trigger.stateWin.trueForType));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->trigger.stateWin.trueForCount));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.stateWin.trueForDuration));
int32_t stateWindowZerothLen =
pMsg->trigger.stateWin.zeroth == NULL ? 0 : (int32_t)strlen((char*)pMsg->trigger.stateWin.zeroth) + 1;
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->trigger.stateWin.zeroth, stateWindowZerothLen));
int32_t stateWindowExprLen =
pMsg->trigger.stateWin.expr == NULL ? 0 : (int32_t)strlen((char*)pMsg->trigger.stateWin.expr) + 1;
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->trigger.stateWin.expr, stateWindowExprLen));
break;
}
case WINDOW_TYPE_INTERVAL: {
// slide trigger
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.sliding.intervalUnit));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.sliding.slidingUnit));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.sliding.offsetUnit));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.sliding.soffsetUnit));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.sliding.precision));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.sliding.interval));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.sliding.offset));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.sliding.sliding));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.sliding.soffset));
break;
}
case WINDOW_TYPE_EVENT: {
// event trigger
int32_t eventWindowStartCondLen = pMsg->trigger.event.startCond == NULL ? 0 : (int32_t)strlen((char*)pMsg->trigger.event.startCond) + 1;
int32_t eventWindowEndCondLen = pMsg->trigger.event.endCond == NULL ? 0 : (int32_t)strlen((char*)pMsg->trigger.event.endCond) + 1;
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->trigger.event.startCond, eventWindowStartCondLen));
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->trigger.event.endCond, eventWindowEndCondLen));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->trigger.event.trueForType));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->trigger.event.trueForCount));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.event.trueForDuration));
break;
}
case WINDOW_TYPE_COUNT: {
// count trigger
int32_t countWindowCondColsLen = pMsg->trigger.count.condCols == NULL ? 0 : (int32_t)strlen((char*)pMsg->trigger.count.condCols) + 1;
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->trigger.count.condCols, countWindowCondColsLen));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.count.countVal));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.count.sliding));
break;
}
case WINDOW_TYPE_PERIOD: {
// period trigger
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.period.periodUnit));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.period.offsetUnit));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.period.precision));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.period.period));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.period.offset));
break;
}
default:
TAOS_CHECK_EXIT(TSDB_CODE_MND_STREAM_INTERNAL_ERROR);
break;
}
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->eventTypes));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->placeHolderBitmap));
TAOS_CHECK_EXIT(tEncodeI16(pEncoder, pMsg->calcTsSlotId));
TAOS_CHECK_EXIT(tEncodeI16(pEncoder, pMsg->triTsSlotId));
TAOS_CHECK_EXIT(tEncodeI16(pEncoder, pMsg->calcPkSlotId));
TAOS_CHECK_EXIT(tEncodeI16(pEncoder, pMsg->triPkSlotId));
int32_t triggerPrevFilterLen = (pMsg->triggerPrevFilter == NULL) ? 0 : ((int32_t)strlen(pMsg->triggerPrevFilter) + 1);
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->triggerPrevFilter, triggerPrevFilterLen));
int32_t triggerScanPlanLen = (pMsg->triggerScanPlan == NULL) ? 0 : ((int32_t)strlen(pMsg->triggerScanPlan) + 1);
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->triggerScanPlan, triggerScanPlanLen));
int32_t calcCacheScanPlanLen = (pMsg->calcCacheScanPlan == NULL) ? 0 : ((int32_t)strlen(pMsg->calcCacheScanPlan) + 1);
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->calcCacheScanPlan, calcCacheScanPlanLen));
int32_t readerNum = taosArrayGetSize(pMsg->readerList);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, readerNum));
for (int32_t i = 0; i < readerNum; ++i) {
SStreamTaskAddr* pAddr = (SStreamTaskAddr*)taosArrayGet(pMsg->readerList, i);
TAOS_CHECK_EXIT(tEncodeSStreamTaskAddr(pEncoder, pAddr));
}
int32_t runnerNum = taosArrayGetSize(pMsg->runnerList);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, runnerNum));
for (int32_t i = 0; i < runnerNum; ++i) {
SStreamRunnerTarget* pTarget = (SStreamRunnerTarget*)taosArrayGet(pMsg->runnerList, i);
TAOS_CHECK_EXIT(tEncodeSStreamRunnerTarget(pEncoder, pTarget));
}
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->leaderSnodeId));
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->streamName, (int32_t)strlen(pMsg->streamName) + 1));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->precision));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->nodelayCreateSubtable));
_exit:
return code;
}
int32_t tSerializeSFieldWithOptions(SEncoder* pEncoder, const SFieldWithOptions *pField) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tEncodeCStr(pEncoder, pField->name));
TAOS_CHECK_EXIT(tEncodeU8(pEncoder, pField->type));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pField->flags));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pField->bytes));
TAOS_CHECK_EXIT(tEncodeU32(pEncoder, pField->compress));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pField->typeMod));
_exit:
return code;
}
int32_t tEncodeSStreamRunnerDeployMsg(SEncoder* pEncoder, const SStreamRunnerDeployMsg* pMsg) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->execReplica));
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->streamName, (int32_t)strlen(pMsg->streamName) + 1));
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->pPlan, NULL == pMsg->pPlan ? 0 : (int32_t)strlen(pMsg->pPlan) + 1));
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->outDBFName, NULL == pMsg->outDBFName ? 0 : (int32_t)strlen(pMsg->outDBFName) + 1));
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->outTblName, NULL == pMsg->outTblName ? 0 : (int32_t)strlen(pMsg->outTblName) + 1));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->outTblType));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->calcNotifyOnly));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->topPlan));
int32_t addrSize = (int32_t)taosArrayGetSize(pMsg->pNotifyAddrUrls);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, addrSize));
for (int32_t i = 0; i < addrSize; ++i) {
const char *url = taosArrayGetP(pMsg->pNotifyAddrUrls, i);
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, url, NULL == url ? 0 : (int32_t)strlen(url) + 1));
}
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->addOptions));
int32_t outColNum = (int32_t)taosArrayGetSize(pMsg->outCols);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, outColNum));
for (int32_t i = 0; i < outColNum; ++i) {
SFieldWithOptions *pCol = taosArrayGet(pMsg->outCols, i);
TAOS_CHECK_EXIT(tSerializeSFieldWithOptions(pEncoder, pCol));
}
int32_t outTagNum = (int32_t)taosArrayGetSize(pMsg->outTags);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, outTagNum));
for (int32_t i = 0; i < outTagNum; ++i) {
SFieldWithOptions *pTag = taosArrayGet(pMsg->outTags, i);
TAOS_CHECK_EXIT(tSerializeSFieldWithOptions(pEncoder, pTag));
}
TAOS_CHECK_EXIT(tEncodeU64(pEncoder, pMsg->outStbUid));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->outStbSversion));
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->subTblNameExpr, NULL == pMsg->subTblNameExpr ? 0 : (int32_t)strlen(pMsg->subTblNameExpr) + 1));
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->tagValueExpr, NULL == pMsg->tagValueExpr ? 0 : (int32_t)strlen(pMsg->tagValueExpr) + 1));
int32_t forceOutColsSize = (int32_t)taosArrayGetSize(pMsg->forceOutCols);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, forceOutColsSize));
for (int32_t i = 0; i < forceOutColsSize; ++i) {
SStreamOutCol *pCoutCol = (SStreamOutCol*)taosArrayGet(pMsg->forceOutCols, i);
int32_t exprLen = pCoutCol->expr == NULL ? 0 : (int32_t)strlen((char*)pCoutCol->expr) + 1;
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pCoutCol->expr, exprLen));
TAOS_CHECK_EXIT(tEncodeU8(pEncoder, pCoutCol->type.type));
TAOS_CHECK_EXIT(tEncodeU8(pEncoder, pCoutCol->type.precision));
TAOS_CHECK_EXIT(tEncodeU8(pEncoder, pCoutCol->type.scale));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pCoutCol->type.bytes));
}
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->lowLatencyCalc));
// colCids and tagCids - always encode size (0 if NULL) for compatibility
int32_t colCidsSize = (int32_t)taosArrayGetSize(pMsg->colCids);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, colCidsSize));
if (colCidsSize > 0) {
for (int32_t i = 0; i < colCidsSize; ++i) {
int16_t* pCid = (int16_t*)taosArrayGet(pMsg->colCids, i);
TAOS_CHECK_EXIT(tEncodeI16(pEncoder, *pCid));
}
}
int32_t tagCidsSize = (int32_t)taosArrayGetSize(pMsg->tagCids);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, tagCidsSize));
if (tagCidsSize > 0) {
for (int32_t i = 0; i < tagCidsSize; ++i) {
int16_t* pCid = (int16_t*)taosArrayGet(pMsg->tagCids, i);
TAOS_CHECK_EXIT(tEncodeI16(pEncoder, *pCid));
}
}
_exit:
return code;
}
int32_t tEncodeSStmTaskDeploy(SEncoder* pEncoder, const SStmTaskDeploy* pTask) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tEncodeStreamTask(pEncoder, (SStreamTask*)&pTask->task));
switch (pTask->task.type) {
case STREAM_READER_TASK:
TAOS_CHECK_EXIT(tEncodeSStreamReaderDeployMsg(pEncoder, &pTask->msg.reader));
break;
case STREAM_TRIGGER_TASK:
TAOS_CHECK_EXIT(tEncodeSStreamTriggerDeployMsg(pEncoder, &pTask->msg.trigger));
break;
case STREAM_RUNNER_TASK:
TAOS_CHECK_EXIT(tEncodeSStreamRunnerDeployMsg(pEncoder, &pTask->msg.runner));
break;
default:
TAOS_CHECK_EXIT(TSDB_CODE_MND_STREAM_INTERNAL_ERROR);
break;
}
_exit:
return code;
}
int32_t tEncodeSStmStreamDeploy(SEncoder* pEncoder, const SStmStreamDeploy* pStream) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pStream->streamId));
int32_t readerNum = taosArrayGetSize(pStream->readerTasks);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, readerNum));
for (int32_t i = 0; i < readerNum; ++i) {
SStmTaskDeploy* pDeploy = taosArrayGet(pStream->readerTasks, i);
TAOS_CHECK_EXIT(tEncodeSStmTaskDeploy(pEncoder, pDeploy));
}
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pStream->triggerTask ? 1 : 0));
if (pStream->triggerTask) {
TAOS_CHECK_EXIT(tEncodeSStmTaskDeploy(pEncoder, pStream->triggerTask));
}
int32_t runnerNum = taosArrayGetSize(pStream->runnerTasks);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, runnerNum));
for (int32_t i = 0; i < runnerNum; ++i) {
SStmTaskDeploy* pDeploy = taosArrayGet(pStream->runnerTasks, i);
TAOS_CHECK_EXIT(tEncodeSStmTaskDeploy(pEncoder, pDeploy));
}
_exit:
return code;
}
int32_t tEncodeSStreamMsg(SEncoder* pEncoder, const SStreamMsg* pMsg) {
int32_t code = 0;
int32_t lino = 0;
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->msgType));
_exit:
return code;
}
int32_t tDecodeSStreamMsg(SDecoder* pDecoder, SStreamMsg* pMsg) {
int32_t code = 0;
int32_t lino;
int32_t type = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &type));
pMsg->msgType = type;
_exit:
return code;
}
int32_t tEncodeSStreamStartTaskMsg(SEncoder* pEncoder, const SStreamStartTaskMsg* pStart) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tEncodeSStreamMsg(pEncoder, &pStart->header));
_exit:
return code;
}
int32_t tEncodeSStreamTaskStart(SEncoder* pEncoder, const SStreamTaskStart* pTask) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tEncodeStreamTask(pEncoder, (SStreamTask*)&pTask->task));
TAOS_CHECK_EXIT(tEncodeSStreamStartTaskMsg(pEncoder, (SStreamStartTaskMsg*)&pTask->startMsg));
_exit:
return code;
}
int32_t tEncodeSStreamUndeployTaskMsg(SEncoder* pEncoder, const SStreamUndeployTaskMsg* pUndeploy) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tEncodeSStreamMsg(pEncoder, &pUndeploy->header));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pUndeploy->doCheckpoint));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pUndeploy->doCleanup));
_exit:
return code;
}
int32_t tEncodeSStreamTaskUndeploy(SEncoder* pEncoder, const SStreamTaskUndeploy* pTask) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tEncodeStreamTask(pEncoder, (SStreamTask*)&pTask->task));
TAOS_CHECK_EXIT(tEncodeSStreamUndeployTaskMsg(pEncoder, (SStreamUndeployTaskMsg*)&pTask->undeployMsg));
_exit:
return code;
}
int32_t tEncodeSStreamRecalcReq(SEncoder* pEncoder, const SStreamRecalcReq* recalc) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, recalc->recalcId));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, recalc->start));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, recalc->end));
_exit:
return code;
}
int32_t tEncodeSStreamMgmtRspCont(SEncoder* pEncoder, SStreamMsgType msgType, const SStreamMgmtRspCont* pRsp) {
int32_t code = 0;
int32_t lino;
switch (msgType) {
case STREAM_MSG_ORIGTBL_READER_INFO: {
int32_t vgNum = taosArrayGetSize(pRsp->vgIds);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, vgNum));
for (int32_t i = 0; i < vgNum; ++i) {
int32_t* vgId = taosArrayGet(pRsp->vgIds, i);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, *vgId));
}
int32_t readerNum = taosArrayGetSize(pRsp->readerList);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, readerNum));
for (int32_t i = 0; i < readerNum; ++i) {
SStreamTaskAddr* addr = taosArrayGet(pRsp->readerList, i);
TAOS_CHECK_EXIT(tEncodeSStreamTaskAddr(pEncoder, addr));
}
break;
}
case STREAM_MSG_UPDATE_RUNNER: {
int32_t runnerNum = taosArrayGetSize(pRsp->runnerList);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, runnerNum));
for (int32_t i = 0; i < runnerNum; ++i) {
SStreamRunnerTarget* target = taosArrayGet(pRsp->runnerList, i);
TAOS_CHECK_EXIT(tEncodeSStreamRunnerTarget(pEncoder, target));
}
break;
}
case STREAM_MSG_USER_RECALC: {
int32_t recalcNum = taosArrayGetSize(pRsp->recalcList);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, recalcNum));
for (int32_t i = 0; i < recalcNum; ++i) {
SStreamRecalcReq* recalc = taosArrayGet(pRsp->recalcList, i);
TAOS_CHECK_EXIT(tEncodeSStreamRecalcReq(pEncoder, recalc));
}
break;
}
case STREAM_MSG_RUNNER_ORIGTBL_READER: {
int32_t rspNum = taosArrayGetSize(pRsp->execRspList);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, rspNum));
for (int32_t i = 0; i < rspNum; ++i) {
SStreamOReaderDeployRsp* pDeployRsp = taosArrayGet(pRsp->execRspList, i);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pDeployRsp->execId));
int32_t vgNum = taosArrayGetSize(pDeployRsp->vgList);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, vgNum));
for (int32_t n = 0; n < vgNum; ++n) {
TAOS_CHECK_EXIT(tEncodeSStreamTaskAddr(pEncoder, taosArrayGet(pDeployRsp->vgList, n)));
}
}
break;
}
default:
break;
}
_exit:
return code;
}
int32_t tEncodeSStreamMgmtRsp(SEncoder* pEncoder, const SStreamMgmtRsp* pRsp) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tEncodeSStreamMsg(pEncoder, &pRsp->header));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pRsp->reqId));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pRsp->code));
TAOS_CHECK_EXIT(tEncodeStreamTask(pEncoder, &pRsp->task));
TAOS_CHECK_EXIT(tEncodeSStreamMgmtRspCont(pEncoder, pRsp->header.msgType, (SStreamMgmtRspCont*)&pRsp->cont));
_exit:
return code;
}
int32_t tEncodeStreamHbRsp(SEncoder* pEncoder, const SMStreamHbRspMsg* pRsp) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tStartEncode(pEncoder));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pRsp->streamGId));
int32_t deployNum = taosArrayGetSize(pRsp->deploy.streamList);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, deployNum));
for (int32_t i = 0; i < deployNum; ++i) {
SStmStreamDeploy* pStream = (SStmStreamDeploy*)taosArrayGet(pRsp->deploy.streamList, i);
TAOS_CHECK_EXIT(tEncodeSStmStreamDeploy(pEncoder, pStream));
}
int32_t startNum = taosArrayGetSize(pRsp->start.taskList);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, startNum));
for (int32_t i = 0; i < startNum; ++i) {
SStreamTaskStart* pTask = (SStreamTaskStart*)taosArrayGet(pRsp->start.taskList, i);
TAOS_CHECK_EXIT(tEncodeSStreamTaskStart(pEncoder, pTask));
}
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pRsp->undeploy.undeployAll));
if (!pRsp->undeploy.undeployAll) {
int32_t undeployNum = taosArrayGetSize(pRsp->undeploy.taskList);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, undeployNum));
for (int32_t i = 0; i < undeployNum; ++i) {
SStreamTaskUndeploy* pTask = (SStreamTaskUndeploy*)taosArrayGet(pRsp->undeploy.taskList, i);
TAOS_CHECK_EXIT(tEncodeSStreamTaskUndeploy(pEncoder, pTask));
}
}
int32_t rspNum = taosArrayGetSize(pRsp->rsps.rspList);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, rspNum));
for (int32_t i = 0; i < rspNum; ++i) {
SStreamMgmtRsp* pMgmtRsp = (SStreamMgmtRsp*)taosArrayGet(pRsp->rsps.rspList, i);
TAOS_CHECK_EXIT(tEncodeSStreamMgmtRsp(pEncoder, pMgmtRsp));
}
_exit:
tEndEncode(pEncoder);
return code;
}
int32_t tDecodeSStreamReaderDeployFromTrigger(SDecoder* pDecoder, SStreamReaderDeployFromTrigger* pMsg) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->triggerTblName, NULL));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->triggerTblUid));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->triggerTblSuid));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->triggerTblType));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->isTriggerTblVirt));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->deleteReCalc));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->deleteOutTbl));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->partitionCols, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->triggerCols, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->triggerScanPlan, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->calcCacheScanPlan, NULL));
_exit:
return code;
}
int32_t tDecodeSStreamReaderDeployFromCalc(SDecoder* pDecoder, SStreamReaderDeployFromCalc* pMsg) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->execReplica));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->calcScanPlan, NULL));
_exit:
return code;
}
int32_t tDecodeSStreamReaderDeployMsg(SDecoder* pDecoder, SStreamReaderDeployMsg* pMsg) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->triggerReader));
if (pMsg->triggerReader) {
TAOS_CHECK_EXIT(tDecodeSStreamReaderDeployFromTrigger(pDecoder, &pMsg->msg.trigger));
} else {
TAOS_CHECK_EXIT(tDecodeSStreamReaderDeployFromCalc(pDecoder, &pMsg->msg.calc));
}
_exit:
return code;
}
int32_t tDecodeSStreamTaskAddr(SDecoder* pDecoder, SStreamTaskAddr* pMsg) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->taskId));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->nodeId));
TAOS_CHECK_EXIT(tDecodeSEpSet(pDecoder, &pMsg->epset));
_exit:
return code;
}
int32_t tDecodeSStreamRunnerTarget(SDecoder* pDecoder, SStreamRunnerTarget* pMsg) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tDecodeSStreamTaskAddr(pDecoder, &pMsg->addr));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->execReplica));
_exit:
return code;
}
int32_t tDecodeSStreamTriggerDeployMsg(SDecoder* pDecoder, SStreamTriggerDeployMsg* pMsg) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->triggerType));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->igDisorder));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->fillHistory));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->fillHistoryFirst));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->lowLatencyCalc));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->igNoDataTrigger));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->enableMultiGroupCalc));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->isTriggerTblVirt));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->triggerHasPF));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->isTriggerTblStb));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->partitionCols, NULL));
int32_t addrSize = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &addrSize));
if (addrSize > 0) {
pMsg->pNotifyAddrUrls = taosArrayInit_s(POINTER_BYTES, addrSize);
TSDB_CHECK_NULL(pMsg->pNotifyAddrUrls, code, lino, _exit, terrno);
}
for (int32_t i = 0; i < addrSize; ++i) {
const char **url = taosArrayGet(pMsg->pNotifyAddrUrls, i);
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)url, NULL));
}
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->notifyEventTypes));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->addOptions));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->notifyHistory));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->maxDelay));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->fillHistoryStartTime));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->watermark));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->expiredTime));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->idleTimeoutMs));
switch (pMsg->triggerType) {
case WINDOW_TYPE_SESSION:
// session trigger
TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pMsg->trigger.session.slotId));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.session.sessionVal));
break;
case WINDOW_TYPE_STATE:
// state trigger
TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pMsg->trigger.stateWin.slotId));
TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pMsg->trigger.stateWin.extend));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->trigger.stateWin.trueForType));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->trigger.stateWin.trueForCount));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.stateWin.trueForDuration));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->trigger.stateWin.zeroth, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->trigger.stateWin.expr, NULL));
break;
case WINDOW_TYPE_INTERVAL:
// slide trigger
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->trigger.sliding.intervalUnit));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->trigger.sliding.slidingUnit));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->trigger.sliding.offsetUnit));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->trigger.sliding.soffsetUnit));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->trigger.sliding.precision));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.sliding.interval));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.sliding.offset));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.sliding.sliding));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.sliding.soffset));
break;
case WINDOW_TYPE_EVENT:
// event trigger
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->trigger.event.startCond, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->trigger.event.endCond, NULL));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->trigger.event.trueForType));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->trigger.event.trueForCount));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.event.trueForDuration));
break;
case WINDOW_TYPE_COUNT:
// count trigger
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->trigger.count.condCols, NULL));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.count.countVal));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.count.sliding));
break;
case WINDOW_TYPE_PERIOD:
// period trigger
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, (int8_t*)&pMsg->trigger.period.periodUnit));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, (int8_t*)&pMsg->trigger.period.offsetUnit));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->trigger.period.precision));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.period.period));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.period.offset));
break;
default:
TAOS_CHECK_EXIT(TSDB_CODE_MND_STREAM_INTERNAL_ERROR);
break;
}
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->eventTypes));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->placeHolderBitmap));
TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pMsg->calcTsSlotId));
TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pMsg->triTsSlotId));
TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pMsg->calcPkSlotId));
TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pMsg->triPkSlotId));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->triggerPrevFilter, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->triggerScanPlan, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->calcCacheScanPlan, NULL));
int32_t readerNum = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &readerNum));
if (readerNum > 0) {
pMsg->readerList = taosArrayInit_s(sizeof(SStreamTaskAddr), readerNum);
TSDB_CHECK_NULL(pMsg->readerList, code, lino, _exit, terrno);
}
for (int32_t i = 0; i < readerNum; ++i) {
SStreamTaskAddr* pAddr = (SStreamTaskAddr*)taosArrayGet(pMsg->readerList, i);
TAOS_CHECK_EXIT(tDecodeSStreamTaskAddr(pDecoder, pAddr));
}
int32_t runnerNum = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &runnerNum));
if (runnerNum > 0) {
pMsg->runnerList = taosArrayInit_s(sizeof(SStreamRunnerTarget), runnerNum);
TSDB_CHECK_NULL(pMsg->runnerList, code, lino, _exit, terrno);
}
for (int32_t i = 0; i < runnerNum; ++i) {
SStreamRunnerTarget* pTarget = (SStreamRunnerTarget*)taosArrayGet(pMsg->runnerList, i);
TAOS_CHECK_EXIT(tDecodeSStreamRunnerTarget(pDecoder, pTarget));
}
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->leaderSnodeId));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->streamName, NULL));
if (!tDecodeIsEnd(pDecoder)) {
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->precision));
}
if (!tDecodeIsEnd(pDecoder)) {
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->nodelayCreateSubtable));
}
_exit:
return code;
}
int32_t tDeserializeSFieldWithOptions(SDecoder *pDecoder, SFieldWithOptions *pField) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tDecodeCStrTo(pDecoder, pField->name));
TAOS_CHECK_EXIT(tDecodeU8(pDecoder, &pField->type));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pField->flags));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pField->bytes));
TAOS_CHECK_EXIT(tDecodeU32(pDecoder, &pField->compress));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pField->typeMod));
_exit:
return code;
}
void destroySStreamOutCols(void* p){
if (p == NULL) return;
SStreamOutCol* col = (SStreamOutCol*)p;
taosMemoryFreeClear(col->expr);
}
int32_t tDecodeSStreamRunnerDeployMsg(SDecoder* pDecoder, SStreamRunnerDeployMsg* pMsg) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->execReplica));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->streamName, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->pPlan, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->outDBFName, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->outTblName, NULL));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->outTblType));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->calcNotifyOnly));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->topPlan));
int32_t addrSize = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &addrSize));
if (addrSize > 0) {
pMsg->pNotifyAddrUrls = taosArrayInit_s(POINTER_BYTES, addrSize);
TSDB_CHECK_NULL(pMsg->pNotifyAddrUrls, code, lino, _exit, terrno);
}
for (int32_t i = 0; i < addrSize; ++i) {
const char **url = taosArrayGet(pMsg->pNotifyAddrUrls, i);
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)url, NULL));
}
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->addOptions));
int32_t outColNum = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &outColNum));
if (outColNum > 0) {
pMsg->outCols = taosArrayInit_s(sizeof(SFieldWithOptions), outColNum);
TSDB_CHECK_NULL(pMsg->outCols, code, lino, _exit, terrno);
}
for (int32_t i = 0; i < outColNum; ++i) {
SFieldWithOptions *pCol = taosArrayGet(pMsg->outCols, i);
TAOS_CHECK_EXIT(tDeserializeSFieldWithOptions(pDecoder, pCol));
}
int32_t outTagNum = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &outTagNum));
if (outTagNum > 0) {
pMsg->outTags = taosArrayInit_s(sizeof(SFieldWithOptions), outTagNum);
TSDB_CHECK_NULL(pMsg->outTags, code, lino, _exit, terrno);
}
for (int32_t i = 0; i < outTagNum; ++i) {
SFieldWithOptions *pTag = taosArrayGet(pMsg->outTags, i);
TAOS_CHECK_EXIT(tDeserializeSFieldWithOptions(pDecoder, pTag));
}
TAOS_CHECK_EXIT(tDecodeU64(pDecoder, &pMsg->outStbUid));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->outStbSversion));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->subTblNameExpr, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->tagValueExpr, NULL));
int32_t forceOutColsSize = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &forceOutColsSize));
if (forceOutColsSize > 0) {
pMsg->forceOutCols = taosArrayInit_s(sizeof(SStreamOutCol), forceOutColsSize);
TSDB_CHECK_NULL(pMsg->forceOutCols, code, lino, _exit, terrno);
}
for (int32_t i = 0; i < forceOutColsSize; ++i) {
SStreamOutCol *pCoutCol = (SStreamOutCol*)taosArrayGet(pMsg->forceOutCols, i);
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pCoutCol->expr, NULL));
TAOS_CHECK_EXIT(tDecodeU8(pDecoder, &pCoutCol->type.type));
TAOS_CHECK_EXIT(tDecodeU8(pDecoder, &pCoutCol->type.precision));
TAOS_CHECK_EXIT(tDecodeU8(pDecoder, &pCoutCol->type.scale));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pCoutCol->type.bytes));
}
if (!tDecodeIsEnd(pDecoder)) {
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->lowLatencyCalc));
}
// colCids and tagCids - always decode size, create array only if size > 0
// For backward compatibility, check if there's more data before decoding
if (!tDecodeIsEnd(pDecoder)) {
int32_t colCidsSize = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &colCidsSize));
if (colCidsSize > 0 && colCidsSize <= TSDB_MAX_COLUMNS) { // Sanity check
pMsg->colCids = taosArrayInit(colCidsSize, sizeof(int16_t));
TSDB_CHECK_NULL(pMsg->colCids, code, lino, _exit, terrno);
for (int32_t i = 0; i < colCidsSize; ++i) {
int16_t cid = 0;
TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &cid));
if (taosArrayPush(pMsg->colCids, &cid) == NULL) {
TAOS_CHECK_EXIT(terrno);
}
}
}
}
// Try to decode tagCids if there's more data
if (!tDecodeIsEnd(pDecoder)) {
int32_t tagCidsSize = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &tagCidsSize));
if (tagCidsSize > 0 && tagCidsSize <= TSDB_MAX_TAGS) { // Sanity check
pMsg->tagCids = taosArrayInit(tagCidsSize, sizeof(int16_t));
TSDB_CHECK_NULL(pMsg->tagCids, code, lino, _exit, terrno);
for (int32_t i = 0; i < tagCidsSize; ++i) {
int16_t cid = 0;
TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &cid));
if (taosArrayPush(pMsg->tagCids, &cid) == NULL) {
TAOS_CHECK_EXIT(terrno);
}
}
}
}
_exit:
return code;
}
int32_t tDecodeSStmTaskDeploy(SDecoder* pDecoder, SStmTaskDeploy* pTask) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tDecodeStreamTask(pDecoder, (SStreamTask*)&pTask->task));
switch (pTask->task.type) {
case STREAM_READER_TASK:
TAOS_CHECK_EXIT(tDecodeSStreamReaderDeployMsg(pDecoder, &pTask->msg.reader));
break;
case STREAM_TRIGGER_TASK:
TAOS_CHECK_EXIT(tDecodeSStreamTriggerDeployMsg(pDecoder, &pTask->msg.trigger));
break;
case STREAM_RUNNER_TASK:
TAOS_CHECK_EXIT(tDecodeSStreamRunnerDeployMsg(pDecoder, &pTask->msg.runner));
break;
default:
TAOS_CHECK_EXIT(TSDB_CODE_MND_STREAM_INTERNAL_ERROR);
break;
}
_exit:
return code;
}
int32_t tDecodeSStmStreamDeploy(SDecoder* pDecoder, SStmStreamDeploy* pStream) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pStream->streamId));
int32_t readerNum = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &readerNum));
if (readerNum > 0) {
pStream->readerTasks = taosArrayInit_s(sizeof(SStmTaskDeploy), readerNum);
TSDB_CHECK_NULL(pStream->readerTasks, code, lino, _exit, terrno);
}
for (int32_t i = 0; i < readerNum; ++i) {
SStmTaskDeploy* pTask = taosArrayGet(pStream->readerTasks, i);
TAOS_CHECK_EXIT(tDecodeSStmTaskDeploy(pDecoder, pTask));
}
int32_t triggerTask = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &triggerTask));
if (triggerTask) {
pStream->triggerTask = taosMemoryCalloc(1, sizeof(SStmTaskDeploy));
TSDB_CHECK_NULL(pStream->triggerTask, code, lino, _exit, terrno);
TAOS_CHECK_EXIT(tDecodeSStmTaskDeploy(pDecoder, pStream->triggerTask));
}
int32_t runnerNum = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &runnerNum));
if (runnerNum > 0) {
pStream->runnerTasks = taosArrayInit_s(sizeof(SStmTaskDeploy), runnerNum);
TSDB_CHECK_NULL(pStream->runnerTasks, code, lino, _exit, terrno);
}
for (int32_t i = 0; i < runnerNum; ++i) {
SStmTaskDeploy* pTask = taosArrayGet(pStream->runnerTasks, i);
TAOS_CHECK_EXIT(tDecodeSStmTaskDeploy(pDecoder, pTask));
}
_exit:
return code;
}
int32_t tDecodeSStreamStartTaskMsg(SDecoder* pDecoder, SStreamStartTaskMsg* pStart) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tDecodeSStreamMsg(pDecoder, &pStart->header));
_exit:
return code;
}
int32_t tDecodeSStreamTaskStart(SDecoder* pDecoder, SStreamTaskStart* pTask) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tDecodeStreamTask(pDecoder, (SStreamTask*)&pTask->task));
TAOS_CHECK_EXIT(tDecodeSStreamStartTaskMsg(pDecoder, (SStreamStartTaskMsg*)&pTask->startMsg));
_exit:
return code;
}
int32_t tDecodeSStreamUndeployTaskMsg(SDecoder* pDecoder, SStreamUndeployTaskMsg* pUndeploy) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tDecodeSStreamMsg(pDecoder, &pUndeploy->header));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pUndeploy->doCheckpoint));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pUndeploy->doCleanup));
_exit:
return code;
}
int32_t tDecodeSStreamTaskUndeploy(SDecoder* pDecoder, SStreamTaskUndeploy* pTask) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tDecodeStreamTask(pDecoder, (SStreamTask*)&pTask->task));
TAOS_CHECK_EXIT(tDecodeSStreamUndeployTaskMsg(pDecoder, (SStreamUndeployTaskMsg*)&pTask->undeployMsg));
_exit:
return code;
}
int32_t tDecodeSStreamRecalcReq(SDecoder* pDecoder, SStreamRecalcReq* recalc) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &recalc->recalcId));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &recalc->start));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &recalc->end));
_exit:
return code;
}
int32_t tDecodeSStreamMgmtRspCont(SDecoder* pDecoder, SStreamMsgType msgType, SStreamMgmtRspCont* pCont) {
int32_t code = 0;
int32_t lino;
switch (msgType) {
case STREAM_MSG_ORIGTBL_READER_INFO: {
int32_t vgNum = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgNum));
if (vgNum > 0) {
pCont->vgIds = taosArrayInit_s(sizeof(int32_t), vgNum);
TSDB_CHECK_NULL(pCont->vgIds, code, lino, _exit, terrno);
}
for (int32_t i = 0; i < vgNum; ++i) {
int32_t *vgId = taosArrayGet(pCont->vgIds, i);
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, vgId));
}
int32_t readerNum = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &readerNum));
if (readerNum > 0) {
pCont->readerList = taosArrayInit_s(sizeof(SStreamTaskAddr), readerNum);
TSDB_CHECK_NULL(pCont->readerList, code, lino, _exit, terrno);
}
for (int32_t i = 0; i < readerNum; ++i) {
SStreamTaskAddr *addr = taosArrayGet(pCont->readerList, i);
TAOS_CHECK_EXIT(tDecodeSStreamTaskAddr(pDecoder, addr));
}
break;
}
case STREAM_MSG_UPDATE_RUNNER: {
int32_t runnerNum = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &runnerNum));
if (runnerNum > 0) {
pCont->runnerList = taosArrayInit_s(sizeof(SStreamRunnerTarget), runnerNum);
TSDB_CHECK_NULL(pCont->runnerList, code, lino, _exit, terrno);
}
for (int32_t i = 0; i < runnerNum; ++i) {
SStreamRunnerTarget *target = taosArrayGet(pCont->runnerList, i);
TAOS_CHECK_EXIT(tDecodeSStreamRunnerTarget(pDecoder, target));
}
break;
}
case STREAM_MSG_USER_RECALC: {
int32_t recalcNum = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &recalcNum));
if (recalcNum > 0) {
pCont->recalcList = taosArrayInit_s(sizeof(SStreamRecalcReq), recalcNum);
TSDB_CHECK_NULL(pCont->recalcList, code, lino, _exit, terrno);
}
for (int32_t i = 0; i < recalcNum; ++i) {
SStreamRecalcReq *recalc = taosArrayGet(pCont->recalcList, i);
TAOS_CHECK_EXIT(tDecodeSStreamRecalcReq(pDecoder, recalc));
}
break;
}
case STREAM_MSG_RUNNER_ORIGTBL_READER: {
int32_t rspNum = 0, vgNum = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &rspNum));
if (rspNum > 0) {
pCont->execRspList = taosArrayInit_s(sizeof(SStreamOReaderDeployRsp), rspNum);
TSDB_CHECK_NULL(pCont->execRspList, code, lino, _exit, terrno);
}
for (int32_t i = 0; i < rspNum; ++i) {
SStreamOReaderDeployRsp *pDeployRsp = taosArrayGet(pCont->execRspList, i);
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pDeployRsp->execId));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgNum));
if (vgNum > 0) {
pDeployRsp->vgList = taosArrayInit_s(sizeof(SStreamTaskAddr), vgNum);
TSDB_CHECK_NULL(pDeployRsp->vgList, code, lino, _exit, terrno);
}
for (int32_t n = 0; n < vgNum; ++n) {
SStreamTaskAddr* pAddr = taosArrayGet(pDeployRsp->vgList, n);
TAOS_CHECK_EXIT(tDecodeSStreamTaskAddr(pDecoder, pAddr));
}
}
break;
}
default:
break;
}
_exit:
return code;
}
int32_t tDecodeSStreamMgmtRsp(SDecoder* pDecoder, SStreamMgmtRsp* pRsp) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tDecodeSStreamMsg(pDecoder, &pRsp->header));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pRsp->reqId));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pRsp->code));
TAOS_CHECK_EXIT(tDecodeStreamTask(pDecoder, &pRsp->task));
TAOS_CHECK_EXIT(tDecodeSStreamMgmtRspCont(pDecoder, pRsp->header.msgType, &pRsp->cont));
_exit:
return code;
}
void tFreeSStreamOReaderDeployRsp(void* param) {
if (NULL == param) {
return;
}
SStreamOReaderDeployRsp* pRsp = (SStreamOReaderDeployRsp*)param;
taosArrayDestroy(pRsp->vgList);
}
void tFreeSStreamMgmtRsp(void* param) {
if (NULL == param) {
return;
}
SStreamMgmtRsp* pRsp = (SStreamMgmtRsp*)param;
taosArrayDestroy(pRsp->cont.vgIds);
taosArrayDestroy(pRsp->cont.readerList);
taosArrayDestroy(pRsp->cont.runnerList);
taosArrayDestroy(pRsp->cont.recalcList);
taosArrayDestroyEx(pRsp->cont.execRspList, tFreeSStreamOReaderDeployRsp);
}
void tFreeSStreamReaderDeployMsg(SStreamReaderDeployMsg* pReader) {
if (NULL == pReader) {
return;
}
if (pReader->triggerReader) {
SStreamReaderDeployFromTrigger* pMsg = (SStreamReaderDeployFromTrigger*)&pReader->msg.trigger;
taosMemoryFree(pMsg->triggerTblName);
taosMemoryFree(pMsg->partitionCols);
taosMemoryFree(pMsg->triggerCols);
taosMemoryFree(pMsg->triggerScanPlan);
taosMemoryFree(pMsg->calcCacheScanPlan);
} else {
SStreamReaderDeployFromCalc* pMsg = (SStreamReaderDeployFromCalc*)&pReader->msg.calc;
taosMemoryFree(pMsg->calcScanPlan);
}
}
void tFreeStreamNotifyUrl(void* param) {
if (NULL == param) {
return;
}
taosMemoryFree(*(void**)param);
}
void tFreeSStreamTriggerDeployMsg(SStreamTriggerDeployMsg* pTrigger) {
if (NULL == pTrigger) {
return;
}
taosArrayDestroyEx(pTrigger->pNotifyAddrUrls, tFreeStreamNotifyUrl);
switch (pTrigger->triggerType) {
case WINDOW_TYPE_STATE:
taosMemoryFree(pTrigger->trigger.stateWin.zeroth);
taosMemoryFree(pTrigger->trigger.stateWin.expr);
break;
case WINDOW_TYPE_EVENT:
taosMemoryFree(pTrigger->trigger.event.startCond);
taosMemoryFree(pTrigger->trigger.event.endCond);
break;
case WINDOW_TYPE_COUNT:
taosMemoryFree(pTrigger->trigger.count.condCols);
break;
default:
break;
}
taosMemoryFree(pTrigger->partitionCols);
taosMemoryFree(pTrigger->triggerPrevFilter);
taosMemoryFree(pTrigger->triggerScanPlan);
taosMemoryFree(pTrigger->calcCacheScanPlan);
taosArrayDestroy(pTrigger->readerList);
taosArrayDestroy(pTrigger->runnerList);
taosMemoryFree(pTrigger->streamName);
}
void tFreeSStreamOutCol(void* param) {
if (NULL == param) {
return;
}
SStreamOutCol* pOut = (SStreamOutCol*)param;
taosMemoryFree(pOut->expr);
}
void tFreeSStreamRunnerDeployMsg(SStreamRunnerDeployMsg* pRunner) {
if (NULL == pRunner) {
return;
}
taosMemoryFree(pRunner->streamName);
taosMemoryFree(pRunner->pPlan);
taosMemoryFree(pRunner->outDBFName);
taosMemoryFree(pRunner->outTblName);
taosArrayDestroyEx(pRunner->pNotifyAddrUrls, tFreeStreamNotifyUrl);
taosArrayDestroy(pRunner->outCols);
taosArrayDestroy(pRunner->outTags);
taosMemoryFree(pRunner->subTblNameExpr);
taosMemoryFree(pRunner->tagValueExpr);
taosArrayDestroyEx(pRunner->forceOutCols, tFreeSStreamOutCol);
}
void tFreeSStmTaskDeploy(void* param) {
if (NULL == param) {
return;
}
SStmTaskDeploy* pTask = (SStmTaskDeploy*)param;
switch (pTask->task.type) {
case STREAM_READER_TASK:
tFreeSStreamReaderDeployMsg(&pTask->msg.reader);
break;
case STREAM_TRIGGER_TASK:
tFreeSStreamTriggerDeployMsg(&pTask->msg.trigger);
break;
case STREAM_RUNNER_TASK:
tFreeSStreamRunnerDeployMsg(&pTask->msg.runner);
break;
default:
break;
}
}
void tFreeSStmStreamDeploy(void* param) {
if (NULL == param) {
return;
}
SStmStreamDeploy* pDeploy = (SStmStreamDeploy*)param;
int32_t readerNum = taosArrayGetSize(pDeploy->readerTasks);
for (int32_t i = 0; i < readerNum; ++i) {
SStmTaskDeploy* pReader = taosArrayGet(pDeploy->readerTasks, i);
if (!pReader->msg.reader.triggerReader && pReader->msg.reader.msg.calc.freeScanPlan) {
taosMemoryFreeClear(pReader->msg.reader.msg.calc.calcScanPlan);
}
}
taosArrayDestroy(pDeploy->readerTasks);
if (pDeploy->triggerTask) {
taosArrayDestroy(pDeploy->triggerTask->msg.trigger.readerList);
taosArrayDestroy(pDeploy->triggerTask->msg.trigger.runnerList);
taosMemoryFree(pDeploy->triggerTask);
}
int32_t runnerNum = taosArrayGetSize(pDeploy->runnerTasks);
for (int32_t i = 0; i < runnerNum; ++i) {
SStmTaskDeploy* pRunner = taosArrayGet(pDeploy->runnerTasks, i);
taosMemoryFree(pRunner->msg.runner.pPlan);
}
taosArrayDestroy(pDeploy->runnerTasks);
}
void tDeepFreeSStmStreamDeploy(void* param) {
if (NULL == param) {
return;
}
SStmStreamDeploy* pDeploy = (SStmStreamDeploy*)param;
taosArrayDestroyEx(pDeploy->readerTasks, tFreeSStmTaskDeploy);
tFreeSStmTaskDeploy(pDeploy->triggerTask);
taosMemoryFree(pDeploy->triggerTask);
taosArrayDestroyEx(pDeploy->runnerTasks, tFreeSStmTaskDeploy);
}
void tFreeSMStreamHbRspMsg(SMStreamHbRspMsg* pRsp) {
if (NULL == pRsp) {
return;
}
taosArrayDestroyEx(pRsp->deploy.streamList, tFreeSStmStreamDeploy);
taosArrayDestroy(pRsp->start.taskList);
taosArrayDestroy(pRsp->undeploy.taskList);
taosArrayDestroyEx(pRsp->rsps.rspList, tFreeSStreamMgmtRsp);
}
void tDeepFreeSMStreamHbRspMsg(SMStreamHbRspMsg* pRsp) {
if (NULL == pRsp) {
return;
}
taosArrayDestroyEx(pRsp->deploy.streamList, tDeepFreeSStmStreamDeploy);
taosArrayDestroy(pRsp->start.taskList);
taosArrayDestroy(pRsp->undeploy.taskList);
taosArrayDestroyEx(pRsp->rsps.rspList, tFreeSStreamMgmtRsp);
}
int32_t tDecodeStreamHbRsp(SDecoder* pDecoder, SMStreamHbRspMsg* pRsp) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tStartDecode(pDecoder));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pRsp->streamGId));
int32_t deployNum = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &deployNum));
if (deployNum > 0) {
pRsp->deploy.streamList = taosArrayInit_s(sizeof(SStmStreamDeploy), deployNum);
TSDB_CHECK_NULL(pRsp->deploy.streamList, code, lino, _exit, terrno);
}
for (int32_t i = 0; i < deployNum; ++i) {
SStmStreamDeploy* pStream = taosArrayGet(pRsp->deploy.streamList, i);
TAOS_CHECK_EXIT(tDecodeSStmStreamDeploy(pDecoder, pStream));
}
int32_t startNum = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &startNum));
if (startNum > 0) {
pRsp->start.taskList = taosArrayInit_s(sizeof(SStreamTaskStart), startNum);
TSDB_CHECK_NULL(pRsp->start.taskList, code, lino, _exit, terrno);
}
for (int32_t i = 0; i < startNum; ++i) {
SStreamTaskStart* pTask = (SStreamTaskStart*)taosArrayGet(pRsp->start.taskList, i);
TAOS_CHECK_EXIT(tDecodeSStreamTaskStart(pDecoder, pTask));
}
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pRsp->undeploy.undeployAll));
if (!pRsp->undeploy.undeployAll) {
int32_t undeployNum = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &undeployNum));
if (undeployNum > 0) {
pRsp->undeploy.taskList = taosArrayInit_s(sizeof(SStreamTaskUndeploy), undeployNum);
TSDB_CHECK_NULL(pRsp->undeploy.taskList, code, lino, _exit, terrno);
}
for (int32_t i = 0; i < undeployNum; ++i) {
SStreamTaskUndeploy* pTask = (SStreamTaskUndeploy*)taosArrayGet(pRsp->undeploy.taskList, i);
TAOS_CHECK_EXIT(tDecodeSStreamTaskUndeploy(pDecoder, pTask));
}
}
int32_t rspNum = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &rspNum));
if (rspNum > 0) {
pRsp->rsps.rspList = taosArrayInit_s(sizeof(SStreamMgmtRsp), rspNum);
TSDB_CHECK_NULL(pRsp->rsps.rspList, code, lino, _exit, terrno);
for (int32_t i = 0; i < rspNum; ++i) {
SStreamMgmtRsp* pMgmtRsp = (SStreamMgmtRsp*)taosArrayGet(pRsp->rsps.rspList, i);
TAOS_CHECK_EXIT(tDecodeSStreamMgmtRsp(pDecoder, pMgmtRsp));
}
}
tEndDecode(pDecoder);
_exit:
return code;
}
int32_t tEncodeStreamTaskRunReq (SEncoder* pEncoder, const SStreamTaskRunReq* pReq) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tStartEncode(pEncoder));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pReq->streamId));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->taskId));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->reqType));
tEndEncode(pEncoder);
_exit:
return code;
}
int32_t tDecodeStreamTaskRunReq(SDecoder* pDecoder, SStreamTaskRunReq* pReq) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tStartDecode(pDecoder));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->streamId));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->taskId));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->reqType));
tEndDecode(pDecoder);
_exit:
return code;
}
int32_t tEncodeStreamTaskStopReq(SEncoder* pEncoder, const SStreamTaskStopReq* pReq) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tStartEncode(pEncoder));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pReq->streamId));
tEndEncode(pEncoder);
_exit:
return code;
}
int32_t tDecodeStreamTaskStopReq(SDecoder* pDecoder, SStreamTaskStopReq* pReq) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tStartDecode(pDecoder));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->streamId));
tEndDecode(pDecoder);
_exit:
return code;
}
int32_t tSerializeSCMCreateStreamReqImpl(SEncoder* pEncoder, const SCMCreateStreamReq *pReq) {
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
char* json = NULL;
int32_t jsonLen = 0;
TAOS_CHECK_EXIT(scmCreateStreamReqToJson(pReq, false, &json, &jsonLen));
TAOS_CHECK_EXIT(tEncodeCStrWithLen(pEncoder, json, jsonLen));
_exit:
taosMemoryFreeClear(json);
if (code) {
return code;
}
return 0;
}
int32_t tSerializeSCMCreateStreamReq(void *buf, int32_t bufLen, const SCMCreateStreamReq *pReq) {
SEncoder encoder = {0};
tEncoderInit(&encoder, buf, bufLen);
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tSerializeSCMCreateStreamReqImpl(&encoder, pReq));
tEndEncode(&encoder);
_exit:
if (code) {
tEncoderClear(&encoder);
return code;
} else {
int32_t tlen = encoder.pos;
tEncoderClear(&encoder);
return tlen;
}
return 0;
}
// Old version deserialization for backward compatibility,
// especially for stream version number 7
int32_t tDeserializeSCMCreateStreamReqImplOld(SDecoder *pDecoder, SCMCreateStreamReq *pReq, int32_t leftBytes) {
int32_t code = 0;
int32_t lino;
pReq->calcPkSlotId = -1;
pReq->triPkSlotId = -1;
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->streamId));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->name, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->sql, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->outDB, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->streamDB, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->triggerDB, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->triggerTblName, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->outTblName, NULL));
int32_t calcDbSize = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &calcDbSize));
pReq->calcDB = taosArrayInit(calcDbSize, POINTER_BYTES);
if (pReq->calcDB == NULL) {
TAOS_CHECK_EXIT(terrno);
}
for (int32_t i = 0; i < calcDbSize; ++i) {
char *calcDb = NULL;
TAOS_CHECK_EXIT(tDecodeCStr(pDecoder, &calcDb));
calcDb = taosStrndup(calcDb, TSDB_DB_FNAME_LEN);
if (calcDb == NULL) {
TAOS_CHECK_EXIT(terrno);
}
if (taosArrayPush(pReq->calcDB, &calcDb) == NULL) {
taosMemoryFree(calcDb);
TAOS_CHECK_EXIT(terrno);
}
}
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->igExists));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->triggerType));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->igDisorder));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->deleteReCalc));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->deleteOutTbl));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->fillHistory));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->fillHistoryFirst));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->calcNotifyOnly));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->lowLatencyCalc));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->igNoDataTrigger));
int32_t addrSize = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &addrSize));
if (addrSize > 0) {
pReq->pNotifyAddrUrls = taosArrayInit(addrSize, POINTER_BYTES);
if (pReq->pNotifyAddrUrls == NULL) {
TAOS_CHECK_EXIT(terrno);
}
}
for (int32_t i = 0; i < addrSize; ++i) {
char *url = NULL;
TAOS_CHECK_EXIT(tDecodeCStr(pDecoder, &url));
url = taosStrndup(url, TSDB_STREAM_NOTIFY_URL_LEN);
if (url == NULL) {
TAOS_CHECK_EXIT(terrno);
}
if (taosArrayPush(pReq->pNotifyAddrUrls, &url) == NULL) {
taosMemoryFree(url);
TAOS_CHECK_EXIT(terrno);
}
}
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->notifyEventTypes));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->addOptions));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->notifyHistory));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->triggerFilterCols, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->triggerCols, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->partitionCols, NULL));
int32_t outColSize = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &outColSize));
if (outColSize > 0) {
pReq->outCols = taosArrayInit_s(sizeof(SFieldWithOptions), outColSize);
if (pReq->outCols == NULL) {
TAOS_CHECK_EXIT(terrno);
}
for (int32_t i = 0; i < outColSize; ++i) {
SFieldWithOptions* pField = taosArrayGet(pReq->outCols, i);
TAOS_CHECK_EXIT(tDeserializeSFieldWithOptions(pDecoder, pField));
}
}
int32_t outTagSize = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &outTagSize));
if (outTagSize > 0) {
pReq->outTags = taosArrayInit(outTagSize, sizeof(SFieldWithOptions));
if (pReq->outTags == NULL) {
TAOS_CHECK_EXIT(terrno);
}
for (int32_t i = 0; i < outTagSize; ++i) {
SFieldWithOptions field = {0};
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &field.type));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &field.flags));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &field.bytes));
TAOS_CHECK_EXIT(tDecodeCStrTo(pDecoder, field.name));
if (taosArrayPush(pReq->outTags, &field) == NULL) {
TAOS_CHECK_EXIT(terrno);
}
}
}
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->maxDelay));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->fillHistoryStartTime));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->watermark));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->expiredTime));
switch (pReq->triggerType) {
case WINDOW_TYPE_SESSION: {
// session trigger
TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pReq->trigger.session.slotId));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.session.sessionVal));
break;
}
case WINDOW_TYPE_STATE: {
// state trigger
TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pReq->trigger.stateWin.slotId));
pReq->trigger.stateWin.extend = 0;
pReq->trigger.stateWin.trueForType = 0;
pReq->trigger.stateWin.trueForCount = 0;
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.stateWin.trueForDuration));
break;
}
case WINDOW_TYPE_INTERVAL: {
// slide trigger
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->trigger.sliding.intervalUnit));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->trigger.sliding.slidingUnit));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->trigger.sliding.offsetUnit));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->trigger.sliding.soffsetUnit));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->trigger.sliding.precision));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.sliding.interval));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.sliding.offset));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.sliding.sliding));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.sliding.soffset));
break;
}
case WINDOW_TYPE_EVENT: {
// event trigger
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->trigger.event.startCond, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->trigger.event.endCond, NULL));
pReq->trigger.event.trueForType = 0;
pReq->trigger.event.trueForCount = 0;
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.event.trueForDuration));
break;
}
case WINDOW_TYPE_COUNT: {
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->trigger.count.condCols, NULL));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.count.countVal));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.count.sliding));
break;
}
case WINDOW_TYPE_PERIOD: {
// period trigger
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->trigger.period.precision));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->trigger.period.periodUnit));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->trigger.period.offsetUnit));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.period.period));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.period.offset));
break;
}
default:
TAOS_CHECK_EXIT(TSDB_CODE_INVALID_MSG);
}
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->triggerTblType));
TAOS_CHECK_EXIT(tDecodeU64(pDecoder, &pReq->triggerTblUid));
TAOS_CHECK_EXIT(tDecodeU64(pDecoder, &pReq->triggerTblSuid));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->vtableCalc));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->outTblType));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->outStbExists));
TAOS_CHECK_EXIT(tDecodeU64(pDecoder, &pReq->outStbUid));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->outStbSversion));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->eventTypes));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->flags));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->tsmaId));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->placeHolderBitmap));
TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pReq->calcTsSlotId));
TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pReq->triTsSlotId));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->triggerTblVgId));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->outTblVgId));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->triggerScanPlan, NULL));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->triggerHasPF));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->triggerPrevFilter, NULL));
int32_t calcScanPlanListSize = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &calcScanPlanListSize));
if (calcScanPlanListSize > 0) {
pReq->calcScanPlanList = taosArrayInit(calcScanPlanListSize, sizeof(SStreamCalcScan));
if (pReq->calcScanPlanList == NULL) {
TAOS_CHECK_EXIT(terrno);
}
for (int32_t i = 0; i < calcScanPlanListSize; ++i) {
SStreamCalcScan calcScan = {0};
int32_t vgListSize = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgListSize));
if (vgListSize > 0) {
calcScan.vgList = taosArrayInit(vgListSize, sizeof(int32_t));
if (calcScan.vgList == NULL) {
TAOS_CHECK_EXIT(terrno);
}
for (int32_t j = 0; j < vgListSize; ++j) {
int32_t vgId = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgId));
if (taosArrayPush(calcScan.vgList, &vgId) == NULL) {
TAOS_CHECK_EXIT(terrno);
}
}
}
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &calcScan.readFromCache));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&calcScan.scanPlan, NULL));
if (taosArrayPush(pReq->calcScanPlanList, &calcScan) == NULL) {
TAOS_CHECK_EXIT(terrno);
}
}
}
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->numOfCalcSubplan));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->calcPlan, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->subTblNameExpr, NULL));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->tagValueExpr, NULL));
int32_t forceOutColsSize = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &forceOutColsSize));
if (forceOutColsSize > 0) {
pReq->forceOutCols = taosArrayInit(forceOutColsSize, sizeof(SStreamOutCol));
if (pReq->forceOutCols == NULL) {
TAOS_CHECK_EXIT(terrno);
}
for (int32_t i = 0; i < forceOutColsSize; ++i) {
SStreamOutCol outCol = {0};
int64_t exprLen = 0;
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&outCol.expr, &exprLen));
TAOS_CHECK_EXIT(tDecodeU8(pDecoder, &outCol.type.type));
TAOS_CHECK_EXIT(tDecodeU8(pDecoder, &outCol.type.precision));
TAOS_CHECK_EXIT(tDecodeU8(pDecoder, &outCol.type.scale));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &outCol.type.bytes));
if (taosArrayPush(pReq->forceOutCols, &outCol) == NULL) {
TAOS_CHECK_EXIT(terrno);
}
}
}
// LeftBytes is the size of all fields at the tail of SStreamObj.
// If there are more data in the buffer, then it means
// the new fields are added in SStreamObj, need to decode them.
if (pDecoder->size - pDecoder->pos > leftBytes) {
switch (pReq->triggerType) {
case WINDOW_TYPE_STATE: {
// state trigger
if (!tDecodeIsEnd(pDecoder)) {
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->trigger.stateWin.expr, NULL));
}
if (!tDecodeIsEnd(pDecoder)) {
TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pReq->trigger.stateWin.extend));
}
break;
}
case WINDOW_TYPE_INTERVAL: {
if (!tDecodeIsEnd(pDecoder)) {
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->trigger.sliding.overlap));
}
break;
}
default:
break;
}
}
if (pDecoder->size - pDecoder->pos > leftBytes) {
if (!tDecodeIsEnd(pDecoder)) {
TAOS_CHECK_EXIT(tDecodeU8(pDecoder, &pReq->triggerPrec));
}
}
_exit:
return code;
}
// New deserialization using JSON
// start from taosd ver-3.3.8.6, stream version number 8
int32_t tDeserializeSCMCreateStreamReqImpl(SDecoder *pDecoder, SCMCreateStreamReq *pReq) {
int32_t code = 0;
int32_t lino;
char* json = NULL;
SJson* pJson = NULL;
TAOS_CHECK_EXIT(tDecodeCStrAlloc(pDecoder, &json));
pJson = tjsonParse(json);
if (pJson == NULL) {
TAOS_CHECK_EXIT(TSDB_CODE_MND_STREAM_INVALID_JSON);
}
TAOS_CHECK_EXIT(jsonToSCMCreateStreamReq(pJson, pReq));
_exit:
taosMemoryFreeClear(json);
if (NULL != pJson) {
tjsonDelete(pJson);
}
return code;
}
int32_t tDeserializeSCMCreateStreamReq(void *buf, int32_t bufLen, SCMCreateStreamReq *pReq) {
SDecoder decoder = {0};
tDecoderInit(&decoder, buf, bufLen);
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tStartDecode(&decoder));
code = tDeserializeSCMCreateStreamReqImpl(&decoder, pReq);
if (TSDB_CODE_MND_STREAM_INVALID_JSON == code) {
uError("invalid json for stream create request, try old deserialization");
// try old deserialization for backward compatibility
tDecoderClear(&decoder);
tDecoderInit(&decoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDeserializeSCMCreateStreamReqImplOld(&decoder, pReq, 0));
}
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return code;
}
int32_t tSerializeSMDropStreamReq(void *buf, int32_t bufLen, const SMDropStreamReq *pReq) {
int32_t code = 0;
int32_t lino;
int32_t tlen;
SEncoder encoder = {0};
tEncoderInit(&encoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->count));
for (int32_t i = 0; i < pReq->count; i++) {
int32_t nameLen = pReq->name[i] == NULL ? 0 : (int32_t)strlen(pReq->name[i]) + 1;
TAOS_CHECK_EXIT(tEncodeBinary(&encoder, pReq->name[i], nameLen));
}
TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->igNotExists));
tEndEncode(&encoder);
_exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
int32_t tDeserializeSMDropStreamReq(void *buf, int32_t bufLen, SMDropStreamReq *pReq) {
SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->count));
if (pReq->count > 0) {
pReq->name = taosMemoryCalloc(pReq->count, sizeof(char*));
if (pReq->name == NULL) {
code = terrno;
goto _exit;
}
for (int32_t i = 0; i < pReq->count; i++) {
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void**)&pReq->name[i], NULL));
}
}
TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->igNotExists));
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return code;
}
void tFreeMDropStreamReq(SMDropStreamReq *pReq) {
if (NULL == pReq) {
return;
}
if (pReq->name) {
for (int32_t i = 0; i < pReq->count; i++) {
taosMemoryFreeClear(pReq->name[i]);
}
taosMemoryFreeClear(pReq->name);
}
}
static FORCE_INLINE void tFreeStreamCalcScan(void* pScan) {
if (pScan == NULL) {
return;
}
SStreamCalcScan *pCalcScan = (SStreamCalcScan *)pScan;
taosArrayDestroy(pCalcScan->vgList);
taosMemoryFreeClear(pCalcScan->scanPlan);
}
void tFreeStreamOutCol(void* pCol) {
if (pCol == NULL) {
return;
}
SStreamOutCol *pOutCol = (SStreamOutCol *)pCol;
taosMemoryFreeClear(pOutCol->expr);
}
void tFreeSCMCreateStreamReq(SCMCreateStreamReq *pReq) {
if (NULL == pReq) {
return;
}
taosMemoryFreeClear(pReq->name);
taosMemoryFreeClear(pReq->sql);
taosMemoryFreeClear(pReq->streamDB);
taosMemoryFreeClear(pReq->triggerDB);
taosMemoryFreeClear(pReq->outDB);
taosMemoryFreeClear(pReq->triggerTblName);
taosMemoryFreeClear(pReq->outTblName);
taosArrayDestroyP(pReq->calcDB, NULL);
pReq->calcDB = NULL;
taosArrayDestroyP(pReq->pNotifyAddrUrls, NULL);
pReq->pNotifyAddrUrls = NULL;
taosMemoryFreeClear(pReq->triggerFilterCols);
taosMemoryFreeClear(pReq->triggerCols);
taosMemoryFreeClear(pReq->partitionCols);
taosArrayDestroy(pReq->outTags);
pReq->outTags = NULL;
taosArrayDestroy(pReq->outCols);
pReq->outCols = NULL;
switch (pReq->triggerType) {
case WINDOW_TYPE_STATE:
taosMemoryFreeClear(pReq->trigger.stateWin.zeroth);
taosMemoryFreeClear(pReq->trigger.stateWin.expr);
break;
case WINDOW_TYPE_EVENT:
taosMemoryFreeClear(pReq->trigger.event.startCond);
taosMemoryFreeClear(pReq->trigger.event.endCond);
break;
default:
break;
}
taosMemoryFreeClear(pReq->triggerScanPlan);
taosArrayDestroyEx(pReq->calcScanPlanList, tFreeStreamCalcScan);
pReq->calcScanPlanList = NULL;
taosMemoryFreeClear(pReq->triggerPrevFilter);
taosMemoryFreeClear(pReq->calcPlan);
taosMemoryFreeClear(pReq->subTblNameExpr);
taosMemoryFreeClear(pReq->tagValueExpr);
taosArrayDestroyEx(pReq->forceOutCols, tFreeStreamOutCol);
pReq->forceOutCols = NULL;
taosArrayDestroy(pReq->colCids);
pReq->colCids = NULL;
taosArrayDestroy(pReq->tagCids);
pReq->tagCids = NULL;
}
int32_t tCloneStreamCreateDeployPointers(SCMCreateStreamReq *pSrc, SCMCreateStreamReq** ppDst) {
int32_t code = 0, lino = 0;
if (NULL == pSrc) {
return code;
}
void* p = NULL;
int32_t num = 0;
*ppDst = taosMemoryCalloc(1, sizeof(SCMCreateStreamReq));
TSDB_CHECK_NULL(*ppDst, code, lino, _exit, terrno);
SCMCreateStreamReq* pDst = *ppDst;
if (pSrc->outDB) {
pDst->outDB = COPY_STR(pSrc->outDB);
TSDB_CHECK_NULL(pDst->outDB, code, lino, _exit, terrno);
}
if (pSrc->triggerTblName) {
pDst->triggerTblName = COPY_STR(pSrc->triggerTblName);
TSDB_CHECK_NULL(pDst->triggerTblName, code, lino, _exit, terrno);
}
if (pSrc->outTblName) {
pDst->outTblName = COPY_STR(pSrc->outTblName);
TSDB_CHECK_NULL(pDst->outTblName, code, lino, _exit, terrno);
}
if (pSrc->pNotifyAddrUrls) {
num = taosArrayGetSize(pSrc->pNotifyAddrUrls);
if (num > 0) {
pDst->pNotifyAddrUrls = taosArrayInit(num, POINTER_BYTES);
TSDB_CHECK_NULL(pDst->pNotifyAddrUrls, code, lino, _exit, terrno);
}
for (int32_t i = 0; i < num; ++i) {
p = taosStrdup(taosArrayGetP(pSrc->pNotifyAddrUrls, i));
TSDB_CHECK_NULL(p, code, lino, _exit, terrno);
TSDB_CHECK_NULL(taosArrayPush(pDst->pNotifyAddrUrls, &p), code, lino, _exit, terrno);
}
}
if (pSrc->triggerFilterCols) {
pDst->triggerFilterCols = COPY_STR(pSrc->triggerFilterCols);
TSDB_CHECK_NULL(pDst->triggerFilterCols, code, lino, _exit, terrno);
}
if (pSrc->triggerCols) {
pDst->triggerCols = COPY_STR(pSrc->triggerCols);
TSDB_CHECK_NULL(pDst->triggerCols, code, lino, _exit, terrno);
}
if (pSrc->partitionCols) {
pDst->partitionCols = COPY_STR(pSrc->partitionCols);
TSDB_CHECK_NULL(pDst->partitionCols, code, lino, _exit, terrno);
}
if (pSrc->outCols) {
pDst->outCols = taosArrayDup(pSrc->outCols, NULL);
TSDB_CHECK_NULL(pDst->outCols, code, lino, _exit, terrno);
}
if (pSrc->outTags) {
pDst->outTags = taosArrayDup(pSrc->outTags, NULL);
TSDB_CHECK_NULL(pDst->outTags, code, lino, _exit, terrno);
}
pDst->triggerType = pSrc->triggerType;
switch (pSrc->triggerType) {
case WINDOW_TYPE_STATE:
pDst->trigger.stateWin.slotId = pSrc->trigger.stateWin.slotId;
pDst->trigger.stateWin.extend = pSrc->trigger.stateWin.extend;
pDst->trigger.stateWin.trueForType = pSrc->trigger.stateWin.trueForType;
pDst->trigger.stateWin.trueForCount = pSrc->trigger.stateWin.trueForCount;
pDst->trigger.stateWin.trueForDuration = pSrc->trigger.stateWin.trueForDuration;
if (pSrc->trigger.stateWin.zeroth) {
pDst->trigger.stateWin.zeroth = COPY_STR(pSrc->trigger.stateWin.zeroth);
TSDB_CHECK_NULL(pDst->trigger.stateWin.zeroth, code, lino, _exit, terrno);
}
if (pSrc->trigger.stateWin.expr) {
pDst->trigger.stateWin.expr = COPY_STR(pSrc->trigger.stateWin.expr);
TSDB_CHECK_NULL(pDst->trigger.stateWin.expr, code, lino, _exit, terrno);
}
break;
case WINDOW_TYPE_EVENT:
if (pSrc->trigger.event.startCond) {
pDst->trigger.event.startCond = COPY_STR(pSrc->trigger.event.startCond);
TSDB_CHECK_NULL(pDst->trigger.event.startCond, code, lino, _exit, terrno);
}
if (pSrc->trigger.event.endCond) {
pDst->trigger.event.endCond = COPY_STR(pSrc->trigger.event.endCond);
TSDB_CHECK_NULL(pDst->trigger.event.endCond, code, lino, _exit, terrno);
}
pDst->trigger.event.trueForType = pSrc->trigger.event.trueForType;
pDst->trigger.event.trueForCount = pSrc->trigger.event.trueForCount;
pDst->trigger.event.trueForDuration = pSrc->trigger.event.trueForDuration;
break;
case WINDOW_TYPE_COUNT:
pDst->trigger.count.countVal = pSrc->trigger.count.countVal;
pDst->trigger.count.sliding = pSrc->trigger.count.sliding;
if (pSrc->trigger.count.condCols) {
pDst->trigger.count.condCols = COPY_STR(pSrc->trigger.count.condCols);
TSDB_CHECK_NULL(pDst->trigger.count.condCols, code, lino, _exit, terrno);
}
break;
default:
pDst->trigger = pSrc->trigger;
break;
}
if (pSrc->triggerScanPlan) {
pDst->triggerScanPlan = COPY_STR(pSrc->triggerScanPlan);
TSDB_CHECK_NULL(pDst->triggerScanPlan, code, lino, _exit, terrno);
}
if (pSrc->calcScanPlanList) {
num = taosArrayGetSize(pSrc->calcScanPlanList);
if (num > 0) {
pDst->calcScanPlanList = taosArrayInit(num, sizeof(SStreamCalcScan));
TSDB_CHECK_NULL(pDst->calcScanPlanList, code, lino, _exit, terrno);
}
for (int32_t i = 0; i < num; ++i) {
SStreamCalcScan* sscan = taosArrayGet(pSrc->calcScanPlanList, i);
SStreamCalcScan dscan = {.readFromCache = sscan->readFromCache};
dscan.vgList = taosArrayDup(sscan->vgList, NULL);
TSDB_CHECK_NULL(dscan.vgList, code, lino, _exit, terrno);
dscan.scanPlan = COPY_STR(sscan->scanPlan);
TSDB_CHECK_NULL(dscan.scanPlan, code, lino, _exit, terrno);
TSDB_CHECK_NULL(taosArrayPush(pDst->calcScanPlanList, &dscan), code, lino, _exit, terrno);
}
}
if (pSrc->triggerPrevFilter) {
pDst->triggerPrevFilter = COPY_STR(pSrc->triggerPrevFilter);
TSDB_CHECK_NULL(pDst->triggerPrevFilter, code, lino, _exit, terrno);
}
if (pSrc->calcPlan) {
pDst->calcPlan = COPY_STR(pSrc->calcPlan);
TSDB_CHECK_NULL(pDst->calcPlan, code, lino, _exit, terrno);
}
if (pSrc->subTblNameExpr) {
pDst->subTblNameExpr = COPY_STR(pSrc->subTblNameExpr);
TSDB_CHECK_NULL(pDst->subTblNameExpr, code, lino, _exit, terrno);
}
if (pSrc->tagValueExpr) {
pDst->tagValueExpr = COPY_STR(pSrc->tagValueExpr);
TSDB_CHECK_NULL(pDst->tagValueExpr, code, lino, _exit, terrno);
}
if (pSrc->forceOutCols) {
num = taosArrayGetSize(pSrc->forceOutCols);
if (num > 0) {
pDst->forceOutCols = taosArrayInit(num, sizeof(SStreamOutCol));
TSDB_CHECK_NULL(pDst->forceOutCols, code, lino, _exit, terrno);
}
for (int32_t i = 0; i < num; ++i) {
SStreamOutCol* scol = taosArrayGet(pSrc->forceOutCols, i);
SStreamOutCol dcol = {.type = scol->type};
dcol.expr = COPY_STR(scol->expr);
TSDB_CHECK_NULL(dcol.expr, code, lino, _exit, terrno);
TSDB_CHECK_NULL(taosArrayPush(pDst->forceOutCols, &dcol), code, lino, _exit, terrno);
}
}
if (pSrc->colCids) {
pDst->colCids = taosArrayDup(pSrc->colCids, NULL);
TSDB_CHECK_NULL(pDst->colCids, code, lino, _exit, terrno);
}
if (pSrc->tagCids) {
pDst->tagCids = taosArrayDup(pSrc->tagCids, NULL);
TSDB_CHECK_NULL(pDst->tagCids, code, lino, _exit, terrno);
}
pDst->triggerTblUid = pSrc->triggerTblUid;
pDst->triggerTblSuid = pSrc->triggerTblSuid;
pDst->triggerTblType = pSrc->triggerTblType;
pDst->triggerPrec = pSrc->triggerPrec;
pDst->deleteReCalc = pSrc->deleteReCalc;
pDst->deleteOutTbl = pSrc->deleteOutTbl;
pDst->flags = pSrc->flags;
_exit:
if (code) {
tFreeSCMCreateStreamReq(pDst);
uError("%s failed at line %d since %s", __FUNCTION__, lino, tstrerror(code));
}
return code;
}
int32_t tSerializeSMPauseStreamReq(void *buf, int32_t bufLen, const SMPauseStreamReq *pReq) {
int32_t code = 0;
int32_t lino;
int32_t tlen;
SEncoder encoder = {0};
tEncoderInit(&encoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartEncode(&encoder));
int32_t nameLen = pReq->name == NULL ? 0 : (int32_t)strlen(pReq->name) + 1;
TAOS_CHECK_EXIT(tEncodeBinary(&encoder, pReq->name, nameLen));
TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->igNotExists));
tEndEncode(&encoder);
_exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
int32_t tDeserializeSMPauseStreamReq(void *buf, int32_t bufLen, SMPauseStreamReq *pReq) {
SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void**)&pReq->name, NULL));
TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->igNotExists));
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return code;
}
void tFreeMPauseStreamReq(SMPauseStreamReq *pReq) {
taosMemoryFreeClear(pReq->name);
}
int32_t tSerializeSMResumeStreamReq(void *buf, int32_t bufLen, const SMResumeStreamReq *pReq) {
SEncoder encoder = {0};
int32_t code = 0;
int32_t lino;
int32_t tlen;
tEncoderInit(&encoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartEncode(&encoder));
int32_t nameLen = pReq->name == NULL ? 0 : (int32_t)strlen(pReq->name) + 1;
TAOS_CHECK_EXIT(tEncodeBinary(&encoder, pReq->name, nameLen));
TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->igNotExists));
TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->igUntreated));
tEndEncode(&encoder);
_exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
int32_t tDeserializeSMResumeStreamReq(void *buf, int32_t bufLen, SMResumeStreamReq *pReq) {
SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void**)&pReq->name, NULL));
TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->igNotExists));
TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->igUntreated));
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return code;
}
void tFreeMResumeStreamReq(SMResumeStreamReq *pReq) {
taosMemoryFreeClear(pReq->name);
}
int32_t tSerializeSMRecalcStreamReq(void *buf, int32_t bufLen, const SMRecalcStreamReq *pReq) {
SEncoder encoder = {0};
int32_t code = 0;
int32_t lino;
int32_t tlen;
tEncoderInit(&encoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartEncode(&encoder));
int32_t nameLen = pReq->name == NULL ? 0 : (int32_t)strlen(pReq->name) + 1;
TAOS_CHECK_EXIT(tEncodeBinary(&encoder, pReq->name, nameLen));
TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->calcAll));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->timeRange.skey));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->timeRange.ekey));
tEndEncode(&encoder);
_exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
int32_t tDeserializeSMRecalcStreamReq(void *buf, int32_t bufLen, SMRecalcStreamReq *pReq) {
SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void**)&pReq->name, NULL));
TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->calcAll));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->timeRange.skey));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->timeRange.ekey));
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return code;
}
void tFreeMRecalcStreamReq(SMRecalcStreamReq *pReq) {
taosMemoryFreeClear(pReq->name);
}
static int32_t tEncodeStreamProgressReq(SEncoder *pEncoder, const SStreamProgressReq *pReq) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pReq->streamId));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pReq->taskId));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->fetchIdx));
_exit:
return code;
}
int32_t tSerializeStreamProgressReq(void *buf, int32_t bufLen, const SStreamProgressReq *pReq) {
SEncoder encoder = {0};
int32_t code = 0;
int32_t lino;
int32_t tlen;
tEncoderInit(&encoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tEncodeStreamProgressReq(&encoder, pReq));
tEndEncode(&encoder);
_exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
static int32_t tDecodeStreamProgressReq(SDecoder *pDecoder, SStreamProgressReq *pReq) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->streamId));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->taskId));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->fetchIdx));
_exit:
return code;
}
int32_t tDeserializeStreamProgressReq(void *buf, int32_t bufLen, SStreamProgressReq *pReq) {
SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, (char *)buf, bufLen);
TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDecodeStreamProgressReq(&decoder, pReq));
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return code;
}
static int32_t tEncodeStreamProgressRsp(SEncoder *pEncoder, const SStreamProgressRsp *pRsp) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pRsp->streamId));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pRsp->fillHisFinished));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pRsp->progressDelay));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pRsp->fetchIdx));
_exit:
return code;
}
int32_t tSerializeStreamProgressRsp(void *buf, int32_t bufLen, const SStreamProgressRsp *pRsp) {
SEncoder encoder = {0};
int32_t code = 0;
int32_t lino;
int32_t tlen;
tEncoderInit(&encoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tEncodeStreamProgressRsp(&encoder, pRsp));
tEndEncode(&encoder);
_exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
static int32_t tDecodeStreamProgressRsp(SDecoder *pDecoder, SStreamProgressRsp *pRsp) {
int32_t code = 0;
int32_t lino;
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pRsp->streamId));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, (int8_t *)&pRsp->fillHisFinished));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pRsp->progressDelay));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pRsp->fetchIdx));
_exit:
return code;
}
int32_t tDeserializeSStreamProgressRsp(void *buf, int32_t bufLen, SStreamProgressRsp *pRsp) {
SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDecodeStreamProgressRsp(&decoder, pRsp));
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return code;
}
int32_t tSerializeSTriggerOrigTableInfoRsp(void* buf, int32_t bufLen, const SSTriggerOrigTableInfoRsp* pRsp){
SEncoder encoder = {0};
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
int32_t tlen = 0;
tEncoderInit(&encoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartEncode(&encoder));
int32_t size = taosArrayGetSize(pRsp->cols);
TAOS_CHECK_EXIT(tEncodeI32(&encoder, size));
for (int32_t i = 0; i < size; ++i) {
OTableInfoRsp* oInfo = taosArrayGet(pRsp->cols, i);
if (oInfo == NULL) {
uError("col id is NULL at index %d", i);
code = TSDB_CODE_INVALID_PARA;
goto _exit;
}
TAOS_CHECK_EXIT(tEncodeI64(&encoder, oInfo->suid));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, oInfo->uid));
TAOS_CHECK_EXIT(tEncodeI16(&encoder, oInfo->cid));
}
tEndEncode(&encoder);
_exit:
if (code != TSDB_CODE_SUCCESS) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
int32_t tDserializeSTriggerOrigTableInfoRsp(void* buf, int32_t bufLen, SSTriggerOrigTableInfoRsp* pRsp){
SDecoder decoder = {0};
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
tDecoderInit(&decoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartDecode(&decoder));
int32_t size = 0;
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &size));
pRsp->cols = taosArrayInit(size, sizeof(OTableInfoRsp));
if (pRsp->cols == NULL) {
code = terrno;
uError("failed to allocate memory for cids, size: %d, errno: %d", size, code);
goto _exit;
}
for (int32_t i = 0; i < size; ++i) {
OTableInfoRsp* oInfo = taosArrayReserve(pRsp->cols, 1);
if (oInfo == NULL) {
code = terrno;
uError("failed to reserve memory for OTableInfo, size: %d, errno: %d", size, code);
goto _exit;
}
TAOS_CHECK_RETURN(tDecodeI64(&decoder, &oInfo->suid));
TAOS_CHECK_RETURN(tDecodeI64(&decoder, &oInfo->uid));
TAOS_CHECK_RETURN(tDecodeI16(&decoder, &oInfo->cid));
}
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return code;
}
void tDestroySTriggerOrigTableInfoRsp(SSTriggerOrigTableInfoRsp* pRsp){
taosArrayDestroy(pRsp->cols);
}
void tDestroySTriggerPullRequest(SSTriggerPullRequestUnion* pReq) {
if (pReq == NULL) return;
if (pReq->base.type == STRIGGER_PULL_WAL_DATA_NEW || pReq->base.type == STRIGGER_PULL_WAL_CALC_DATA_NEW) {
SSTriggerWalDataNewRequest* pRequest = (SSTriggerWalDataNewRequest*)pReq;
taosArrayDestroy(pRequest->versions);
tSimpleHashCleanup(pRequest->ranges);
} else if (pReq->base.type == STRIGGER_PULL_TSDB_DATA) {
SSTriggerTsdbDataRequest* pRequest = (SSTriggerTsdbDataRequest*)pReq;
if (pRequest->cids != NULL) {
taosArrayDestroy(pRequest->cids);
pRequest->cids = NULL;
}
} else if (pReq->base.type == STRIGGER_PULL_VTABLE_INFO) {
SSTriggerVirTableInfoRequest* pRequest = (SSTriggerVirTableInfoRequest*)pReq;
if (pRequest->cids != NULL) {
taosArrayDestroy(pRequest->cids);
pRequest->cids = NULL;
}
if (pRequest->uids != NULL) {
taosArrayDestroy(pRequest->uids);
pRequest->uids = NULL;
}
} else if (pReq->base.type == STRIGGER_PULL_VTABLE_PSEUDO_COL) {
SSTriggerVirTablePseudoColRequest *pRequest = (SSTriggerVirTablePseudoColRequest*)pReq;
if (pRequest->cids != NULL) {
taosArrayDestroy(pRequest->cids);
pRequest->cids = NULL;
}
} else if (pReq->base.type == STRIGGER_PULL_OTABLE_INFO) {
SSTriggerOrigTableInfoRequest* pRequest = (SSTriggerOrigTableInfoRequest*)pReq;
if (pRequest->cols != NULL) {
taosArrayDestroy(pRequest->cols);
pRequest->cols = NULL;
}
} else if (pReq->base.type == STRIGGER_PULL_SET_TABLE) {
SSTriggerSetTableRequest* pRequest = (SSTriggerSetTableRequest*)pReq;
tSimpleHashCleanup(pRequest->uidInfoTrigger);
tSimpleHashCleanup(pRequest->uidInfoCalc);
}
}
int32_t encodePlainArray(SEncoder *encoder, SArray *pArr) {
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
int32_t nEle = taosArrayGetSize(pArr);
uint8_t* buf = (nEle > 0) ? TARRAY_DATA(pArr) : NULL;
int32_t len = (nEle > 0) ? (nEle * pArr->elemSize) : 0;
TAOS_CHECK_EXIT(tEncodeBinary(encoder, buf, len));
_exit:
return code;
}
int32_t decodePlainArray(SDecoder* decoder, SArray** ppArr, uint32_t elemSize) {
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
void* buf = NULL;
uint64_t len = 0;
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(decoder, &buf, &len));
if (len > 0) {
*ppArr = taosArrayInit(0, elemSize);
TSDB_CHECK_NULL(*ppArr, code, lino, _exit, terrno);
TSWAP((*ppArr)->pData, buf);
(*ppArr)->size = (*ppArr)->capacity = len / elemSize;
}
_exit:
if (buf != NULL) {
taosMemoryFree(buf);
}
return code;
}
static int32_t encodeSetTableMapInfo(SEncoder* encoder, SSHashObj* pInfo) {
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
int32_t size = tSimpleHashGetSize(pInfo);
TAOS_CHECK_EXIT(tEncodeI32(encoder, size));
int32_t iter = 0;
void* px = tSimpleHashIterate(pInfo, NULL, &iter);
while (px != NULL) {
int64_t* uid = tSimpleHashGetKey(px, NULL);
TAOS_CHECK_EXIT(tEncodeI64(encoder, *uid));
TAOS_CHECK_EXIT(tEncodeI64(encoder, *(uid + 1)));
SSHashObj* info = *(SSHashObj**)px;
int32_t len = tSimpleHashGetSize(info);
TAOS_CHECK_EXIT(tEncodeI32(encoder, len));
int32_t iter1 = 0;
void* px1 = tSimpleHashIterate(info, NULL, &iter1);
while (px1 != NULL) {
int16_t* slot = tSimpleHashGetKey(px1, NULL);
int16_t* cid = (int16_t*)px1;
TAOS_CHECK_EXIT(tEncodeI16(encoder, *slot));
TAOS_CHECK_EXIT(tEncodeI16(encoder, *cid));
px1 = tSimpleHashIterate(info, px1, &iter1);
}
px = tSimpleHashIterate(pInfo, px, &iter);
}
_exit:
return code;
}
int32_t tSerializeSTriggerPullRequest(void* buf, int32_t bufLen, const SSTriggerPullRequest* pReq) {
SEncoder encoder = {0};
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
int32_t tlen = 0;
tEncoderInit(&encoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->type));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->streamId));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->readerTaskId));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->sessionId));
switch (pReq->type) {
case STRIGGER_PULL_SET_TABLE: {
SSTriggerSetTableRequest* pRequest = (SSTriggerSetTableRequest*)pReq;
TAOS_CHECK_EXIT(encodeSetTableMapInfo(&encoder, pRequest->uidInfoTrigger));
TAOS_CHECK_EXIT(encodeSetTableMapInfo(&encoder, pRequest->uidInfoCalc));
break;
}
case STRIGGER_PULL_LAST_TS: {
break;
}
case STRIGGER_PULL_FIRST_TS: {
SSTriggerFirstTsRequest* pRequest = (SSTriggerFirstTsRequest*)pReq;
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->gid));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->startTime));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));
break;
}
case STRIGGER_PULL_TSDB_META: {
SSTriggerTsdbMetaRequest* pRequest = (SSTriggerTsdbMetaRequest*)pReq;
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->startTime));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->endTime));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->gid));
TAOS_CHECK_EXIT(tEncodeI8(&encoder, pRequest->order));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));
break;
}
case STRIGGER_PULL_TSDB_META_NEXT: {
break;
}
case STRIGGER_PULL_TSDB_TS_DATA: {
SSTriggerTsdbTsDataRequest* pRequest = (SSTriggerTsdbTsDataRequest*)pReq;
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->suid));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->uid));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->skey));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ekey));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));
break;
}
case STRIGGER_PULL_TSDB_TRIGGER_DATA: {
SSTriggerTsdbTriggerDataRequest* pRequest = (SSTriggerTsdbTriggerDataRequest*)pReq;
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->startTime));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->gid));
TAOS_CHECK_EXIT(tEncodeI8(&encoder, pRequest->order));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));
break;
}
case STRIGGER_PULL_TSDB_TRIGGER_DATA_NEXT: {
break;
}
case STRIGGER_PULL_TSDB_CALC_DATA: {
SSTriggerTsdbCalcDataRequest* pRequest = (SSTriggerTsdbCalcDataRequest*)pReq;
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->gid));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->skey));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ekey));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));
break;
}
case STRIGGER_PULL_TSDB_CALC_DATA_NEXT: {
break;
}
case STRIGGER_PULL_TSDB_DATA: {
SSTriggerTsdbDataRequest* pRequest = (SSTriggerTsdbDataRequest*)pReq;
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->suid));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->uid));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->skey));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ekey));
TAOS_CHECK_EXIT(encodePlainArray(&encoder, pRequest->cids));
TAOS_CHECK_EXIT(tEncodeI8(&encoder, pRequest->order));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));
break;
}
case STRIGGER_PULL_TSDB_DATA_NEXT: {
break;
}
case STRIGGER_PULL_WAL_META_NEW: {
SSTriggerWalMetaNewRequest* pRequest = (SSTriggerWalMetaNewRequest*)pReq;
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->lastVer));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ctime));
break;
}
case STRIGGER_PULL_WAL_DATA_NEW:
case STRIGGER_PULL_WAL_CALC_DATA_NEW: {
SSTriggerWalDataNewRequest* pRequest = (SSTriggerWalDataNewRequest*)pReq;
int32_t nVersion = taosArrayGetSize(pRequest->versions);
TAOS_CHECK_EXIT(tEncodeI32(&encoder, nVersion));
for (int32_t i = 0; i < nVersion; i++) {
int64_t ver = *(int64_t*)TARRAY_GET_ELEM(pRequest->versions, i);
TAOS_CHECK_EXIT(tEncodeI64(&encoder, ver));
}
int32_t nRanges = tSimpleHashGetSize(pRequest->ranges);
TAOS_CHECK_EXIT(tEncodeI32(&encoder, nRanges));
int32_t iter = 0;
void* px = tSimpleHashIterate(pRequest->ranges, NULL, &iter);
while (px != NULL) {
uint64_t* gid = tSimpleHashGetKey(px, NULL);
TAOS_CHECK_EXIT(tEncodeU64(&encoder, *gid));
int64_t* key = (int64_t*)px;
TAOS_CHECK_EXIT(tEncodeI64(&encoder, key[0]));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, key[1]));
px = tSimpleHashIterate(pRequest->ranges, px, &iter);
}
break;
}
case STRIGGER_PULL_WAL_META_DATA_NEW: {
SSTriggerWalMetaDataNewRequest* pRequest = (SSTriggerWalMetaDataNewRequest*)pReq;
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->lastVer));
break;
}
case STRIGGER_PULL_GROUP_COL_VALUE: {
SSTriggerGroupColValueRequest* pRequest = (SSTriggerGroupColValueRequest*)pReq;
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->gid));
break;
}
case STRIGGER_PULL_VTABLE_INFO: {
SSTriggerVirTableInfoRequest* pRequest = (SSTriggerVirTableInfoRequest*)pReq;
TAOS_CHECK_EXIT(encodePlainArray(&encoder, pRequest->cids));
TAOS_CHECK_EXIT(encodePlainArray(&encoder, pRequest->uids));
TAOS_CHECK_EXIT(tEncodeBool(&encoder, pRequest->fetchAllTable));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));
break;
}
case STRIGGER_PULL_VTABLE_PSEUDO_COL: {
SSTriggerVirTablePseudoColRequest* pRequest = (SSTriggerVirTablePseudoColRequest*)pReq;
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->uid));
TAOS_CHECK_EXIT(encodePlainArray(&encoder, pRequest->cids));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));
break;
}
case STRIGGER_PULL_OTABLE_INFO: {
SSTriggerOrigTableInfoRequest* pRequest = (SSTriggerOrigTableInfoRequest*)pReq;
int32_t size = taosArrayGetSize(pRequest->cols);
TAOS_CHECK_EXIT(tEncodeI32(&encoder, size));
for (int32_t i = 0; i < size; ++i) {
OTableInfo* oInfo = taosArrayGet(pRequest->cols, i);
if (oInfo == NULL) {
uError("col id is NULL at index %d", i);
code = TSDB_CODE_INVALID_PARA;
goto _exit;
}
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, oInfo->refTableName));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, oInfo->refColName));
}
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));
break;
}
default: {
uError("unknown pull type %d", pReq->type);
code = TSDB_CODE_INVALID_PARA;
break;
}
}
tEndEncode(&encoder);
_exit:
if (code != TSDB_CODE_SUCCESS) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
static void destroyHash(void* data){
if (data){
SSHashObj* tmp = *(SSHashObj**)data;
tSimpleHashCleanup(tmp);
}
}
static int32_t decodeSetTableMapInfo(SDecoder* decoder, SSHashObj** ppInfo) {
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
int32_t size = 0;
TAOS_CHECK_EXIT(tDecodeI32(decoder, &size));
*ppInfo = tSimpleHashInit(size, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY));
if (*ppInfo == NULL) {
TAOS_CHECK_EXIT(terrno);
}
tSimpleHashSetFreeFp(*ppInfo, destroyHash);
for (int32_t i = 0; i < size; ++i) {
int64_t id[2] = {0};
TAOS_CHECK_EXIT(tDecodeI64(decoder, id));
TAOS_CHECK_EXIT(tDecodeI64(decoder, id+1));
int32_t len = 0;
TAOS_CHECK_EXIT(tDecodeI32(decoder, &len));
SSHashObj* tmp = tSimpleHashInit(len, taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT));
if (tmp == NULL) {
TAOS_CHECK_EXIT(terrno);
}
TAOS_CHECK_EXIT(tSimpleHashPut(*ppInfo, id, sizeof(id), &tmp, POINTER_BYTES));
for (int32_t j = 0; j < len; ++j) {
int16_t slotId = 0;
int16_t cid = 0;
TAOS_CHECK_EXIT(tDecodeI16(decoder, &slotId));
TAOS_CHECK_EXIT(tDecodeI16(decoder, &cid));
TAOS_CHECK_EXIT(tSimpleHashPut(tmp, &slotId, sizeof(slotId), &cid, sizeof(cid)));
}
}
_exit:
if (code != TSDB_CODE_SUCCESS) {
tSimpleHashCleanup(*ppInfo);
*ppInfo = NULL;
}
return code;
}
int32_t tDeserializeSTriggerPullRequest(void* buf, int32_t bufLen, SSTriggerPullRequestUnion* pReq) {
SDecoder decoder = {0};
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
tDecoderInit(&decoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartDecode(&decoder));
int32_t type = 0;
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &type));
SSTriggerPullRequest* pBase = &(pReq->base);
pBase->type = type;
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pBase->streamId));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pBase->readerTaskId));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pBase->sessionId));
switch (type) {
case STRIGGER_PULL_SET_TABLE: {
SSTriggerSetTableRequest* pRequest = &(pReq->setTableReq);
TAOS_CHECK_EXIT(decodeSetTableMapInfo(&decoder, &pRequest->uidInfoTrigger));
TAOS_CHECK_EXIT(decodeSetTableMapInfo(&decoder, &pRequest->uidInfoCalc));
break;
}
case STRIGGER_PULL_LAST_TS: {
break;
}
case STRIGGER_PULL_FIRST_TS: {
SSTriggerFirstTsRequest* pRequest = &(pReq->firstTsReq);
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->startTime));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));
break;
}
case STRIGGER_PULL_TSDB_META: {
SSTriggerTsdbMetaRequest* pRequest = &(pReq->tsdbMetaReq);
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->startTime));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->endTime));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));
TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pRequest->order));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));
break;
}
case STRIGGER_PULL_TSDB_META_NEXT: {
break;
}
case STRIGGER_PULL_TSDB_TS_DATA: {
SSTriggerTsdbTsDataRequest* pRequest = &(pReq->tsdbTsDataReq);
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->suid));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->uid));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->skey));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ekey));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));
break;
}
case STRIGGER_PULL_TSDB_TRIGGER_DATA: {
SSTriggerTsdbTriggerDataRequest* pRequest = &(pReq->tsdbTriggerDataReq);
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->startTime));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));
TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pRequest->order));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));
break;
}
case STRIGGER_PULL_TSDB_TRIGGER_DATA_NEXT: {
break;
}
case STRIGGER_PULL_TSDB_CALC_DATA: {
SSTriggerTsdbCalcDataRequest* pRequest = &(pReq->tsdbCalcDataReq);
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->skey));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ekey));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));
break;
}
case STRIGGER_PULL_TSDB_CALC_DATA_NEXT: {
break;
}
case STRIGGER_PULL_TSDB_DATA: {
SSTriggerTsdbDataRequest* pRequest = &(pReq->tsdbDataReq);
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->suid));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->uid));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->skey));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ekey));
TAOS_CHECK_EXIT(decodePlainArray(&decoder, &pRequest->cids, sizeof(col_id_t)));
TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pRequest->order));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));
break;
}
case STRIGGER_PULL_TSDB_DATA_NEXT: {
break;
}
case STRIGGER_PULL_WAL_META_NEW: {
SSTriggerWalMetaNewRequest* pRequest = &(pReq->walMetaNewReq);
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->lastVer));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ctime));
break;
}
case STRIGGER_PULL_WAL_DATA_NEW:
case STRIGGER_PULL_WAL_CALC_DATA_NEW: {
SSTriggerWalDataNewRequest* pRequest = &(pReq->walDataNewReq);
int32_t nVersion = 0;
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nVersion));
pRequest->versions = taosArrayInit_s(sizeof(int64_t), nVersion);
for (int32_t i = 0; i < nVersion; i++) {
int64_t* pVer = TARRAY_GET_ELEM(pRequest->versions, i);
TAOS_CHECK_EXIT(tDecodeI64(&decoder, pVer));
}
int32_t nRanges = 0;
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nRanges));
pRequest->ranges = tSimpleHashInit(nRanges, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT));
if (pRequest->ranges == NULL) {
TAOS_CHECK_EXIT(terrno);
}
for (int32_t i = 0; i < nRanges; i++) {
uint64_t gid = 0;
int64_t pRange[2] = {0};
TAOS_CHECK_EXIT(tDecodeU64(&decoder, &gid));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRange[0]));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRange[1]));
TAOS_CHECK_EXIT(tSimpleHashPut(pRequest->ranges, &gid, sizeof(gid), pRange, sizeof(pRange)));
}
break;
}
case STRIGGER_PULL_WAL_META_DATA_NEW: {
SSTriggerWalMetaDataNewRequest* pRequest = &(pReq->walMetaDataNewReq);
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->lastVer));
break;
}
case STRIGGER_PULL_GROUP_COL_VALUE: {
SSTriggerGroupColValueRequest* pRequest = &(pReq->groupColValueReq);
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));
break;
}
case STRIGGER_PULL_VTABLE_INFO: {
SSTriggerVirTableInfoRequest* pRequest = &(pReq->virTableInfoReq);
TAOS_CHECK_EXIT(decodePlainArray(&decoder, &pRequest->cids, sizeof(col_id_t)));
TAOS_CHECK_EXIT(decodePlainArray(&decoder, &pRequest->uids, sizeof(int64_t)));
TAOS_CHECK_EXIT(tDecodeBool(&decoder, &pRequest->fetchAllTable));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));
break;
}
case STRIGGER_PULL_VTABLE_PSEUDO_COL: {
SSTriggerVirTablePseudoColRequest* pRequest = &(pReq->virTablePseudoColReq);
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->uid));
TAOS_CHECK_EXIT(decodePlainArray(&decoder, &pRequest->cids, sizeof(col_id_t)));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));
break;
}
case STRIGGER_PULL_OTABLE_INFO: {
SSTriggerOrigTableInfoRequest* pRequest = &(pReq->origTableInfoReq);
int32_t size = 0;
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &size));
pRequest->cols = taosArrayInit(size, sizeof(OTableInfo));
if (pRequest->cols == NULL) {
code = terrno;
uError("failed to allocate memory for cids, size: %d, errno: %d", size, code);
goto _exit;
}
for (int32_t i = 0; i < size; ++i) {
OTableInfo* oInfo = taosArrayReserve(pRequest->cols, 1);
if (oInfo == NULL) {
code = terrno;
uError("failed to reserve memory for OTableInfo, size: %d, errno: %d", size, code);
goto _exit;
}
TAOS_CHECK_RETURN(tDecodeCStrTo(&decoder, oInfo->refTableName));
TAOS_CHECK_RETURN(tDecodeCStrTo(&decoder, oInfo->refColName));
}
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));
break;
}
default: {
uError("unknown pull type %d", type);
code = TSDB_CODE_INVALID_PARA;
break;
}
}
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return code;
}
static int32_t tSerializeSTriggerCalcParam(SEncoder* pEncoder, SArray* pParams, bool ignoreNotificationInfo, bool full) {
int32_t size = full ? taosArrayGetSize(pParams) : 0;
int32_t code = 0;
int32_t lino = 0;
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, size));
for (int32_t i = 0; i < size; ++i) {
SSTriggerCalcParam* param = taosArrayGet(pParams, i);
if (param == NULL) {
TAOS_CHECK_EXIT(terrno);
}
int64_t plainFieldSize = offsetof(SSTriggerCalcParam, notifyType);
if (pEncoder->data) {
TAOS_MEMCPY(pEncoder->data + pEncoder->pos, param, plainFieldSize);
}
pEncoder->pos += plainFieldSize;
if (!ignoreNotificationInfo) {
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, param->notifyType));
uint64_t len = (param->extraNotifyContent != NULL) ? strlen(param->extraNotifyContent) + 1 : 0;
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, (uint8_t*)param->extraNotifyContent, len));
}
}
_exit:
return code;
}
void tDestroySSTriggerCalcParam(void* ptr) {
SSTriggerCalcParam* pParam = ptr;
if (pParam && pParam->extraNotifyContent != NULL) {
taosMemoryFreeClear(pParam->extraNotifyContent);
}
if (pParam && pParam->resultNotifyContent != NULL) {
taosMemoryFreeClear(pParam->resultNotifyContent);
}
if (pParam && pParam->pExternalWindowData != NULL) {
taosArrayDestroyEx(pParam->pExternalWindowData, tDestroySStreamGroupValue);
pParam->pExternalWindowData = NULL;
}
}
void tDestroySSTriggerGroupCalcInfo(void* ptr) {
SSTriggerGroupCalcInfo* pCalcInfo = ptr;
if (pCalcInfo && pCalcInfo->pParams != NULL) {
taosArrayDestroyEx(pCalcInfo->pParams, tDestroySSTriggerCalcParam);
pCalcInfo->pParams = NULL;
}
if (pCalcInfo && pCalcInfo->pGroupColVals != NULL) {
taosArrayDestroyEx(pCalcInfo->pGroupColVals, tDestroySStreamGroupValue);
pCalcInfo->pGroupColVals = NULL;
}
}
void tDestroySSTriggerGroupReadInfo(void* ptr) {
SSTriggerGroupReadInfo* pReadInfo = ptr;
if (pReadInfo && pReadInfo->pTables) {
taosArrayDestroy(pReadInfo->pTables);
pReadInfo->pTables = NULL;
}
}
void tDestroySSTriggerGroupReadInfoArray(void* ptr) {
if (ptr != NULL && *(SArray**)ptr != NULL) {
SArray* pArray = *(SArray**)ptr;
taosArrayDestroyEx(pArray, tDestroySSTriggerGroupReadInfo);
*(SArray**)ptr = NULL;
}
}
void tDestroySStreamGroupValue(void* ptr) {
SStreamGroupValue* pValue = ptr;
if ((pValue != NULL) && (IS_VAR_DATA_TYPE(pValue->data.type) || pValue->data.type == TSDB_DATA_TYPE_DECIMAL)) {
taosMemoryFreeClear(pValue->data.pData);
pValue->data.nData = 0;
}
}
static int32_t tDeserializeSTriggerCalcParam(SDecoder* pDecoder, SArray**ppParams, bool ignoreNotificationInfo) {
int32_t size = 0, code = 0, lino = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &size));
if (size <= 0) {
return code;
}
*ppParams = taosArrayInit(size, sizeof(SSTriggerCalcParam));
if (*ppParams == NULL) {
TAOS_CHECK_EXIT(terrno);
}
for (int32_t i = 0; i < size; ++i) {
SSTriggerCalcParam* param = taosArrayReserve(*ppParams, 1);
if (param == NULL) {
TAOS_CHECK_EXIT(terrno);
}
int64_t plainFieldSize = offsetof(SSTriggerCalcParam, notifyType);
TAOS_MEMCPY(param, pDecoder->data + pDecoder->pos, plainFieldSize);
pDecoder->pos += plainFieldSize;
if (!ignoreNotificationInfo) {
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &param->notifyType));
uint64_t len = 0;
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&param->extraNotifyContent, &len));
}
}
_exit:
return code;
}
static int32_t tSerializeStriggerGroupColVals(SEncoder* pEncoder, SArray* pGroupColVals, int32_t vgId) {
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
int32_t size = taosArrayGetSize(pGroupColVals);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, size));
for (int32_t i = 0; i < size; ++i) {
SStreamGroupValue* pValue = taosArrayGet(pGroupColVals, i);
if (pValue == NULL) {
TAOS_CHECK_EXIT(terrno);
}
TAOS_CHECK_EXIT(tEncodeBool(pEncoder, pValue->isNull));
if (pValue->isNull) {
continue;
}
TAOS_CHECK_EXIT(tEncodeBool(pEncoder, pValue->isTbname));
if (pValue->isTbname) {
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pValue->uid));
if (vgId != -1) { pValue->vgId = vgId; }
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pValue->vgId));
}
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pValue->data.type));
if (IS_VAR_DATA_TYPE(pValue->data.type)) {
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pValue->data.pData, pValue->data.nData));
} else {
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pValue->data.val));
}
}
_exit:
return code;
}
static int32_t tDeserializeStriggerGroupColVals(SDecoder* pDecoder, SArray** ppGroupColVals) {
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
int32_t size = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &size));
taosArrayClearEx(*ppGroupColVals, tDestroySStreamGroupValue);
if (size > 0) {
if (*ppGroupColVals == NULL) {
*ppGroupColVals = taosArrayInit(size, sizeof(SStreamGroupValue));
if (*ppGroupColVals == NULL) {
TAOS_CHECK_EXIT(terrno);
}
} else {
TAOS_CHECK_EXIT(taosArrayEnsureCap(*ppGroupColVals, size));
}
}
for (int32_t i = 0; i < size; ++i) {
SStreamGroupValue* pValue = taosArrayReserve(*ppGroupColVals, 1);
if (pValue == NULL) {
TAOS_CHECK_EXIT(terrno);
}
TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &pValue->isNull));
if (pValue->isNull) {
continue;
}
TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &pValue->isTbname));
if (pValue->isTbname) {
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pValue->uid));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pValue->vgId));
}
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pValue->data.type));
if (IS_VAR_DATA_TYPE(pValue->data.type)) {
uint64_t len = 0;
TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pValue->data.pData, &len));
pValue->data.nData = len;
} else {
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pValue->data.val));
}
}
_exit:
return code;
}
int32_t tSerializeSStreamGroupInfo(void* buf, int32_t bufLen, const SStreamGroupInfo* gInfo, int32_t vgId) {
SEncoder encoder = {0};
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
int32_t tlen = 0;
tEncoderInit(&encoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tSerializeStriggerGroupColVals(&encoder, gInfo->gInfo, vgId));
tEndEncode(&encoder);
_exit:
if (code != TSDB_CODE_SUCCESS) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
int32_t tDeserializeSStreamGroupInfo(void* buf, int32_t bufLen, SStreamGroupInfo* gInfo) {
SDecoder decoder = {0};
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
int32_t size = 0;
tDecoderInit(&decoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDeserializeStriggerGroupColVals(&decoder, &gInfo->gInfo));
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return code;
}
static int32_t tSerializeSSTriggerGroupCalcInfo(SEncoder* pEncoder, SSTriggerGroupCalcInfo* pInfo) {
int32_t code = 0;
int32_t lino = 0;
TAOS_CHECK_EXIT(tSerializeSTriggerCalcParam(pEncoder, pInfo->pParams, false, true));
TAOS_CHECK_EXIT(tSerializeStriggerGroupColVals(pEncoder, pInfo->pGroupColVals, -1));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pInfo->createTable));
_exit:
return code;
}
static int32_t tSerializeSSTriggerGroupReadInfo(SEncoder* pEncoder, SSTriggerGroupReadInfo* pInfo) {
int32_t code = 0;
int32_t lino = 0;
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->gid));
int64_t plainFieldSize = offsetof(SSTriggerCalcParam, notifyType);
if (pEncoder->data) {
TAOS_MEMCPY(pEncoder->data + pEncoder->pos, &pInfo->firstParam, plainFieldSize);
}
pEncoder->pos += plainFieldSize;
if (pEncoder->data) {
TAOS_MEMCPY(pEncoder->data + pEncoder->pos, &pInfo->lastParam, plainFieldSize);
}
pEncoder->pos += plainFieldSize;
int32_t nTables = taosArrayGetSize(pInfo->pTables);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, nTables));
if (pEncoder->data && nTables > 0) {
TAOS_MEMCPY(pEncoder->data + pEncoder->pos, pInfo->pTables->pData, nTables * sizeof(int64_t));
}
pEncoder->pos += nTables * sizeof(int64_t);
_exit:
return code;
}
int32_t tSerializeSTriggerCalcRequest(void* buf, int32_t bufLen, const SSTriggerCalcRequest* pReq) {
SEncoder encoder = {0};
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
int32_t tlen = 0;
tEncoderInit(&encoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->streamId));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->runnerTaskId));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->sessionId));
TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->triggerType));
TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->isMultiGroupCalc));
TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->stbPartByTbname));
if (!pReq->isMultiGroupCalc) {
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->gid));
TAOS_CHECK_EXIT(tSerializeSTriggerCalcParam(&encoder, pReq->params, false, true));
TAOS_CHECK_EXIT(tSerializeStriggerGroupColVals(&encoder, pReq->groupColVals, -1));
TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->createTable));
} else {
int32_t nGroups = tSimpleHashGetSize(pReq->pGroupCalcInfos);
TAOS_CHECK_EXIT(tEncodeI32(&encoder, nGroups));
int32_t iter1 = 0;
SSTriggerGroupCalcInfo* pCalcInfo = tSimpleHashIterate(pReq->pGroupCalcInfos, NULL, &iter1);
while (pCalcInfo != NULL) {
int64_t* gid = tSimpleHashGetKey(pCalcInfo, NULL);
TAOS_CHECK_EXIT(tEncodeI64(&encoder, *gid));
TAOS_CHECK_EXIT(tSerializeSSTriggerGroupCalcInfo(&encoder, pCalcInfo));
pCalcInfo = tSimpleHashIterate(pReq->pGroupCalcInfos, pCalcInfo, &iter1);
}
int32_t nVnodes = tSimpleHashGetSize(pReq->pGroupReadInfos);
TAOS_CHECK_EXIT(tEncodeI32(&encoder, nVnodes));
int32_t iter2 = 0;
void* px = tSimpleHashIterate(pReq->pGroupReadInfos, NULL, &iter2);
while (px != NULL) {
int32_t* vgId = tSimpleHashGetKey(px, NULL);
TAOS_CHECK_EXIT(tEncodeI32(&encoder, *vgId));
SArray* pInfos = *(SArray**)px;
int32_t nGroups = taosArrayGetSize(pInfos);
TAOS_CHECK_EXIT(tEncodeI32(&encoder, nGroups));
for (int32_t i = 0; i < nGroups; ++i) {
SSTriggerGroupReadInfo* pReadInfo = TARRAY_GET_ELEM(pInfos, i);
TAOS_CHECK_EXIT(tSerializeSSTriggerGroupReadInfo(&encoder, pReadInfo));
}
px = tSimpleHashIterate(pReq->pGroupReadInfos, px, &iter2);
}
}
TAOS_CHECK_EXIT(tEncodeBool(&encoder, pReq->isWindowTrigger));
TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->precision));
tEndEncode(&encoder);
_exit:
if (code != TSDB_CODE_SUCCESS) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
static int32_t tDeserializeSSTriggerGroupCalcInfo(SDecoder* pDecoder, SSTriggerGroupCalcInfo* pInfo) {
int32_t code = 0;
int32_t lino = 0;
TAOS_CHECK_EXIT(tDeserializeSTriggerCalcParam(pDecoder, &pInfo->pParams, false));
TAOS_CHECK_EXIT(tDeserializeStriggerGroupColVals(pDecoder, &pInfo->pGroupColVals));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pInfo->createTable));
_exit:
return code;
}
static int32_t tDeserializeSSTriggerGroupReadInfo(SDecoder* pDecoder, SSTriggerGroupReadInfo* pInfo) {
int32_t code = 0;
int32_t lino = 0;
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->gid));
int64_t plainFieldSize = offsetof(SSTriggerCalcParam, notifyType);
TAOS_MEMCPY(&pInfo->firstParam, pDecoder->data + pDecoder->pos, plainFieldSize);
pDecoder->pos += plainFieldSize;
TAOS_MEMCPY(&pInfo->lastParam, pDecoder->data + pDecoder->pos, plainFieldSize);
pDecoder->pos += plainFieldSize;
int32_t nTables = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &nTables));
if (nTables > 0) {
pInfo->pTables = taosArrayInit_s(sizeof(int64_t), nTables);
QUERY_CHECK_NULL(pInfo->pTables, code, lino, _exit, terrno);
TAOS_MEMCPY(pInfo->pTables->pData, pDecoder->data + pDecoder->pos, nTables * sizeof(int64_t));
}
pDecoder->pos += nTables * sizeof(int64_t);
_exit:
return code;
}
int32_t tDeserializeSTriggerCalcRequest(void* buf, int32_t bufLen, SSTriggerCalcRequest* pReq) {
SDecoder decoder = {0};
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
tDecoderInit(&decoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->streamId));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->runnerTaskId));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->sessionId));
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->triggerType));
TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->isMultiGroupCalc));
TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->stbPartByTbname));
if (!pReq->isMultiGroupCalc) {
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->gid));
TAOS_CHECK_EXIT(tDeserializeSTriggerCalcParam(&decoder, &pReq->params, false));
TAOS_CHECK_EXIT(tDeserializeStriggerGroupColVals(&decoder, &pReq->groupColVals));
TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->createTable));
} else {
pReq->pGroupCalcInfos = tSimpleHashInit(256, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT));
QUERY_CHECK_NULL(pReq->pGroupCalcInfos, code, lino, _exit, terrno);
tSimpleHashSetFreeFp(pReq->pGroupCalcInfos, tDestroySSTriggerGroupCalcInfo);
int32_t nGroups = 0;
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nGroups));
for (int32_t i = 0; i < nGroups; i++) {
int64_t gid = 0;
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &gid));
SSTriggerGroupCalcInfo info = {0};
TAOS_CHECK_EXIT(tSimpleHashPut(pReq->pGroupCalcInfos, &gid, sizeof(int64_t), &info, sizeof(info)));
SSTriggerGroupCalcInfo* pCalcInfo = tSimpleHashGet(pReq->pGroupCalcInfos, &gid, sizeof(int64_t));
QUERY_CHECK_NULL(pCalcInfo, code, lino, _exit, TSDB_CODE_INTERNAL_ERROR);
TAOS_CHECK_EXIT(tDeserializeSSTriggerGroupCalcInfo(&decoder, pCalcInfo));
}
int32_t nVnodes = 0;
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nVnodes));
pReq->pGroupReadInfos = tSimpleHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT));
QUERY_CHECK_NULL(pReq->pGroupReadInfos, code, lino, _exit, terrno);
tSimpleHashSetFreeFp(pReq->pGroupReadInfos, tDestroySSTriggerGroupReadInfoArray);
for (int32_t i = 0; i < nVnodes; i++) {
int32_t vgId = 0;
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &vgId));
int32_t nGroups = 0;
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nGroups));
SArray* pInfos = taosArrayInit_s(sizeof(SSTriggerGroupReadInfo), nGroups);
QUERY_CHECK_NULL(pInfos, code, lino, _exit, terrno);
code = tSimpleHashPut(pReq->pGroupReadInfos, &vgId, sizeof(int32_t), &pInfos, POINTER_BYTES);
if (code != TSDB_CODE_SUCCESS) {
taosArrayDestroy(pInfos);
TAOS_CHECK_EXIT(code);
}
for (int32_t j = 0; j < nGroups; ++j) {
SSTriggerGroupReadInfo* pReadInfo = TARRAY_GET_ELEM(pInfos, j);
TAOS_CHECK_EXIT(tDeserializeSSTriggerGroupReadInfo(&decoder, pReadInfo));
}
}
}
if (!tDecodeIsEnd(&decoder)) {
TAOS_CHECK_EXIT(tDecodeBool(&decoder, &pReq->isWindowTrigger));
TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->precision));
}
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return code;
}
void tDestroySTriggerCalcRequest(SSTriggerCalcRequest* pReq) {
if (pReq != NULL) {
if (pReq->params != NULL) {
taosArrayDestroyEx(pReq->params, tDestroySSTriggerCalcParam);
pReq->params = NULL;
}
if (pReq->groupColVals != NULL) {
taosArrayDestroyEx(pReq->groupColVals, tDestroySStreamGroupValue);
pReq->groupColVals = NULL;
}
if (pReq->pGroupCalcInfos != NULL) {
tSimpleHashCleanup(pReq->pGroupCalcInfos);
pReq->pGroupCalcInfos = NULL;
}
if (pReq->pGroupReadInfos != NULL) {
tSimpleHashCleanup(pReq->pGroupReadInfos);
pReq->pGroupReadInfos = NULL;
}
blockDataDestroy(pReq->pOutBlock);
pReq->pOutBlock = NULL;
}
}
int32_t tSerializeSTriggerDropTableRequest(void* buf, int32_t bufLen, const SSTriggerDropRequest* pReq) {
SEncoder encoder = {0};
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
int32_t tlen = 0;
tEncoderInit(&encoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->streamId));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->runnerTaskId));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->sessionId));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->gid));
TAOS_CHECK_EXIT(tSerializeStriggerGroupColVals(&encoder, pReq->groupColVals, -1));
tEndEncode(&encoder);
_exit:
if (code != TSDB_CODE_SUCCESS) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
int32_t tDeserializeSTriggerDropTableRequest(void* buf, int32_t bufLen, SSTriggerDropRequest* pReq) {
SDecoder decoder = {0};
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
tDecoderInit(&decoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->streamId));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->runnerTaskId));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->sessionId));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->gid));
TAOS_CHECK_EXIT(tDeserializeStriggerGroupColVals(&decoder, &pReq->groupColVals));
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return code;
}
void tDestroySSTriggerDropRequest(SSTriggerDropRequest* pReq) {
if (pReq != NULL) {
if (pReq->groupColVals != NULL) {
taosArrayDestroyEx(pReq->groupColVals, tDestroySStreamGroupValue);
pReq->groupColVals = NULL;
}
}
}
int32_t tSerializeSTriggerCtrlRequest(void* buf, int32_t bufLen, const SSTriggerCtrlRequest* pReq) {
SEncoder encoder = {0};
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
int32_t tlen = 0;
tEncoderInit(&encoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->type));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->streamId));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->taskId));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->sessionId));
tEndEncode(&encoder);
_exit:
if (code != TSDB_CODE_SUCCESS) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
int32_t tDeserializeSTriggerCtrlRequest(void* buf, int32_t bufLen, SSTriggerCtrlRequest* pReq) {
SDecoder decoder = {0};
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
tDecoderInit(&decoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartDecode(&decoder));
int32_t type = 0;
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &type));
pReq->type = type;
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->streamId));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->taskId));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->sessionId));
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return code;
}
int32_t tSerializeStRtFuncInfo(SEncoder* pEncoder, const SStreamRuntimeFuncInfo* pInfo, bool needStreamRtInfo, bool needStreamGrpInfo) {
int32_t code = 0, lino = 0;
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pInfo->isMultiGroupCalc));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pInfo->stbPartByTbname));
TAOS_CHECK_EXIT(tEncodeBool(pEncoder, needStreamRtInfo));
TAOS_CHECK_EXIT(tEncodeBool(pEncoder, needStreamGrpInfo));
if (pInfo->isMultiGroupCalc) {
if (needStreamRtInfo) {
if (needStreamGrpInfo) {
int32_t nGroups = taosArrayGetSize(pInfo->curGrpRead);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, nGroups));
int8_t withGrpCalcInfo = 1;
for (int32_t i = 0; i < nGroups; ++i) {
SSTriggerGroupReadInfo* pReadInfo = TARRAY_GET_ELEM(pInfo->curGrpRead, i);
TAOS_CHECK_EXIT(tSerializeSSTriggerGroupReadInfo(pEncoder, pReadInfo));
if (0 == i) {
withGrpCalcInfo = (taosArrayGetSize(pReadInfo->pTables) <= 0);
}
}
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, withGrpCalcInfo));
if (withGrpCalcInfo) {
int32_t nGroups = tSimpleHashGetSize(pInfo->pGroupCalcInfos);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, nGroups));
int32_t iter1 = 0;
SSTriggerGroupCalcInfo* pCalcInfo = tSimpleHashIterate(pInfo->pGroupCalcInfos, NULL, &iter1);
while (pCalcInfo != NULL) {
int64_t* gid = tSimpleHashGetKey(pCalcInfo, NULL);
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, *gid));
TAOS_CHECK_EXIT(tSerializeSSTriggerGroupCalcInfo(pEncoder, pCalcInfo));
pCalcInfo = tSimpleHashIterate(pInfo->pGroupCalcInfos, pCalcInfo, &iter1);
}
}
} else {
int32_t nGroups = tSimpleHashGetSize(pInfo->pGroupCalcInfos);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, nGroups));
int32_t iter1 = 0;
SSTriggerGroupCalcInfo* pCalcInfo = tSimpleHashIterate(pInfo->pGroupCalcInfos, NULL, &iter1);
while (pCalcInfo != NULL) {
int64_t* gid = tSimpleHashGetKey(pCalcInfo, NULL);
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, *gid));
TAOS_CHECK_EXIT(tSerializeSSTriggerGroupCalcInfo(pEncoder, pCalcInfo));
pCalcInfo = tSimpleHashIterate(pInfo->pGroupCalcInfos, pCalcInfo, &iter1);
}
int32_t nVnodes = tSimpleHashGetSize(pInfo->pGroupReadInfos);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, nVnodes));
int32_t iter2 = 0;
void* px = tSimpleHashIterate(pInfo->pGroupReadInfos, NULL, &iter2);
while (px != NULL) {
int32_t* vgId = tSimpleHashGetKey(px, NULL);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, *vgId));
SArray* pInfos = *(SArray**)px;
int32_t nGroups = taosArrayGetSize(pInfos);
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, nGroups));
for (int32_t i = 0; i < nGroups; ++i) {
SSTriggerGroupReadInfo* pReadInfo = TARRAY_GET_ELEM(pInfos, i);
TAOS_CHECK_EXIT(tSerializeSSTriggerGroupReadInfo(pEncoder, pReadInfo));
}
px = tSimpleHashIterate(pInfo->pGroupReadInfos, px, &iter2);
}
}
}
} else {
TAOS_CHECK_EXIT(tSerializeSTriggerCalcParam(pEncoder, pInfo->pStreamPesudoFuncVals, true, needStreamRtInfo));
TAOS_CHECK_EXIT(tSerializeStriggerGroupColVals(pEncoder, pInfo->pStreamPartColVals, -1));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->groupId));
}
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->curWindow.skey));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->curWindow.ekey));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pInfo->curIdx));
TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->sessionId));
TAOS_CHECK_EXIT(tEncodeBool(pEncoder, pInfo->withExternalWindow));
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pInfo->triggerType));
TAOS_CHECK_EXIT(tEncodeBool(pEncoder, pInfo->isWindowTrigger));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pInfo->precision));
TAOS_CHECK_EXIT(tEncodeU64(pEncoder, pInfo->streamGen));
_exit:
return code;
}
int32_t tDeserializeStRtFuncInfo(SDecoder* pDecoder, SStreamRuntimeFuncInfo* pInfo) {
int32_t code = 0, lino = 0;
int32_t size = 0;
bool needStreamRtInfo = false;
bool needStreamGrpInfo = false;
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pInfo->isMultiGroupCalc));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pInfo->stbPartByTbname));
TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &needStreamRtInfo));
TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &needStreamGrpInfo));
if (pInfo->isMultiGroupCalc) {
if (needStreamRtInfo) {
if (needStreamGrpInfo) {
int32_t nGroups = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &nGroups));
if (nGroups > 0) {
pInfo->curGrpRead = taosArrayInit_s(sizeof(SSTriggerGroupReadInfo), nGroups);
QUERY_CHECK_NULL(pInfo->curGrpRead, code, lino, _exit, terrno);
}
for (int32_t j = 0; j < nGroups; ++j) {
SSTriggerGroupReadInfo* pReadInfo = TARRAY_GET_ELEM(pInfo->curGrpRead, j);
TAOS_CHECK_EXIT(tDeserializeSSTriggerGroupReadInfo(pDecoder, pReadInfo));
}
int8_t withGrpCalcInfo = 0;
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &withGrpCalcInfo));
if (withGrpCalcInfo) {
int32_t nGroups = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &nGroups));
pInfo->pGroupCalcInfos = tSimpleHashInit(nGroups, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT));
QUERY_CHECK_NULL(pInfo->pGroupCalcInfos, code, lino, _exit, terrno);
tSimpleHashSetFreeFp(pInfo->pGroupCalcInfos, tDestroySSTriggerGroupCalcInfo);
for (int32_t i = 0; i < nGroups; i++) {
int64_t gid = 0;
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &gid));
SSTriggerGroupCalcInfo info = {0};
TAOS_CHECK_EXIT(tSimpleHashPut(pInfo->pGroupCalcInfos, &gid, sizeof(int64_t), &info, sizeof(info)));
SSTriggerGroupCalcInfo* pCalcInfo = tSimpleHashGet(pInfo->pGroupCalcInfos, &gid, sizeof(int64_t));
QUERY_CHECK_NULL(pCalcInfo, code, lino, _exit, TSDB_CODE_INTERNAL_ERROR);
TAOS_CHECK_EXIT(tDeserializeSSTriggerGroupCalcInfo(pDecoder, pCalcInfo));
}
}
} else {
int32_t nGroups = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &nGroups));
pInfo->pGroupCalcInfos = tSimpleHashInit(nGroups, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT));
QUERY_CHECK_NULL(pInfo->pGroupCalcInfos, code, lino, _exit, terrno);
tSimpleHashSetFreeFp(pInfo->pGroupCalcInfos, tDestroySSTriggerGroupCalcInfo);
for (int32_t i = 0; i < nGroups; i++) {
int64_t gid = 0;
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &gid));
SSTriggerGroupCalcInfo info = {0};
TAOS_CHECK_EXIT(tSimpleHashPut(pInfo->pGroupCalcInfos, &gid, sizeof(int64_t), &info, sizeof(info)));
SSTriggerGroupCalcInfo* pCalcInfo = tSimpleHashGet(pInfo->pGroupCalcInfos, &gid, sizeof(int64_t));
QUERY_CHECK_NULL(pCalcInfo, code, lino, _exit, TSDB_CODE_INTERNAL_ERROR);
TAOS_CHECK_EXIT(tDeserializeSSTriggerGroupCalcInfo(pDecoder, pCalcInfo));
}
int32_t nVnodes = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &nVnodes));
pInfo->pGroupReadInfos = tSimpleHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT));
QUERY_CHECK_NULL(pInfo->pGroupReadInfos, code, lino, _exit, terrno);
tSimpleHashSetFreeFp(pInfo->pGroupReadInfos, tDestroySSTriggerGroupReadInfoArray);
for (int32_t i = 0; i < nVnodes; i++) {
int32_t vgId = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgId));
int32_t nGroups = 0;
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &nGroups));
SArray* pInfos = taosArrayInit_s(sizeof(SSTriggerGroupReadInfo), nGroups);
QUERY_CHECK_NULL(pInfos, code, lino, _exit, terrno);
code = tSimpleHashPut(pInfo->pGroupReadInfos, &vgId, sizeof(int32_t), &pInfos, POINTER_BYTES);
if (code != TSDB_CODE_SUCCESS) {
taosArrayDestroy(pInfos);
TAOS_CHECK_EXIT(code);
}
for (int32_t j = 0; j < nGroups; ++j) {
SSTriggerGroupReadInfo* pReadInfo = TARRAY_GET_ELEM(pInfos, j);
TAOS_CHECK_EXIT(tDeserializeSSTriggerGroupReadInfo(pDecoder, pReadInfo));
}
}
}
}
} else {
TAOS_CHECK_EXIT(tDeserializeSTriggerCalcParam(pDecoder, &pInfo->pStreamPesudoFuncVals, true));
TAOS_CHECK_EXIT(tDeserializeStriggerGroupColVals(pDecoder, &pInfo->pStreamPartColVals));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->groupId));
}
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->curWindow.skey));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->curWindow.ekey));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pInfo->curIdx));
TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->sessionId));
TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &pInfo->withExternalWindow));
TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pInfo->triggerType));
if (!tDecodeIsEnd(pDecoder)) {
TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &pInfo->isWindowTrigger));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pInfo->precision));
}
if (!tDecodeIsEnd(pDecoder)) {
TAOS_CHECK_EXIT(tDecodeU64(pDecoder, &pInfo->streamGen));
}
_exit:
return code;
}
void tDestroyStRtFuncInfo(SStreamRuntimeFuncInfo* pInfo){
if (pInfo == NULL) return;
if (pInfo->pStreamPesudoFuncVals != NULL) {
taosArrayDestroyEx(pInfo->pStreamPesudoFuncVals, tDestroySSTriggerCalcParam);
pInfo->pStreamPesudoFuncVals = NULL;
}
if (pInfo->pStreamPartColVals != NULL) {
taosArrayDestroyEx(pInfo->pStreamPartColVals, tDestroySStreamGroupValue);
pInfo->pStreamPartColVals = NULL;
}
if (pInfo->pGroupCalcInfos != NULL) {
tSimpleHashCleanup(pInfo->pGroupCalcInfos);
pInfo->pGroupCalcInfos = NULL;
}
if (pInfo->pGroupReadInfos != NULL) {
tSimpleHashCleanup(pInfo->pGroupReadInfos);
pInfo->pGroupReadInfos = NULL;
}
if (pInfo->outNormalTable != NULL) {
taosMemoryFreeClear(pInfo->outNormalTable);
}
}
int32_t tSerializeSStreamMsgVTableInfo(void* buf, int32_t bufLen, const SStreamMsgVTableInfo* pRsp){
SEncoder encoder = {0};
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
int32_t tlen = 0;
tEncoderInit(&encoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartEncode(&encoder));
int32_t size = taosArrayGetSize(pRsp->infos);
TAOS_CHECK_EXIT(tEncodeI32(&encoder, size));
for (int32_t i = 0; i < size; ++i) {
VTableInfo* info = taosArrayGet(pRsp->infos, i);
if (info == NULL) {
TAOS_CHECK_EXIT(terrno);
}
TAOS_CHECK_EXIT(tEncodeI64(&encoder, info->gId));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, info->uid));
TAOS_CHECK_EXIT(tEncodeSColRefWrapper(&encoder, &info->cols));
}
tEndEncode(&encoder);
_exit:
if (code != TSDB_CODE_SUCCESS) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
int32_t tDeserializeSStreamMsgVTableInfo(void* buf, int32_t bufLen, SStreamMsgVTableInfo *vTableInfo){
SDecoder decoder = {0};
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
int32_t size = 0;
tDecoderInit(&decoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &size));
vTableInfo->infos = taosArrayInit(size, sizeof(VTableInfo));
if (vTableInfo->infos == NULL) {
TAOS_CHECK_EXIT(terrno);
}
for (int32_t i = 0; i < size; ++i) {
VTableInfo* info = taosArrayReserve(vTableInfo->infos, 1);
if (info == NULL) {
TAOS_CHECK_EXIT(terrno);
}
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &info->gId));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &info->uid));
TAOS_CHECK_EXIT(tDecodeSColRefWrapperEx(&decoder, &info->cols, false));
}
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return code;
}
void tDestroyVTableInfo(void *ptr) {
if (NULL == ptr) {
return;
}
VTableInfo* pTable = (VTableInfo*)ptr;
taosMemoryFree(pTable->cols.pColRef);
}
void tDestroySStreamMsgVTableInfo(SStreamMsgVTableInfo *ptr) {
if (ptr == NULL) return;
taosArrayDestroyEx(ptr->infos, tDestroyVTableInfo);
ptr->infos = NULL;
}
int32_t tSerializeSStreamTsResponse(void* buf, int32_t bufLen, const SStreamTsResponse* pRsp) {
SEncoder encoder = {0};
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
int32_t tlen = 0;
tEncoderInit(&encoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRsp->ver));
int32_t size = taosArrayGetSize(pRsp->tsInfo);
TAOS_CHECK_EXIT(tEncodeI32(&encoder, size));
for (int32_t i = 0; i < size; ++i) {
STsInfo* tsInfo = taosArrayGet(pRsp->tsInfo, i);
TAOS_CHECK_EXIT(tEncodeI64(&encoder, tsInfo->gId));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, tsInfo->ts));
}
tEndEncode(&encoder);
_exit:
if (code != TSDB_CODE_SUCCESS) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
int32_t tDeserializeSStreamTsResponse(void* buf, int32_t bufLen, void *pBlock) {
SDecoder decoder = {0};
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
SSDataBlock *pResBlock = pBlock;
tDecoderInit(&decoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, (int64_t*)&pResBlock->info.id.groupId));
int32_t numOfCols = 2;
if (pResBlock->pDataBlock == NULL) {
pResBlock->pDataBlock = taosArrayInit_s(sizeof(SColumnInfoData), numOfCols);
if (pResBlock->pDataBlock == NULL) {
TAOS_CHECK_EXIT(terrno);
}
for (int32_t i = 0; i< numOfCols; ++i) {
SColumnInfoData *pColInfoData = taosArrayGet(pResBlock->pDataBlock, i);
if (pColInfoData == NULL) {
TAOS_CHECK_EXIT(terrno);
}
pColInfoData->info.type = TSDB_DATA_TYPE_BIGINT;
pColInfoData->info.bytes = sizeof(int64_t);
}
}
int32_t numOfRows = 0;
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &numOfRows));
TAOS_CHECK_EXIT(blockDataEnsureCapacity(pResBlock, numOfRows));
for (int32_t i = 0; i < numOfRows; ++i) {
for (int32_t j = 0; j < numOfCols; ++j) {
SColumnInfoData *pColInfoData = taosArrayGet(pResBlock->pDataBlock, j);
if (pColInfoData == NULL) {
TAOS_CHECK_EXIT(terrno);
}
int64_t value = 0;
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &value));
colDataSetInt64(pColInfoData, i, &value);
}
}
pResBlock->info.dataLoad = 1;
pResBlock->info.rows = numOfRows;
tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder);
return code;
}
static int32_t encodeData(SEncoder* encoder, void* pBlock, SSHashObj* indexHash) {
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
int32_t len = 0;
if (encoder->data == NULL){
len = blockGetEncodeSize(pBlock);
} else {
len = blockEncode(pBlock, (char*)(encoder->data + encoder->pos), encoder->size - encoder->pos, blockDataGetNumOfCols(pBlock));
if (len < 0) {
TAOS_CHECK_EXIT(terrno);
}
}
encoder->pos += len;
if (indexHash == NULL) {
goto _exit;
}
uint32_t pos = encoder->pos;
encoder->pos += sizeof(uint32_t); // reserve space for tables
int32_t tables = 0;
void* pe = NULL;
int32_t iter = 0;
while ((pe = tSimpleHashIterate(indexHash, pe, &iter)) != NULL) {
SStreamWalDataSlice* pInfo = (SStreamWalDataSlice*)pe;
if (pInfo->gId == -1){
continue;
}
int64_t uid = *(int64_t*)(tSimpleHashGetKey(pe, NULL));
TAOS_CHECK_EXIT(tEncodeI64(encoder, uid));
TAOS_CHECK_EXIT(tEncodeU64(encoder, pInfo->gId));
TAOS_CHECK_EXIT(tEncodeI32(encoder, pInfo->startRowIdx));
TAOS_CHECK_EXIT(tEncodeI32(encoder, pInfo->numRows));
tables++;
}
uint32_t tmpPos = encoder->pos;
encoder->pos = pos;
TAOS_CHECK_EXIT(tEncodeI32(encoder, tables));
encoder->pos = tmpPos;
_exit:
return code;
}
static int32_t encodeBlock(SEncoder* encoder, void* block, SSHashObj* indexHash) {
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
if (block != NULL && ((SSDataBlock*)block)->info.rows > 0) {
TAOS_CHECK_EXIT(tEncodeI8(encoder, 1));
TAOS_CHECK_EXIT(encodeData(encoder, block, indexHash));
} else {
TAOS_CHECK_EXIT(tEncodeI8(encoder, 0));
}
_exit:
return code;
}
int32_t tSerializeSStreamWalDataResponse(void* buf, int32_t bufLen, SSTriggerWalNewRsp* rsp) {
SEncoder encoder = {0};
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
int32_t tlen = 0;
tEncoderInit(&encoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(encodeBlock(&encoder, rsp->dataBlock, rsp->indexHash));
TAOS_CHECK_EXIT(encodeBlock(&encoder, rsp->metaBlock, NULL));
TAOS_CHECK_EXIT(encodeBlock(&encoder, rsp->deleteBlock, NULL));
TAOS_CHECK_EXIT(encodeBlock(&encoder, rsp->tableBlock, NULL));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, rsp->ver));
TAOS_CHECK_EXIT(tEncodeI64(&encoder, rsp->verTime));
tEndEncode(&encoder);
_exit:
if (code != TSDB_CODE_SUCCESS) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder);
return tlen;
}
static int32_t decodeBlock(SDecoder* decoder, void* pBlock) {
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
int8_t hasData = false;
TAOS_CHECK_EXIT(tDecodeI8(decoder, &hasData));
if (hasData) {
TAOS_CHECK_EXIT(pBlock != NULL ? TSDB_CODE_SUCCESS : TSDB_CODE_INVALID_PARA);
const char* pEndPos = NULL;
TAOS_CHECK_EXIT(blockDecode(pBlock, (char*)decoder->data + decoder->pos, &pEndPos));
decoder->pos = (uint8_t*)pEndPos - decoder->data;
} else if (pBlock != NULL) {
blockDataEmpty(pBlock);
}
_exit:
return code;
}
int32_t tDeserializeSStreamWalDataResponse(void* buf, int32_t bufLen, SSTriggerWalNewRsp* pRsp, SArray* pSlices){
SDecoder decoder = {0};
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
SSDataBlock* pBlock = NULL;
tDecoderInit(&decoder, buf, bufLen);
TAOS_CHECK_EXIT(tStartDecode(&decoder));
// decode data block
int8_t hasData = false;
TAOS_CHECK_EXIT(tDecodeI8(&decoder, &hasData));
pBlock = pRsp->dataBlock;
if (hasData) {
TAOS_CHECK_EXIT(pBlock != NULL ? TSDB_CODE_SUCCESS : TSDB_CODE_INVALID_PARA);
const char* pEndPos = NULL;
TAOS_CHECK_EXIT(blockDecode(pBlock, (char*)decoder.data + decoder.pos, &pEndPos));
decoder.pos = (uint8_t*)pEndPos - decoder.data;
int32_t nSlices = 0;
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nSlices));
TAOS_CHECK_EXIT(taosArrayEnsureCap(pSlices, nSlices));
taosArrayClear(pSlices);
int64_t uid = 0;
uint64_t gid = 0;
int32_t startIdx = 0;
int32_t numRows = 0;
for (int32_t i = 0; i < nSlices; i++) {
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &uid));
TAOS_CHECK_EXIT(tDecodeU64(&decoder, &gid));
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &startIdx));
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &numRows));
int32_t endIdx = startIdx + numRows;
int64_t value[3] = {gid, uid, (int64_t)startIdx << 32 | endIdx};
void* px = taosArrayPush(pSlices, value);
if (px == NULL) {
code = terrno;
goto _exit;
}
}
} else if (pBlock != NULL) {
blockDataEmpty(pBlock);
taosArrayClear(pSlices);
}
TAOS_CHECK_EXIT(decodeBlock(&decoder, pRsp->metaBlock));
TAOS_CHECK_EXIT(decodeBlock(&decoder, pRsp->deleteBlock));
TAOS_CHECK_EXIT(decodeBlock(&decoder, pRsp->tableBlock));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->ver));
TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->verTime));
tEndDecode(&decoder);
_exit:
if (code != TSDB_CODE_SUCCESS) {
uError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
}
tDecoderClear(&decoder);
return code;
}
int32_t tSerializeGetStreamCreateSqlReq(void* buf, int32_t bufLen, const SGetStreamCreateSqlReq* pReq) {
SEncoder encoder = {0};
tEncoderInit(&encoder, buf, bufLen);
int32_t code = 0, lino = 0;
TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->name));
tEndEncode(&encoder);
_exit:
if (code) uError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
int32_t len = encoder.pos;
tEncoderClear(&encoder);
return (code != 0) ? code : len;
}
int32_t tDeserializeGetStreamCreateSqlReq(void* buf, int32_t bufLen, SGetStreamCreateSqlReq* pReq) {
SDecoder decoder = {0};
tDecoderInit(&decoder, buf, bufLen);
int32_t code = 0, lino = 0;
TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->name));
tEndDecode(&decoder);
_exit:
if (code) uError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
tDecoderClear(&decoder);
return code;
}
int32_t tSerializeGetStreamCreateSqlRsp(void* buf, int32_t bufLen, const SGetStreamCreateSqlRsp* pRsp) {
SEncoder encoder = {0};
tEncoderInit(&encoder, buf, bufLen);
int32_t code = 0, lino = 0;
TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pRsp->sql ? pRsp->sql : ""));
tEndEncode(&encoder);
_exit:
if (code) uError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
int32_t len = encoder.pos;
tEncoderClear(&encoder);
return (code != 0) ? code : len;
}
int32_t tDeserializeGetStreamCreateSqlRsp(void* buf, int32_t bufLen, SGetStreamCreateSqlRsp* pRsp) {
SDecoder decoder = {0};
tDecoderInit(&decoder, buf, bufLen);
int32_t code = 0, lino = 0;
TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDecodeCStrAlloc(&decoder, &pRsp->sql));
tEndDecode(&decoder);
_exit:
if (code) uError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
tDecoderClear(&decoder);
return code;
}
void tFreeGetStreamCreateSqlRsp(SGetStreamCreateSqlRsp* pRsp) {
if (pRsp) {
taosMemoryFreeClear(pRsp->sql);
}
}
Reference in a new issue View git blame Copy permalink