taosdata/TDengine | Build 5000 | source/common/src/msg/streamMsg.c | Coveralls

27

int32_t tEncodeSStreamMgmtReq(SEncoder* pEncoder, const SStreamMgmtReq* pReq) {

131,364✔

28

  int32_t code = 0;

131,364✔

29

  int32_t lino = 0;

131,364✔

30

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pReq->reqId));

262,728✔

31

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->type));

262,728✔

32

  switch (pReq->type) {

131,364✔

33

    case STREAM_MGMT_REQ_TRIGGER_ORIGTBL_READER: {

126,634✔

34

      if (pReq->cont.pReqs) {

126,634✔

35

        int32_t num = taosArrayGetSize(pReq->cont.pReqs);

126,634✔

36

        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, num));

126,634✔

37

        for (int32_t i = 0; i < num; ++i) {

499,626✔

38

          SStreamDbTableName* pName = taosArrayGet(pReq->cont.pReqs, i);

372,992✔

39

          TAOS_CHECK_EXIT(tEncodeCStrWithLen(pEncoder, pName->dbFName, strlen(pName->dbFName) + 1));

745,984✔

40

          TAOS_CHECK_EXIT(tEncodeCStrWithLen(pEncoder, pName->tbName, strlen(pName->tbName) + 1));

745,984✔

45

      break;

126,634✔

47

    case STREAM_MGMT_REQ_RUNNER_ORIGTBL_READER: {

4,730✔

48

      if (pReq->cont.pReqs) {

4,730✔

49

        int32_t num = taosArrayGetSize(pReq->cont.pReqs);

4,730✔

50

        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, num));

4,730✔

51

        for (int32_t i = 0; i < num; ++i) {

9,460✔

52

          SStreamOReaderDeployReq* pDeploy = taosArrayGet(pReq->cont.pReqs, i);

4,730✔

53

          int32_t vgIdNum = taosArrayGetSize(pDeploy->vgIds);

4,730✔

54

          TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pDeploy->execId));

9,460✔

55

          TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pDeploy->uid));

9,460✔

56

          TAOS_CHECK_EXIT(tEncodeI32(pEncoder, vgIdNum));

4,730✔

57

          for (int32_t n = 0; n < vgIdNum; ++n) {

9,460✔

58

            TAOS_CHECK_EXIT(tEncodeI32(pEncoder, *(int32_t*)taosArrayGet(pDeploy->vgIds, n)));

9,460✔

64

      break;

4,730✔

71

_exit:

131,364✔

73

  return code;

131,364✔

76

void tFreeRunnerOReaderDeployReq(void* param) {

7,095✔

77

  SStreamOReaderDeployReq* pReq = (SStreamOReaderDeployReq*)param;

7,095✔

78

  if (pReq) {

7,095✔

79

    taosArrayDestroy(pReq->vgIds);

7,095✔

81

7,095✔

83

void tFreeSStreamMgmtReq(SStreamMgmtReq* pReq) {

262,728✔

84

  if (NULL == pReq) {

262,728✔

85

    return;

65,682✔

88

  switch (pReq->type) {

197,046✔

89

    case STREAM_MGMT_REQ_TRIGGER_ORIGTBL_READER:

189,951✔

90

      taosArrayDestroy(pReq->cont.pReqs);

189,951✔

91

      break;

189,951✔

92

    case STREAM_MGMT_REQ_RUNNER_ORIGTBL_READER:

7,095✔

93

      taosArrayDestroyEx(pReq->cont.pReqs, tFreeRunnerOReaderDeployReq);

7,095✔

94

      break;

7,095✔

101

int32_t tCloneSStreamMgmtReq(SStreamMgmtReq* pSrc, SStreamMgmtReq** ppDst) {

65,682✔

102

  *ppDst = NULL;

65,682✔

104

  if (NULL == pSrc) {

65,682✔

108

  int32_t code = 0, lino = 0;

65,682✔

109

  *ppDst = taosMemoryCalloc(1, sizeof(SStreamMgmtReq));

65,682✔

110

  TSDB_CHECK_NULL(*ppDst, code, lino, _exit, terrno);

65,682✔

112

  memcpy(*ppDst, pSrc, sizeof(*pSrc));

65,682✔

113

  if (pSrc->cont.pReqs) {

65,682✔

114

    switch (pSrc->type) {

65,682✔

115

      case STREAM_MGMT_REQ_TRIGGER_ORIGTBL_READER:

63,317✔

116

        (*ppDst)->cont.pReqs = taosArrayDup(pSrc->cont.pReqs, NULL);

63,317✔

117

        TSDB_CHECK_NULL((*ppDst)->cont.pReqs, code, lino, _exit, terrno);

63,317✔

118

        break;

63,317✔

119

      case STREAM_MGMT_REQ_RUNNER_ORIGTBL_READER: {

2,365✔

120

        int32_t reqNum = taosArrayGetSize(pSrc->cont.pReqs);

2,365✔

121

        (*ppDst)->cont.pReqs = taosArrayInit_s(sizeof(SStreamOReaderDeployReq), reqNum);

2,365✔

122

        TSDB_CHECK_NULL((*ppDst)->cont.pReqs, code, lino, _exit, terrno);

2,365✔

123

        for (int32_t i = 0; i < reqNum; ++i) {

4,730✔

124

          SStreamOReaderDeployReq* pNew = taosArrayGet((*ppDst)->cont.pReqs, i);

2,365✔

125

          SStreamOReaderDeployReq* pReq = taosArrayGet(pSrc->cont.pReqs, i);

2,365✔

126

          pNew->vgIds = taosArrayDup(pReq->vgIds, NULL);

2,365✔

127

          TSDB_CHECK_NULL(pNew->vgIds, code, lino, _exit, terrno);

2,365✔

128

          pNew->execId = pReq->execId;

2,365✔

129

          pNew->uid = pReq->uid;

2,365✔

131

        break;

2,365✔

140

  if (code) {

65,682✔

146

  return code;

65,682✔

150

int32_t tDecodeSStreamMgmtReq(SDecoder* pDecoder, SStreamMgmtReq* pReq) {

65,682✔

151

  int32_t code = 0;

65,682✔

152

  int32_t lino = 0;

65,682✔

154

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->reqId));

131,364✔

155

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, (int32_t*)&pReq->type));

131,364✔

156

  switch (pReq->type) {

65,682✔

157

    case STREAM_MGMT_REQ_TRIGGER_ORIGTBL_READER: {

63,317✔

158

      int32_t num = 0;

63,317✔

159

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &num));

63,317✔

160

      if (num > 0) {

63,317✔

161

        pReq->cont.pReqs = taosArrayInit(num, sizeof(SStreamDbTableName));

63,317✔

162

        TSDB_CHECK_NULL(pReq->cont.pReqs, code, lino, _exit, terrno);

63,317✔

163

        for (int32_t i = 0; i < num; ++i) {

249,813✔

164

          SStreamDbTableName* p = taosArrayReserve(pReq->cont.pReqs, 1);

186,496✔

165

          TAOS_CHECK_EXIT(tDecodeCStrTo(pDecoder, p->dbFName));

186,496✔

166

          TAOS_CHECK_EXIT(tDecodeCStrTo(pDecoder, p->tbName));

186,496✔

169

      break;

63,317✔

171

    case STREAM_MGMT_REQ_RUNNER_ORIGTBL_READER: {

2,365✔

172

      int32_t num = 0, vgIdNum = 0;

2,365✔

173

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &num));

2,365✔

174

      if (num > 0) {

2,365✔

175

        pReq->cont.pReqs = taosArrayInit_s(sizeof(SStreamOReaderDeployReq), num);

2,365✔

176

        TSDB_CHECK_NULL(pReq->cont.pReqs, code, lino, _exit, terrno);

2,365✔

177

        for (int32_t i = 0; i < num; ++i) {

4,730✔

178

          SStreamOReaderDeployReq* p = taosArrayGet(pReq->cont.pReqs, i);

2,365✔

179

          TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &p->execId));

4,730✔

180

          TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &p->uid));

4,730✔

181

          TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgIdNum));

2,365✔

182

          if (vgIdNum > 0) {

2,365✔

183

            p->vgIds = taosArrayInit_s(sizeof(int32_t), vgIdNum);

2,365✔

184

            TSDB_CHECK_NULL(p->vgIds, code, lino, _exit, terrno);

2,365✔

186

          for (int32_t n = 0; n < vgIdNum; ++n) {

4,730✔

187

            int32_t* vgId = taosArrayGet(p->vgIds, n);

2,365✔

188

            TAOS_CHECK_EXIT(tDecodeI32(pDecoder, vgId));

2,365✔

192

      break;

2,365✔

199

_exit:

65,682✔

201

  return code;

65,682✔

204

int32_t tEncodeStreamTask(SEncoder* pEncoder, const SStreamTask* pTask) {

72,498,812✔

205

  int32_t code = 0;

72,498,812✔

208

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->type));

144,997,624✔

209

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->streamId));

144,997,624✔

210

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->taskId));

144,997,624✔

212

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->flags));

144,997,624✔

213

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->seriousId));

144,997,624✔

214

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->deployId));

144,997,624✔

215

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->nodeId));

144,997,624✔

217

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->taskIdx));

144,997,624✔

218

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->status));

144,997,624✔

219

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->detailStatus));

144,997,624✔

220

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->errorCode));

144,997,624✔

221

  if (pTask->pMgmtReq) {

72,498,812✔

222

    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, 1));

131,364✔

223

    TAOS_CHECK_EXIT(tEncodeSStreamMgmtReq(pEncoder, pTask->pMgmtReq));

131,364✔

225

    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, 0));

72,367,448✔

228

_exit:

72,367,448✔

230

  return code;

72,498,812✔

234

int32_t tDecodeStreamTask(SDecoder* pDecoder, SStreamTask* pTask) {

34,770,212✔

235

  int32_t code = 0;

34,770,212✔

238

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, (int32_t*)&pTask->type));

69,540,424✔

239

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->streamId));

69,540,424✔

240

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->taskId));

69,540,424✔

242

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->flags));

69,540,424✔

243

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->seriousId));

69,540,424✔

244

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pTask->deployId));

69,540,424✔

245

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pTask->nodeId));

69,540,424✔

247

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pTask->taskIdx));

69,540,424✔

248

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, (int32_t*)&pTask->status));

69,540,424✔

249

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pTask->detailStatus));

69,540,424✔

250

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pTask->errorCode));

69,540,424✔

251

  int32_t req = 0;

34,770,212✔

252

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &req));

34,770,212✔

253

  if (req) {

34,770,212✔

254

    pTask->pMgmtReq = taosMemoryCalloc(1, sizeof(SStreamMgmtReq));

65,682✔

255

    TSDB_CHECK_NULL(pTask->pMgmtReq, code, lino, _exit, terrno);

65,682✔

256

    TAOS_CHECK_EXIT(tDecodeSStreamMgmtReq(pDecoder, pTask->pMgmtReq));

65,682✔

259

_exit:

34,770,212✔

261

  return code;

34,770,212✔

293

int32_t tEncodeSSTriggerRuntimeStatus(SEncoder* pEncoder, const SSTriggerRuntimeStatus* pStatus) {

4,261,270✔

294

  int32_t code = 0;

4,261,270✔

297

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pStatus->autoRecalcNum));

8,522,540✔

298

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pStatus->realtimeSessionNum));

8,522,540✔

299

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pStatus->historySessionNum));

8,522,540✔

300

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pStatus->recalcSessionNum));

8,522,540✔

301

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pStatus->histroyProgress));

8,522,540✔

303

  int32_t recalcNum = (int32_t)taosArrayGetSize(pStatus->userRecalcs);

4,261,270✔

304

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, recalcNum));

4,261,270✔

305

  for (int32_t i = 0; i < recalcNum; ++i) {

4,261,270✔

310

_exit:

4,261,270✔

312

  return code;

4,261,270✔

315

int32_t tDecodeSSTriggerRuntimeStatus(SDecoder* pDecoder, SSTriggerRuntimeStatus* pStatus) {

1,991,273✔

316

  int32_t code = 0;

1,991,273✔

319

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pStatus->autoRecalcNum));

3,982,546✔

320

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pStatus->realtimeSessionNum));

3,982,546✔

321

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pStatus->historySessionNum));

3,982,546✔

322

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pStatus->realtimeSessionNum));

3,982,546✔

323

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pStatus->histroyProgress));

3,982,546✔

325

  int32_t recalcNum = 0;

1,991,273✔

326

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &recalcNum));

1,991,273✔

327

  if (recalcNum > 0) {

1,991,273✔

335

  for (int32_t i = 0; i < recalcNum; ++i) {

1,991,273✔

340

_exit:

1,991,273✔

342

  return code;

1,991,273✔

346

int32_t tEncodeStreamHbMsg(SEncoder* pEncoder, const SStreamHbMsg* pReq) {

30,258,200✔

347

  int32_t code = 0;

30,258,200✔

350

  TAOS_CHECK_EXIT(tStartEncode(pEncoder));

30,258,200✔

351

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->dnodeId));

60,516,400✔

352

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->streamGId));

60,516,400✔

353

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->snodeId));

60,516,400✔

354

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->runnerThreadNum));

60,516,400✔

356

  int32_t vgLeaderNum = taosArrayGetSize(pReq->pVgLeaders);

30,258,200✔

357

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, vgLeaderNum));

30,258,200✔

358

  for (int32_t i = 0; i < vgLeaderNum; ++i) {

118,509,514✔

359

    int32_t* vgId = taosArrayGet(pReq->pVgLeaders, i);

88,251,314✔

360

    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, *vgId));

176,502,628✔

363

  int32_t statusNum = taosArrayGetSize(pReq->pStreamStatus);

30,258,200✔

364

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, statusNum));

30,258,200✔

365

  for (int32_t i = 0; i < statusNum; ++i) {

98,531,626✔

366

    SStmTaskStatusMsg* pStatus = taosArrayGet(pReq->pStreamStatus, i);

68,273,426✔

367

    TAOS_CHECK_EXIT(tEncodeStreamTask(pEncoder, (SStreamTask*)pStatus));

68,273,426✔

370

  int32_t reqNum = taosArrayGetSize(pReq->pStreamReq);

30,258,200✔

371

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, reqNum));

30,258,200✔

372

  for (int32_t i = 0; i < reqNum; ++i) {

30,389,564✔

373

    int32_t* idx = taosArrayGet(pReq->pStreamReq, i);

131,364✔

374

    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, *idx));

262,728✔

377

  int32_t triggerNum = taosArrayGetSize(pReq->pTriggerStatus);

30,258,200✔

378

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, triggerNum));

30,258,200✔

379

  for (int32_t i = 0; i < triggerNum; ++i) {

34,519,470✔

380

    SSTriggerRuntimeStatus* pTrigger = taosArrayGet(pReq->pTriggerStatus, i);

4,261,270✔

381

    TAOS_CHECK_EXIT(tEncodeSSTriggerRuntimeStatus(pEncoder, pTrigger));

4,261,270✔

384

  tEndEncode(pEncoder);

30,258,200✔

386

_exit:

30,258,200✔

387

  if (code) {

30,258,200✔

390

    return pEncoder->pos;

30,258,200✔

394

int32_t tDecodeStreamHbMsg(SDecoder* pDecoder, SStreamHbMsg* pReq) {

14,474,546✔

395

  int32_t code = 0;

14,474,546✔

398

  TAOS_CHECK_EXIT(tStartDecode(pDecoder));

14,474,546✔

399

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->dnodeId));

28,949,092✔

400

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->streamGId));

28,949,092✔

401

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->snodeId));

28,949,092✔

402

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->runnerThreadNum));

28,949,092✔

404

  int32_t vgLearderNum = 0;

14,474,546✔

405

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgLearderNum));

14,474,546✔

406

  if (vgLearderNum > 0) {

14,474,546✔

407

    pReq->pVgLeaders = taosArrayInit(vgLearderNum, sizeof(int32_t));

11,188,472✔

408

    if (NULL == pReq->pVgLeaders) {

11,188,472✔

413

  for (int32_t i = 0; i < vgLearderNum; ++i) {

57,467,743✔

414

    int32_t vgId = 0;

42,993,197✔

415

    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgId));

42,993,197✔

416

    if (NULL == taosArrayPush(pReq->pVgLeaders, &vgId)) {

85,986,394✔

423

  int32_t statusNum = 0;

14,474,546✔

424

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &statusNum));

14,474,546✔

425

  if (statusNum > 0) {

14,474,546✔

426

    pReq->pStreamStatus = taosArrayInit_s(sizeof(SStmTaskStatusMsg), statusNum);

1,034,834✔

427

    if (NULL == pReq->pStreamStatus) {

1,034,834✔

432

  for (int32_t i = 0; i < statusNum; ++i) {

47,133,282✔

433

    SStmTaskStatusMsg* pTask = taosArrayGet(pReq->pStreamStatus, i);

32,658,736✔

434

    if (NULL == pTask) {

32,658,736✔

438

    TAOS_CHECK_EXIT(tDecodeStreamTask(pDecoder, (SStreamTask*)pTask));

32,658,736✔

442

  int32_t reqNum = 0;

14,474,546✔

443

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &reqNum));

14,474,307✔

444

  if (reqNum > 0) {

14,474,307✔

445

    pReq->pStreamReq = taosArrayInit_s(sizeof(int32_t), reqNum);

19,549✔

446

    if (NULL == pReq->pStreamReq) {

19,549✔

451

  for (int32_t i = 0; i < reqNum; ++i) {

14,539,989✔

452

    int32_t* pIdx = taosArrayGet(pReq->pStreamReq, i);

65,682✔

453

    if (NULL == pIdx) {

65,682✔

457

    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, pIdx));

65,682✔

461

  int32_t triggerNum = 0;

14,474,307✔

462

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &triggerNum));

14,474,546✔

463

  if (triggerNum > 0) {

14,474,546✔

464

    pReq->pTriggerStatus = taosArrayInit_s(sizeof(SSTriggerRuntimeStatus), triggerNum);

481,758✔

465

    if (NULL == pReq->pTriggerStatus) {

481,758✔

470

  for (int32_t i = 0; i < triggerNum; ++i) {

16,465,819✔

471

    SSTriggerRuntimeStatus* pStatus = taosArrayGet(pReq->pTriggerStatus, i);

1,991,273✔

472

    if (NULL == pStatus) {

1,991,273✔

476

    TAOS_CHECK_EXIT(tDecodeSSTriggerRuntimeStatus(pDecoder, pStatus));

1,991,273✔

480

  tEndDecode(pDecoder);

14,474,546✔

482

_exit:

14,474,546✔

483

  return code;

14,474,546✔

486

void tFreeSSTriggerRuntimeStatus(void* param) {

4,121,908✔

487

  SSTriggerRuntimeStatus* pStatus = (SSTriggerRuntimeStatus*)param;

4,121,908✔

488

  if (NULL == pStatus) {

4,121,908✔

491

  taosArrayDestroy(pStatus->userRecalcs);

4,121,908✔

494

void tCleanupStreamHbMsg(SStreamHbMsg* pMsg, bool deepClean) {

87,835,505✔

495

  if (pMsg == NULL) {

87,835,505✔

499

  taosArrayDestroy(pMsg->pVgLeaders);

87,835,505✔

500

  if (deepClean) {

87,835,505✔

501

    int32_t reqNum = taosArrayGetSize(pMsg->pStreamReq);

87,835,505✔

502

    for (int32_t i = 0; i < reqNum; ++i) {

87,966,869✔

503

      int32_t* idx = taosArrayGet(pMsg->pStreamReq, i);

131,364✔

504

      SStmTaskStatusMsg* pTask = taosArrayGet(pMsg->pStreamStatus, *idx);

131,364✔

505

      if (NULL == pTask) {

131,364✔

509

      tFreeSStreamMgmtReq(pTask->pMgmtReq);

131,364✔

510

      taosMemoryFree(pTask->pMgmtReq);

131,364✔

513

  taosArrayDestroy(pMsg->pStreamReq);

87,835,505✔

514

  taosArrayDestroy(pMsg->pStreamStatus);

87,835,177✔

515

  taosArrayDestroyEx(pMsg->pTriggerStatus, tFreeSSTriggerRuntimeStatus);

87,835,177✔

518

int32_t tEncodeSStreamReaderDeployFromTrigger(SEncoder* pEncoder, const SStreamReaderDeployFromTrigger* pMsg) {

603,102✔

519

  int32_t code = 0;

603,102✔

522

  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, (const uint8_t*)pMsg->triggerTblName, pMsg->triggerTblName == NULL ? 0 : (int32_t)strlen(pMsg->triggerTblName) + 1));

1,206,204✔

523

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->triggerTblUid));

1,206,204✔

524

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->triggerTblSuid));

1,206,204✔

525

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->triggerTblType));

1,206,204✔

526

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->isTriggerTblVirt));

1,206,204✔

527

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->deleteReCalc));

1,206,204✔

528

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->deleteOutTbl));

1,206,204✔

529

  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->partitionCols, pMsg->partitionCols == NULL ? 0 : (int32_t)strlen(pMsg->partitionCols) + 1));

1,206,204✔

530

  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->triggerCols, pMsg->triggerCols == NULL ? 0 : (int32_t)strlen(pMsg->triggerCols) + 1));

1,206,204✔

532

  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->triggerScanPlan, pMsg->triggerScanPlan == NULL ? 0 : (int32_t)strlen(pMsg->triggerScanPlan) + 1));

1,206,204✔

533

  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->calcCacheScanPlan, pMsg->calcCacheScanPlan == NULL ? 0 : (int32_t)strlen(pMsg->calcCacheScanPlan) + 1));

1,206,204✔

535

_exit:

603,102✔

537

  return code;

603,102✔

540

int32_t tEncodeSStreamReaderDeployFromCalc(SEncoder* pEncoder, const SStreamReaderDeployFromCalc* pMsg) {

770,776✔

541

  int32_t code = 0;

770,776✔

544

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->execReplica));

1,541,552✔

545

  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->calcScanPlan, pMsg->calcScanPlan == NULL ? 0 : (int32_t)strlen(pMsg->calcScanPlan) + 1));

1,541,552✔

547

_exit:

770,776✔

549

  return code;

770,776✔

553

int32_t tEncodeSStreamReaderDeployMsg(SEncoder* pEncoder, const SStreamReaderDeployMsg* pMsg) {

1,373,878✔

554

  int32_t code = 0;

1,373,878✔

557

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->triggerReader));

2,747,756✔

558

  if (pMsg->triggerReader) {

1,373,878✔

559

    TAOS_CHECK_EXIT(tEncodeSStreamReaderDeployFromTrigger(pEncoder, &pMsg->msg.trigger));

603,102✔

561

    TAOS_CHECK_EXIT(tEncodeSStreamReaderDeployFromCalc(pEncoder, &pMsg->msg.calc));

770,776✔

564

_exit:

770,776✔

566

  return code;

1,373,878✔

569

int32_t tEncodeSStreamTaskAddr(SEncoder* pEncoder, const SStreamTaskAddr* pMsg) {

1,763,424✔

570

  int32_t code = 0;

1,763,424✔

573

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->taskId));

3,526,848✔

574

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->nodeId));

3,526,848✔

575

  TAOS_CHECK_EXIT(tEncodeSEpSet(pEncoder, &pMsg->epset));

1,763,424✔

577

_exit:

1,763,424✔

579

  return code;

1,763,424✔

582

int32_t tEncodeSStreamRunnerTarget(SEncoder* pEncoder, const SStreamRunnerTarget* pMsg) {

1,133,550✔

583

  int32_t code = 0;

1,133,550✔

586

  TAOS_CHECK_EXIT(tEncodeSStreamTaskAddr(pEncoder, &pMsg->addr));

1,133,550✔

587

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->execReplica));

2,267,100✔

589

_exit:

1,133,550✔

591

  return code;

1,133,550✔

595

int32_t tEncodeSStreamTriggerDeployMsg(SEncoder* pEncoder, const SStreamTriggerDeployMsg* pMsg) {

384,458✔

596

  int32_t code = 0;

384,458✔

599

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->triggerType));

768,916✔

600

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->igDisorder));

768,916✔

601

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->fillHistory));

768,916✔

602

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->fillHistoryFirst));

768,916✔

603

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->lowLatencyCalc));

768,916✔

604

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->igNoDataTrigger));

768,916✔

605

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->isTriggerTblVirt));

768,916✔

606

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->triggerHasPF));

768,916✔

607

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->isTriggerTblStb));

768,916✔

608

  int32_t partitionColsLen = pMsg->partitionCols == NULL ? 0 : (int32_t)strlen((char*)pMsg->partitionCols) + 1;

384,458✔

609

  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->partitionCols, partitionColsLen));

768,916✔

611

  int32_t addrSize = (int32_t)taosArrayGetSize(pMsg->pNotifyAddrUrls);

384,458✔

612

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, addrSize));

384,458✔

613

  for (int32_t i = 0; i < addrSize; ++i) {

494,586✔

614

    const char *url = taosArrayGetP(pMsg->pNotifyAddrUrls, i);

110,128✔

615

    TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, url, NULL == url ? 0 : (int32_t)strlen(url) + 1));

220,256✔

617

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->notifyEventTypes));

768,916✔

618

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->addOptions));

768,916✔

619

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->notifyHistory));

768,916✔

621

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->maxDelay));

768,916✔

622

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->fillHistoryStartTime));

768,916✔

623

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->watermark));

768,916✔

624

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->expiredTime));

768,916✔

626

  switch (pMsg->triggerType) {

384,458✔

627

    case WINDOW_TYPE_SESSION: {

16,702✔

629

      TAOS_CHECK_EXIT(tEncodeI16(pEncoder, pMsg->trigger.session.slotId));

33,404✔

630

      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.session.sessionVal));

33,404✔

631

      break;

16,702✔

633

    case WINDOW_TYPE_STATE: {

128,546✔

635

      TAOS_CHECK_EXIT(tEncodeI16(pEncoder, pMsg->trigger.stateWin.slotId));

257,092✔

636

      TAOS_CHECK_EXIT(tEncodeI16(pEncoder, pMsg->trigger.stateWin.extend));

257,092✔

637

      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->trigger.stateWin.trueForType));

257,092✔

638

      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->trigger.stateWin.trueForCount));

257,092✔

639

      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.stateWin.trueForDuration));

257,092✔

640

      int32_t stateWindowZerothLen =

128,546✔

641

          pMsg->trigger.stateWin.zeroth == NULL ? 0 : (int32_t)strlen((char*)pMsg->trigger.stateWin.zeroth) + 1;

128,546✔

642

      TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->trigger.stateWin.zeroth, stateWindowZerothLen));

257,092✔

643

      int32_t stateWindowExprLen =

128,546✔

644

          pMsg->trigger.stateWin.expr == NULL ? 0 : (int32_t)strlen((char*)pMsg->trigger.stateWin.expr) + 1;

128,546✔

645

      TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->trigger.stateWin.expr, stateWindowExprLen));

257,092✔

646

      break;

128,546✔

648

    case WINDOW_TYPE_INTERVAL: {

142,088✔

650

      TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.sliding.intervalUnit));

284,176✔

651

      TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.sliding.slidingUnit));

284,176✔

652

      TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.sliding.offsetUnit));

284,176✔

653

      TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.sliding.soffsetUnit));

284,176✔

654

      TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.sliding.precision));

284,176✔

655

      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.sliding.interval));

284,176✔

656

      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.sliding.offset));

284,176✔

657

      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.sliding.sliding));

284,176✔

658

      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.sliding.soffset));

284,176✔

659

      break;

142,088✔

661

    case WINDOW_TYPE_EVENT: {

47,460✔

663

      int32_t eventWindowStartCondLen = pMsg->trigger.event.startCond == NULL ? 0 : (int32_t)strlen((char*)pMsg->trigger.event.startCond) + 1;

47,460✔

664

      int32_t eventWindowEndCondLen = pMsg->trigger.event.endCond == NULL ? 0 : (int32_t)strlen((char*)pMsg->trigger.event.endCond) + 1;

47,460✔

666

      TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->trigger.event.startCond, eventWindowStartCondLen));

94,920✔

667

      TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->trigger.event.endCond, eventWindowEndCondLen));

94,920✔

668

      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->trigger.event.trueForType));

94,920✔

669

      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->trigger.event.trueForCount));

94,920✔

670

      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.event.trueForDuration));

94,920✔

671

      break;

47,460✔

673

    case WINDOW_TYPE_COUNT: {

35,078✔

675

      int32_t countWindowCondColsLen = pMsg->trigger.count.condCols == NULL ? 0 : (int32_t)strlen((char*)pMsg->trigger.count.condCols) + 1;

35,078✔

676

      TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->trigger.count.condCols, countWindowCondColsLen));

70,156✔

678

      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.count.countVal));

70,156✔

679

      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.count.sliding));

70,156✔

680

      break;

35,078✔

682

    case WINDOW_TYPE_PERIOD: {

14,584✔

684

      TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.period.periodUnit));

29,168✔

685

      TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.period.offsetUnit));

29,168✔

686

      TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.period.precision));

29,168✔

687

      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.period.period));

29,168✔

688

      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.period.offset));

29,168✔

689

      break;

14,584✔

696

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->eventTypes));

768,916✔

697

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->placeHolderBitmap));

768,916✔

698

  TAOS_CHECK_EXIT(tEncodeI16(pEncoder, pMsg->calcTsSlotId));

768,916✔

699

  TAOS_CHECK_EXIT(tEncodeI16(pEncoder, pMsg->triTsSlotId));

768,916✔

700

  TAOS_CHECK_EXIT(tEncodeI16(pEncoder, pMsg->calcPkSlotId));

768,916✔

701

  TAOS_CHECK_EXIT(tEncodeI16(pEncoder, pMsg->triPkSlotId));

768,916✔

702

  int32_t triggerPrevFilterLen = (pMsg->triggerPrevFilter == NULL) ? 0 : ((int32_t)strlen(pMsg->triggerPrevFilter) + 1);

384,458✔

703

  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->triggerPrevFilter, triggerPrevFilterLen));

768,916✔

704

  int32_t triggerScanPlanLen = (pMsg->triggerScanPlan == NULL) ? 0 : ((int32_t)strlen(pMsg->triggerScanPlan) + 1);

384,458✔

705

  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->triggerScanPlan, triggerScanPlanLen));

768,916✔

706

  int32_t calcCacheScanPlanLen = (pMsg->calcCacheScanPlan == NULL) ? 0 : ((int32_t)strlen(pMsg->calcCacheScanPlan) + 1);

384,458✔

707

  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->calcCacheScanPlan, calcCacheScanPlanLen));

768,916✔

709

  int32_t readerNum = taosArrayGetSize(pMsg->readerList);

384,458✔

710

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, readerNum));

384,458✔

711

  for (int32_t i = 0; i < readerNum; ++i) {

863,278✔

712

    SStreamTaskAddr* pAddr = (SStreamTaskAddr*)taosArrayGet(pMsg->readerList, i);

478,820✔

713

    TAOS_CHECK_EXIT(tEncodeSStreamTaskAddr(pEncoder, pAddr));

478,820✔

716

  int32_t runnerNum = taosArrayGetSize(pMsg->runnerList);

384,458✔

717

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, runnerNum));

384,458✔

718

  for (int32_t i = 0; i < runnerNum; ++i) {

1,518,008✔

719

    SStreamRunnerTarget* pTarget = (SStreamRunnerTarget*)taosArrayGet(pMsg->runnerList, i);

1,133,550✔

720

    TAOS_CHECK_EXIT(tEncodeSStreamRunnerTarget(pEncoder, pTarget));

1,133,550✔

723

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->leaderSnodeId));

768,916✔

724

  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->streamName, (int32_t)strlen(pMsg->streamName) + 1));

768,916✔

725

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->precision));

768,916✔

727

_exit:

384,458✔

729

  return code;

384,458✔

733

int32_t tSerializeSFieldWithOptions(SEncoder* pEncoder, const SFieldWithOptions *pField) {

6,642,210✔

734

  int32_t code = 0;

6,642,210✔

737

  TAOS_CHECK_EXIT(tEncodeCStr(pEncoder, pField->name));

13,284,420✔

738

  TAOS_CHECK_EXIT(tEncodeU8(pEncoder, pField->type));

13,284,420✔

739

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pField->flags));

13,284,420✔

740

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pField->bytes));

13,284,420✔

741

  TAOS_CHECK_EXIT(tEncodeU32(pEncoder, pField->compress));

13,284,420✔

742

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pField->typeMod));

13,284,420✔

744

_exit:

6,642,210✔

746

  return code;

6,642,210✔

750

int32_t tEncodeSStreamRunnerDeployMsg(SEncoder* pEncoder, const SStreamRunnerDeployMsg* pMsg) {

1,344,996✔

751

  int32_t code = 0;

1,344,996✔

754

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->execReplica));

2,689,992✔

755

  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->streamName, (int32_t)strlen(pMsg->streamName) + 1));

2,689,992✔

756

  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->pPlan, NULL == pMsg->pPlan ? 0 : (int32_t)strlen(pMsg->pPlan) + 1));

2,689,992✔

757

  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->outDBFName, NULL == pMsg->outDBFName ? 0 : (int32_t)strlen(pMsg->outDBFName) + 1));

2,689,992✔

758

  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->outTblName, NULL == pMsg->outTblName ? 0 : (int32_t)strlen(pMsg->outTblName) + 1));

2,689,992✔

759

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->outTblType));

2,689,992✔

760

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->calcNotifyOnly));

2,689,992✔

761

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->topPlan));

2,689,992✔

763

  int32_t addrSize = (int32_t)taosArrayGetSize(pMsg->pNotifyAddrUrls);

1,344,996✔

764

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, addrSize));

1,344,996✔

765

  for (int32_t i = 0; i < addrSize; ++i) {

1,655,556✔

766

    const char *url = taosArrayGetP(pMsg->pNotifyAddrUrls, i);

310,560✔

767

    TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, url, NULL == url ? 0 : (int32_t)strlen(url) + 1));

621,120✔

769

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->addOptions));

2,689,992✔

771

  int32_t outColNum = (int32_t)taosArrayGetSize(pMsg->outCols);

1,344,996✔

772

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, outColNum));

1,344,996✔

773

  for (int32_t i = 0; i < outColNum; ++i) {

6,880,632✔

774

    SFieldWithOptions *pCol = taosArrayGet(pMsg->outCols, i);

5,535,636✔

775

    TAOS_CHECK_EXIT(tSerializeSFieldWithOptions(pEncoder, pCol));

5,535,636✔

778

  int32_t outTagNum = (int32_t)taosArrayGetSize(pMsg->outTags);

1,344,996✔

779

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, outTagNum));

1,344,996✔

780

  for (int32_t i = 0; i < outTagNum; ++i) {

2,451,570✔

781

    SFieldWithOptions *pTag = taosArrayGet(pMsg->outTags, i);

1,106,574✔

782

    TAOS_CHECK_EXIT(tSerializeSFieldWithOptions(pEncoder, pTag));

1,106,574✔

785

  TAOS_CHECK_EXIT(tEncodeU64(pEncoder, pMsg->outStbUid));

2,689,992✔

786

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->outStbSversion));

2,689,992✔

788

  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->subTblNameExpr, NULL == pMsg->subTblNameExpr ? 0 : (int32_t)strlen(pMsg->subTblNameExpr) + 1));

2,689,992✔

789

  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->tagValueExpr, NULL == pMsg->tagValueExpr ? 0 : (int32_t)strlen(pMsg->tagValueExpr) + 1));

2,689,992✔

791

  int32_t forceOutColsSize = (int32_t)taosArrayGetSize(pMsg->forceOutCols);

1,344,996✔

792

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, forceOutColsSize));

1,344,996✔

793

  for (int32_t i = 0; i < forceOutColsSize; ++i) {

1,474,926✔

794

    SStreamOutCol *pCoutCol = (SStreamOutCol*)taosArrayGet(pMsg->forceOutCols, i);

129,930✔

795

    int32_t        exprLen = pCoutCol->expr == NULL ? 0 : (int32_t)strlen((char*)pCoutCol->expr) + 1;

129,930✔

797

    TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pCoutCol->expr, exprLen));

259,860✔

798

    TAOS_CHECK_EXIT(tEncodeU8(pEncoder, pCoutCol->type.type));

259,860✔

799

    TAOS_CHECK_EXIT(tEncodeU8(pEncoder, pCoutCol->type.precision));

259,860✔

800

    TAOS_CHECK_EXIT(tEncodeU8(pEncoder, pCoutCol->type.scale));

259,860✔

801

    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pCoutCol->type.bytes));

259,860✔

804

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->lowLatencyCalc));

2,689,992✔

807

  int32_t colCidsSize = (int32_t)taosArrayGetSize(pMsg->colCids);

1,344,996✔

808

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, colCidsSize));

1,344,996✔

809

  if (colCidsSize > 0) {

1,344,996✔

810

    for (int32_t i = 0; i < colCidsSize; ++i) {

97,608✔

811

      int16_t* pCid = (int16_t*)taosArrayGet(pMsg->colCids, i);

73,626✔

812

      TAOS_CHECK_EXIT(tEncodeI16(pEncoder, *pCid));

147,252✔

816

  int32_t tagCidsSize = (int32_t)taosArrayGetSize(pMsg->tagCids);

1,344,996✔

817

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, tagCidsSize));

1,344,996✔

818

  if (tagCidsSize > 0) {

1,344,996✔

819

    for (int32_t i = 0; i < tagCidsSize; ++i) {

48,594✔

820

      int16_t* pCid = (int16_t*)taosArrayGet(pMsg->tagCids, i);

28,458✔

821

      TAOS_CHECK_EXIT(tEncodeI16(pEncoder, *pCid));

56,916✔

825

_exit:

1,344,996✔

827

  return code;

1,344,996✔

830

int32_t tEncodeSStmTaskDeploy(SEncoder* pEncoder, const SStmTaskDeploy* pTask) {

3,103,332✔

831

  int32_t code = 0;

3,103,332✔

834

  TAOS_CHECK_EXIT(tEncodeStreamTask(pEncoder, (SStreamTask*)&pTask->task));

3,103,332✔

835

  switch (pTask->task.type) {

3,103,332✔

836

    case STREAM_READER_TASK:

1,373,878✔

837

      TAOS_CHECK_EXIT(tEncodeSStreamReaderDeployMsg(pEncoder, &pTask->msg.reader));

1,373,878✔

838

      break;

1,373,878✔

839

    case STREAM_TRIGGER_TASK:

384,458✔

840

      TAOS_CHECK_EXIT(tEncodeSStreamTriggerDeployMsg(pEncoder, &pTask->msg.trigger));

384,458✔

841

      break;

384,458✔

842

    case STREAM_RUNNER_TASK:

1,344,996✔

843

      TAOS_CHECK_EXIT(tEncodeSStreamRunnerDeployMsg(pEncoder, &pTask->msg.runner));

1,344,996✔

844

      break;

1,344,996✔

850

_exit:

3,103,332✔

852

  return code;

3,103,332✔

856

int32_t tEncodeSStmStreamDeploy(SEncoder* pEncoder, const SStmStreamDeploy* pStream) {

525,434✔

857

  int32_t code = 0;

525,434✔

860

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pStream->streamId));

1,050,868✔

862

  int32_t readerNum = taosArrayGetSize(pStream->readerTasks);

525,434✔

863

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, readerNum));

525,434✔

864

  for (int32_t i = 0; i < readerNum; ++i) {

1,899,312✔

865

    SStmTaskDeploy* pDeploy = taosArrayGet(pStream->readerTasks, i);

1,373,878✔

866

    TAOS_CHECK_EXIT(tEncodeSStmTaskDeploy(pEncoder, pDeploy));

1,373,878✔

869

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pStream->triggerTask ? 1 : 0));

1,050,868✔

870

  if (pStream->triggerTask) {

525,434✔

871

    TAOS_CHECK_EXIT(tEncodeSStmTaskDeploy(pEncoder, pStream->triggerTask));

384,458✔

874

  int32_t runnerNum = taosArrayGetSize(pStream->runnerTasks);

525,434✔

875

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, runnerNum));

525,434✔

876

  for (int32_t i = 0; i < runnerNum; ++i) {

1,870,430✔

877

    SStmTaskDeploy* pDeploy = taosArrayGet(pStream->runnerTasks, i);

1,344,996✔

878

    TAOS_CHECK_EXIT(tEncodeSStmTaskDeploy(pEncoder, pDeploy));

1,344,996✔

881

_exit:

525,434✔

883

  return code;

525,434✔

886

int32_t tEncodeSStreamMsg(SEncoder* pEncoder, const SStreamMsg* pMsg) {

1,122,054✔

887

  int32_t code = 0;

1,122,054✔

888

  int32_t lino = 0;

1,122,054✔

890

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->msgType));

2,244,108✔

892

_exit:

1,122,054✔

893

  return code;

1,122,054✔

896

int32_t tDecodeSStreamMsg(SDecoder* pDecoder, SStreamMsg* pMsg) {

561,026✔

897

  int32_t code = 0;

561,026✔

900

  int32_t type = 0;

561,026✔

901

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &type));

561,026✔

902

  pMsg->msgType = type;

561,026✔

904

_exit:

561,026✔

905

  return code;

561,026✔

908

int32_t tEncodeSStreamStartTaskMsg(SEncoder* pEncoder, const SStreamStartTaskMsg* pStart) {

501,820✔

909

  int32_t code = 0;

501,820✔

912

  TAOS_CHECK_EXIT(tEncodeSStreamMsg(pEncoder, &pStart->header));

501,820✔

914

_exit:

501,820✔

916

  return code;

501,820✔

919

int32_t tEncodeSStreamTaskStart(SEncoder* pEncoder, const SStreamTaskStart* pTask) {

501,820✔

920

  int32_t code = 0;

501,820✔

923

  TAOS_CHECK_EXIT(tEncodeStreamTask(pEncoder, (SStreamTask*)&pTask->task));

501,820✔

924

  TAOS_CHECK_EXIT(tEncodeSStreamStartTaskMsg(pEncoder, (SStreamStartTaskMsg*)&pTask->startMsg));

501,820✔

926

_exit:

501,820✔

928

  return code;

501,820✔

931

int32_t tEncodeSStreamUndeployTaskMsg(SEncoder* pEncoder, const SStreamUndeployTaskMsg* pUndeploy) {

482,214✔

932

  int32_t code = 0;

482,214✔

935

  TAOS_CHECK_EXIT(tEncodeSStreamMsg(pEncoder, &pUndeploy->header));

482,214✔

936

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pUndeploy->doCheckpoint));

964,428✔

937

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pUndeploy->doCleanup));

964,428✔

939

_exit:

482,214✔

941

  return code;

482,214✔

944

int32_t tEncodeSStreamTaskUndeploy(SEncoder* pEncoder, const SStreamTaskUndeploy* pTask) {

482,214✔

945

  int32_t code = 0;

482,214✔

948

  TAOS_CHECK_EXIT(tEncodeStreamTask(pEncoder, (SStreamTask*)&pTask->task));

482,214✔

949

  TAOS_CHECK_EXIT(tEncodeSStreamUndeployTaskMsg(pEncoder, (SStreamUndeployTaskMsg*)&pTask->undeployMsg));

482,214✔

951

_exit:

482,214✔

953

  return code;

482,214✔

957

int32_t tEncodeSStreamRecalcReq(SEncoder* pEncoder, const SStreamRecalcReq* recalc) {

6,656✔

958

  int32_t code = 0;

6,656✔

961

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, recalc->recalcId));

13,312✔

962

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, recalc->start));

13,312✔

963

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, recalc->end));

13,312✔

965

_exit:

6,656✔

967

  return code;

6,656✔

970

int32_t tEncodeSStreamMgmtRspCont(SEncoder* pEncoder, SStreamMsgType msgType, const SStreamMgmtRspCont* pRsp) {

138,020✔

971

  int32_t code = 0;

138,020✔

974

  switch (msgType) {

138,020✔

975

    case STREAM_MSG_ORIGTBL_READER_INFO: {

126,634✔

976

      int32_t vgNum = taosArrayGetSize(pRsp->vgIds);

126,634✔

977

      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, vgNum));

126,634✔

979

      for (int32_t i = 0; i < vgNum; ++i) {

499,626✔

980

        int32_t* vgId = taosArrayGet(pRsp->vgIds, i);

372,992✔

981

        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, *vgId));

745,984✔

984

      int32_t readerNum = taosArrayGetSize(pRsp->readerList);

126,634✔

985

      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, readerNum));

126,634✔

987

      for (int32_t i = 0; i < readerNum; ++i) {

249,818✔

988

        SStreamTaskAddr* addr = taosArrayGet(pRsp->readerList, i);

123,184✔

989

        TAOS_CHECK_EXIT(tEncodeSStreamTaskAddr(pEncoder, addr));

123,184✔

991

      break;

126,634✔

1003

    case STREAM_MSG_USER_RECALC: {

6,656✔

1004

      int32_t recalcNum = taosArrayGetSize(pRsp->recalcList);

6,656✔

1005

      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, recalcNum));

6,656✔

1007

      for (int32_t i = 0; i < recalcNum; ++i) {

13,312✔

1008

        SStreamRecalcReq* recalc = taosArrayGet(pRsp->recalcList, i);

6,656✔

1009

        TAOS_CHECK_EXIT(tEncodeSStreamRecalcReq(pEncoder, recalc));

6,656✔

1011

      break;

6,656✔

1013

    case STREAM_MSG_RUNNER_ORIGTBL_READER: {

4,730✔

1014

      int32_t rspNum = taosArrayGetSize(pRsp->execRspList);

4,730✔

1015

      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, rspNum));

4,730✔

1017

      for (int32_t i = 0; i < rspNum; ++i) {

9,460✔

1018

        SStreamOReaderDeployRsp* pDeployRsp = taosArrayGet(pRsp->execRspList, i);

4,730✔

1019

        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pDeployRsp->execId));

9,460✔

1020

        int32_t vgNum = taosArrayGetSize(pDeployRsp->vgList);

4,730✔

1021

        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, vgNum));

4,730✔

1022

        for (int32_t n = 0; n < vgNum; ++n) {

9,460✔

1023

          TAOS_CHECK_EXIT(tEncodeSStreamTaskAddr(pEncoder, taosArrayGet(pDeployRsp->vgList, n)));

4,730✔

1026

      break;

4,730✔

1032

_exit:

138,020✔

1034

  return code;

138,020✔

1037

int32_t tEncodeSStreamMgmtRsp(SEncoder* pEncoder, const SStreamMgmtRsp* pRsp) {

138,020✔

1038

  int32_t code = 0;

138,020✔

1041

  TAOS_CHECK_EXIT(tEncodeSStreamMsg(pEncoder, &pRsp->header));

138,020✔

1042

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pRsp->reqId));

276,040✔

1043

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pRsp->code));

276,040✔

1044

  TAOS_CHECK_EXIT(tEncodeStreamTask(pEncoder, &pRsp->task));

138,020✔

1045

  TAOS_CHECK_EXIT(tEncodeSStreamMgmtRspCont(pEncoder, pRsp->header.msgType, (SStreamMgmtRspCont*)&pRsp->cont));

138,020✔

1047

_exit:

138,020✔

1049

  return code;

138,020✔

1053

int32_t tEncodeStreamHbRsp(SEncoder* pEncoder, const SMStreamHbRspMsg* pRsp) {

28,664,340✔

1054

  int32_t code = 0;

28,664,340✔

1057

  TAOS_CHECK_EXIT(tStartEncode(pEncoder));

28,664,340✔

1058

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pRsp->streamGId));

57,328,680✔

1059

  int32_t deployNum = taosArrayGetSize(pRsp->deploy.streamList);

28,664,340✔

1060

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, deployNum));

28,664,340✔

1061

  for (int32_t i = 0; i < deployNum; ++i) {

29,189,774✔

1062

    SStmStreamDeploy* pStream = (SStmStreamDeploy*)taosArrayGet(pRsp->deploy.streamList, i);

525,434✔

1063

    TAOS_CHECK_EXIT(tEncodeSStmStreamDeploy(pEncoder, pStream));

525,434✔

1066

  int32_t startNum = taosArrayGetSize(pRsp->start.taskList);

28,664,340✔

1067

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, startNum));

28,664,340✔

1068

  for (int32_t i = 0; i < startNum; ++i) {

29,166,160✔

1069

    SStreamTaskStart* pTask = (SStreamTaskStart*)taosArrayGet(pRsp->start.taskList, i);

501,820✔

1070

    TAOS_CHECK_EXIT(tEncodeSStreamTaskStart(pEncoder, pTask));

501,820✔

1073

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pRsp->undeploy.undeployAll));

57,328,680✔

1074

  if (!pRsp->undeploy.undeployAll) {

28,664,340✔

1075

    int32_t undeployNum = taosArrayGetSize(pRsp->undeploy.taskList);

28,664,340✔

1076

    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, undeployNum));

28,664,340✔

1077

    for (int32_t i = 0; i < undeployNum; ++i) {

29,146,554✔

1078

      SStreamTaskUndeploy* pTask = (SStreamTaskUndeploy*)taosArrayGet(pRsp->undeploy.taskList, i);

482,214✔

1079

      TAOS_CHECK_EXIT(tEncodeSStreamTaskUndeploy(pEncoder, pTask));

482,214✔

1083

  int32_t rspNum = taosArrayGetSize(pRsp->rsps.rspList);

28,664,340✔

1084

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, rspNum));

28,664,340✔

1085

  for (int32_t i = 0; i < rspNum; ++i) {

28,802,360✔

1086

    SStreamMgmtRsp* pMgmtRsp = (SStreamMgmtRsp*)taosArrayGet(pRsp->rsps.rspList, i);

138,020✔

1087

    TAOS_CHECK_EXIT(tEncodeSStreamMgmtRsp(pEncoder, pMgmtRsp));

138,020✔

1090

_exit:

28,664,340✔

1092

  tEndEncode(pEncoder);

28,664,340✔

1094

  return code;

28,664,340✔

1097

int32_t tDecodeSStreamReaderDeployFromTrigger(SDecoder* pDecoder, SStreamReaderDeployFromTrigger* pMsg) {

301,263✔

1098

  int32_t code = 0;

301,263✔

1101

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->triggerTblName, NULL));

602,526✔

1102

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->triggerTblUid));

602,526✔

1103

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->triggerTblSuid));

602,526✔

1104

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->triggerTblType));

602,526✔

1105

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->isTriggerTblVirt));

602,526✔

1106

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->deleteReCalc));

602,526✔

1107

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->deleteOutTbl));

602,526✔

1108

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->partitionCols, NULL));

602,526✔

1109

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->triggerCols, NULL));

602,526✔

1110

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->triggerScanPlan, NULL));

602,526✔

1111

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->calcCacheScanPlan, NULL));

602,526✔

1113

_exit:

301,263✔

1115

  return code;

301,263✔

1119

int32_t tDecodeSStreamReaderDeployFromCalc(SDecoder* pDecoder, SStreamReaderDeployFromCalc* pMsg) {

385,355✔

1120

  int32_t code = 0;

385,355✔

1123

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->execReplica));

770,710✔

1124

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->calcScanPlan, NULL));

770,710✔

1126

_exit:

385,355✔

1128

  return code;

385,355✔

1132

int32_t tDecodeSStreamReaderDeployMsg(SDecoder* pDecoder, SStreamReaderDeployMsg* pMsg) {

686,618✔

1133

  int32_t code = 0;

686,618✔

1136

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->triggerReader));

1,373,236✔

1137

  if (pMsg->triggerReader) {

686,618✔

1138

    TAOS_CHECK_EXIT(tDecodeSStreamReaderDeployFromTrigger(pDecoder, &pMsg->msg.trigger));

301,263✔

1140

    TAOS_CHECK_EXIT(tDecodeSStreamReaderDeployFromCalc(pDecoder, &pMsg->msg.calc));

385,355✔

1143

_exit:

385,355✔

1145

  return code;

686,618✔

1149

int32_t tDecodeSStreamTaskAddr(SDecoder* pDecoder, SStreamTaskAddr* pMsg) {

880,799✔

1150

  int32_t code = 0;

880,799✔

1153

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->taskId));

1,761,598✔

1154

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->nodeId));

1,761,598✔

1155

  TAOS_CHECK_EXIT(tDecodeSEpSet(pDecoder, &pMsg->epset));

880,799✔

1157

_exit:

880,799✔

1159

  return code;

880,799✔

1163

int32_t tDecodeSStreamRunnerTarget(SDecoder* pDecoder, SStreamRunnerTarget* pMsg) {

566,067✔

1164

  int32_t code = 0;

566,067✔

1167

  TAOS_CHECK_EXIT(tDecodeSStreamTaskAddr(pDecoder, &pMsg->addr));

566,067✔

1168

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->execReplica));

1,132,134✔

1170

_exit:

566,067✔

1172

  return code;

566,067✔

1176

int32_t tDecodeSStreamTriggerDeployMsg(SDecoder* pDecoder, SStreamTriggerDeployMsg* pMsg) {

191,993✔

1177

  int32_t code = 0;

191,993✔

1180

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->triggerType));

383,986✔

1181

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->igDisorder));

383,986✔

1182

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->fillHistory));

383,986✔

1183

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->fillHistoryFirst));

383,986✔

1184

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->lowLatencyCalc));

383,986✔

1185

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->igNoDataTrigger));

383,986✔

1186

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->isTriggerTblVirt));

383,986✔

1187

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->triggerHasPF));

383,986✔

1188

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->isTriggerTblStb));

383,986✔

1189

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->partitionCols, NULL));

383,986✔

1191

  int32_t addrSize = 0;

191,993✔

1192

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &addrSize));

191,993✔

1193

  if (addrSize > 0) {

191,993✔

1194

    pMsg->pNotifyAddrUrls = taosArrayInit_s(POINTER_BYTES, addrSize);

55,064✔

1195

    TSDB_CHECK_NULL(pMsg->pNotifyAddrUrls, code, lino, _exit, terrno);

55,064✔

1197

  for (int32_t i = 0; i < addrSize; ++i) {

247,057✔

1198

    const char **url = taosArrayGet(pMsg->pNotifyAddrUrls, i);

55,064✔

1199

    TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)url, NULL));

55,064✔

1201

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->notifyEventTypes));

383,986✔

1202

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->addOptions));

383,986✔

1203

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->notifyHistory));

383,986✔

1205

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->maxDelay));

383,986✔

1206

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->fillHistoryStartTime));

383,986✔

1207

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->watermark));

383,986✔

1208

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->expiredTime));

383,986✔

1210

  switch (pMsg->triggerType) {

191,993✔

1211

    case WINDOW_TYPE_SESSION:

8,351✔

1213

      TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pMsg->trigger.session.slotId));

16,702✔

1214

      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.session.sessionVal));

16,702✔

1215

      break;

8,351✔

1216

    case WINDOW_TYPE_STATE:

64,273✔

1218

      TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pMsg->trigger.stateWin.slotId));

128,546✔

1219

      TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pMsg->trigger.stateWin.extend));

128,546✔

1220

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->trigger.stateWin.trueForType));

128,546✔

1221

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->trigger.stateWin.trueForCount));

128,546✔

1222

      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.stateWin.trueForDuration));

128,546✔

1223

      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->trigger.stateWin.zeroth, NULL));

128,546✔

1224

      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->trigger.stateWin.expr, NULL));

128,546✔

1225

      break;

64,273✔

1227

    case WINDOW_TYPE_INTERVAL:

70,808✔

1229

      TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->trigger.sliding.intervalUnit));

141,616✔

1230

      TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->trigger.sliding.slidingUnit));

141,616✔

1231

      TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->trigger.sliding.offsetUnit));

141,616✔

1232

      TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->trigger.sliding.soffsetUnit));

141,616✔

1233

      TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->trigger.sliding.precision));

141,616✔

1234

      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.sliding.interval));

141,616✔

1235

      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.sliding.offset));

141,616✔

1236

      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.sliding.sliding));

141,616✔

1237

      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.sliding.soffset));

141,616✔

1238

      break;

70,808✔

1240

    case WINDOW_TYPE_EVENT:

23,730✔

1242

      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->trigger.event.startCond, NULL));

47,460✔

1243

      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->trigger.event.endCond, NULL));

47,460✔

1244

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->trigger.event.trueForType));

47,460✔

1245

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->trigger.event.trueForCount));

47,460✔

1246

      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.event.trueForDuration));

47,460✔

1247

      break;

23,730✔

1249

    case WINDOW_TYPE_COUNT:

17,539✔

1251

      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->trigger.count.condCols, NULL));

35,078✔

1253

      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.count.countVal));

35,078✔

1254

      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.count.sliding));

35,078✔

1255

      break;

17,539✔

1257

    case WINDOW_TYPE_PERIOD:

7,292✔

1259

      TAOS_CHECK_EXIT(tDecodeI8(pDecoder, (int8_t*)&pMsg->trigger.period.periodUnit));

14,584✔

1260

      TAOS_CHECK_EXIT(tDecodeI8(pDecoder, (int8_t*)&pMsg->trigger.period.offsetUnit));

14,584✔

1261

      TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->trigger.period.precision));

14,584✔

1262

      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.period.period));

14,584✔

1263

      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.period.offset));

14,584✔

1264

      break;

7,292✔

1270

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->eventTypes));

383,986✔

1271

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->placeHolderBitmap));

383,986✔

1272

  TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pMsg->calcTsSlotId));

383,986✔

1273

  TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pMsg->triTsSlotId));

383,986✔

1274

  TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pMsg->calcPkSlotId));

383,986✔

1275

  TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pMsg->triPkSlotId));

383,986✔

1276

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->triggerPrevFilter, NULL));

383,986✔

1277

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->triggerScanPlan, NULL));

383,986✔

1278

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->calcCacheScanPlan, NULL));

383,986✔

1280

  int32_t readerNum = 0;

191,993✔

1281

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &readerNum));

191,993✔

1282

  if (readerNum > 0) {

191,993✔

1283

    pMsg->readerList = taosArrayInit_s(sizeof(SStreamTaskAddr), readerNum);

191,000✔

1284

    TSDB_CHECK_NULL(pMsg->readerList, code, lino, _exit, terrno);

191,000✔

1286

  for (int32_t i = 0; i < readerNum; ++i) {

431,198✔

1287

    SStreamTaskAddr* pAddr = (SStreamTaskAddr*)taosArrayGet(pMsg->readerList, i);

239,205✔

1288

    TAOS_CHECK_EXIT(tDecodeSStreamTaskAddr(pDecoder, pAddr));

239,205✔

1291

  int32_t runnerNum = 0;

191,993✔

1292

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &runnerNum));

191,993✔

1293

  if (runnerNum > 0) {

191,993✔

1294

    pMsg->runnerList = taosArrayInit_s(sizeof(SStreamRunnerTarget), runnerNum);

188,689✔

1295

    TSDB_CHECK_NULL(pMsg->runnerList, code, lino, _exit, terrno);

188,689✔

1297

  for (int32_t i = 0; i < runnerNum; ++i) {

758,060✔

1298

    SStreamRunnerTarget* pTarget = (SStreamRunnerTarget*)taosArrayGet(pMsg->runnerList, i);

566,067✔

1299

    TAOS_CHECK_EXIT(tDecodeSStreamRunnerTarget(pDecoder, pTarget));

566,067✔

1302

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->leaderSnodeId));

383,986✔

1303

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->streamName, NULL));

383,986✔

1304

  if (!tDecodeIsEnd(pDecoder)) {

191,993✔

1305

    TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->precision));

383,986✔

1308

_exit:

191,993✔

1310

  return code;

191,993✔

1315

int32_t tDeserializeSFieldWithOptions(SDecoder *pDecoder, SFieldWithOptions *pField) {

3,316,043✔

1316

  int32_t code = 0;

3,316,043✔

1319

  TAOS_CHECK_EXIT(tDecodeCStrTo(pDecoder, pField->name));

3,316,043✔

1320

  TAOS_CHECK_EXIT(tDecodeU8(pDecoder, &pField->type));

6,632,086✔

1321

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pField->flags));

6,632,086✔

1322

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pField->bytes));

6,632,086✔

1323

  TAOS_CHECK_EXIT(tDecodeU32(pDecoder, &pField->compress));

6,632,086✔

1324

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pField->typeMod));

6,632,086✔

1326

_exit:

3,316,043✔

1328

  return code;

3,316,043✔

1331

void destroySStreamOutCols(void* p){

64,965✔

1332

  if (p == NULL) return;

64,965✔

1333

  SStreamOutCol* col = (SStreamOutCol*)p;

64,965✔

1334

  taosMemoryFreeClear(col->expr);

64,965✔

1337

int32_t tDecodeSStreamRunnerDeployMsg(SDecoder* pDecoder, SStreamRunnerDeployMsg* pMsg) {

671,839✔

1338

  int32_t code = 0;

671,839✔

1341

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->execReplica));

1,343,678✔

1342

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->streamName, NULL));

1,343,678✔

1343

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->pPlan, NULL));

1,343,678✔

1344

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->outDBFName, NULL));

1,343,678✔

1345

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->outTblName, NULL));

1,343,678✔

1346

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->outTblType));

1,343,678✔

1347

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->calcNotifyOnly));

1,343,678✔

1348

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->topPlan));

1,343,678✔

1350

  int32_t addrSize = 0;

671,839✔

1351

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &addrSize));

671,839✔

1352

  if (addrSize > 0) {

671,839✔

1353

    pMsg->pNotifyAddrUrls = taosArrayInit_s(POINTER_BYTES, addrSize);

155,280✔

1354

    TSDB_CHECK_NULL(pMsg->pNotifyAddrUrls, code, lino, _exit, terrno);

155,280✔

1356

  for (int32_t i = 0; i < addrSize; ++i) {

827,119✔

1357

    const char **url = taosArrayGet(pMsg->pNotifyAddrUrls, i);

155,280✔

1358

    TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)url, NULL));

155,280✔

1360

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->addOptions));

1,343,678✔

1362

  int32_t outColNum = 0;

671,839✔

1363

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &outColNum));

671,839✔

1364

  if (outColNum > 0) {

671,839✔

1365

    pMsg->outCols = taosArrayInit_s(sizeof(SFieldWithOptions), outColNum);

671,839✔

1366

    TSDB_CHECK_NULL(pMsg->outCols, code, lino, _exit, terrno);

671,839✔

1368

  for (int32_t i = 0; i < outColNum; ++i) {

3,435,273✔

1369

    SFieldWithOptions *pCol = taosArrayGet(pMsg->outCols, i);

2,763,434✔

1370

    TAOS_CHECK_EXIT(tDeserializeSFieldWithOptions(pDecoder, pCol));

2,763,434✔

1373

  int32_t outTagNum = 0;

671,839✔

1374

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &outTagNum));

671,839✔

1375

  if (outTagNum > 0) {

671,839✔

1376

    pMsg->outTags = taosArrayInit_s(sizeof(SFieldWithOptions), outTagNum);

282,168✔

1377

    TSDB_CHECK_NULL(pMsg->outTags, code, lino, _exit, terrno);

282,168✔

1379

  for (int32_t i = 0; i < outTagNum; ++i) {

1,224,448✔

1380

    SFieldWithOptions *pTag = taosArrayGet(pMsg->outTags, i);

552,609✔

1381

    TAOS_CHECK_EXIT(tDeserializeSFieldWithOptions(pDecoder, pTag));

552,609✔

1384

  TAOS_CHECK_EXIT(tDecodeU64(pDecoder, &pMsg->outStbUid));

1,343,678✔

1385

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->outStbSversion));

1,343,678✔

1387

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->subTblNameExpr, NULL));

1,343,678✔

1388

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->tagValueExpr, NULL));

1,343,678✔

1390

  int32_t forceOutColsSize = 0;

671,839✔

1391

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &forceOutColsSize));

671,839✔

1392

  if (forceOutColsSize > 0) {

671,839✔

1393

    pMsg->forceOutCols = taosArrayInit_s(sizeof(SStreamOutCol), forceOutColsSize);

11,817✔

1394

    TSDB_CHECK_NULL(pMsg->forceOutCols, code, lino, _exit, terrno);

11,817✔

1396

  for (int32_t i = 0; i < forceOutColsSize; ++i) {

736,804✔

1397

    SStreamOutCol *pCoutCol = (SStreamOutCol*)taosArrayGet(pMsg->forceOutCols, i);

64,965✔

1399

    TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pCoutCol->expr, NULL));

129,930✔

1400

    TAOS_CHECK_EXIT(tDecodeU8(pDecoder, &pCoutCol->type.type));

129,930✔

1401

    TAOS_CHECK_EXIT(tDecodeU8(pDecoder, &pCoutCol->type.precision));

129,930✔

1402

    TAOS_CHECK_EXIT(tDecodeU8(pDecoder, &pCoutCol->type.scale));

129,930✔

1403

    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pCoutCol->type.bytes));

129,930✔

1406

  if (!tDecodeIsEnd(pDecoder)) {

671,839✔

1407

    TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->lowLatencyCalc));

1,343,678✔

1412

  if (!tDecodeIsEnd(pDecoder)) {

671,839✔

1413

    int32_t colCidsSize = 0;

671,839✔

1414

    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &colCidsSize));

671,839✔

1415

    if (colCidsSize > 0 && colCidsSize <= TSDB_MAX_COLUMNS) {  // Sanity check

671,839✔

1416

      pMsg->colCids = taosArrayInit(colCidsSize, sizeof(int16_t));

11,226✔

1417

      TSDB_CHECK_NULL(pMsg->colCids, code, lino, _exit, terrno);

11,226✔

1418

      for (int32_t i = 0; i < colCidsSize; ++i) {

43,449✔

1419

        int16_t cid = 0;

32,223✔

1420

        TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &cid));

32,223✔

1421

        if (taosArrayPush(pMsg->colCids, &cid) == NULL) {

64,446✔

1428

  if (!tDecodeIsEnd(pDecoder)) {

671,839✔

1429

    int32_t tagCidsSize = 0;

671,839✔

1430

    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &tagCidsSize));

671,839✔

1431

    if (tagCidsSize > 0 && tagCidsSize <= TSDB_MAX_TAGS) {  // Sanity check

671,839✔

1432

      pMsg->tagCids = taosArrayInit(tagCidsSize, sizeof(int16_t));

9,303✔

1433

      TSDB_CHECK_NULL(pMsg->tagCids, code, lino, _exit, terrno);

9,303✔

1434

      for (int32_t i = 0; i < tagCidsSize; ++i) {

22,767✔

1435

        int16_t cid = 0;

13,464✔

1436

        TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &cid));

13,464✔

1437

        if (taosArrayPush(pMsg->tagCids, &cid) == NULL) {

26,928✔

1444

_exit:

670,471✔

1446

  return code;

671,839✔

1449

int32_t tDecodeSStmTaskDeploy(SDecoder* pDecoder, SStmTaskDeploy* pTask) {

1,550,450✔

1450

  int32_t code = 0;

1,550,450✔

1453

  TAOS_CHECK_EXIT(tDecodeStreamTask(pDecoder, (SStreamTask*)&pTask->task));

1,550,450✔

1454

  switch (pTask->task.type) {

1,550,450✔

1455

    case STREAM_READER_TASK:

686,618✔

1456

      TAOS_CHECK_EXIT(tDecodeSStreamReaderDeployMsg(pDecoder, &pTask->msg.reader));

686,618✔

1457

      break;

686,618✔

1458

    case STREAM_TRIGGER_TASK:

191,993✔

1459

      TAOS_CHECK_EXIT(tDecodeSStreamTriggerDeployMsg(pDecoder, &pTask->msg.trigger));

191,993✔

1460

      break;

191,993✔

1461

    case STREAM_RUNNER_TASK:

671,839✔

1462

      TAOS_CHECK_EXIT(tDecodeSStreamRunnerDeployMsg(pDecoder, &pTask->msg.runner));

671,839✔

1463

      break;

671,839✔

1469

_exit:

1,550,450✔

1471

  return code;

1,550,450✔

1475

int32_t tDecodeSStmStreamDeploy(SDecoder* pDecoder, SStmStreamDeploy* pStream) {

262,485✔

1476

  int32_t code = 0;

262,485✔

1479

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pStream->streamId));

524,970✔

1481

  int32_t readerNum = 0;

262,485✔

1482

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &readerNum));

262,485✔

1483

  if (readerNum > 0) {

262,485✔

1484

    pStream->readerTasks = taosArrayInit_s(sizeof(SStmTaskDeploy), readerNum);

250,643✔

1485

    TSDB_CHECK_NULL(pStream->readerTasks, code, lino, _exit, terrno);

250,643✔

1487

  for (int32_t i = 0; i < readerNum; ++i) {

949,103✔

1488

    SStmTaskDeploy* pTask = taosArrayGet(pStream->readerTasks, i);

686,618✔

1489

    TAOS_CHECK_EXIT(tDecodeSStmTaskDeploy(pDecoder, pTask));

686,618✔

1492

  int32_t triggerTask = 0;

262,485✔

1493

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &triggerTask));

262,485✔

1494

  if (triggerTask) {

262,485✔

1495

    pStream->triggerTask = taosMemoryCalloc(1, sizeof(SStmTaskDeploy));

191,993✔

1496

    TSDB_CHECK_NULL(pStream->triggerTask, code, lino, _exit, terrno);

191,993✔

1497

    TAOS_CHECK_EXIT(tDecodeSStmTaskDeploy(pDecoder, pStream->triggerTask));

191,993✔

1500

  int32_t runnerNum = 0;

262,485✔

1501

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &runnerNum));

262,485✔

1502

  if (runnerNum > 0) {

262,485✔

1503

    pStream->runnerTasks = taosArrayInit_s(sizeof(SStmTaskDeploy), runnerNum);

197,171✔

1504

    TSDB_CHECK_NULL(pStream->runnerTasks, code, lino, _exit, terrno);

197,171✔

1506

  for (int32_t i = 0; i < runnerNum; ++i) {

934,324✔

1507

    SStmTaskDeploy* pTask = taosArrayGet(pStream->runnerTasks, i);

671,839✔

1508

    TAOS_CHECK_EXIT(tDecodeSStmTaskDeploy(pDecoder, pTask));

671,839✔

1511

_exit:

262,485✔

1513

  return code;

262,485✔

1517

int32_t tDecodeSStreamStartTaskMsg(SDecoder* pDecoder, SStreamStartTaskMsg* pStart) {

250,929✔

1518

  int32_t code = 0;

250,929✔

1521

  TAOS_CHECK_EXIT(tDecodeSStreamMsg(pDecoder, &pStart->header));

250,929✔

1523

_exit:

250,929✔

1525

  return code;

250,929✔

1529

int32_t tDecodeSStreamTaskStart(SDecoder* pDecoder, SStreamTaskStart* pTask) {

250,929✔

1530

  int32_t code = 0;

250,929✔

1533

  TAOS_CHECK_EXIT(tDecodeStreamTask(pDecoder, (SStreamTask*)&pTask->task));

250,929✔

1534

  TAOS_CHECK_EXIT(tDecodeSStreamStartTaskMsg(pDecoder, (SStreamStartTaskMsg*)&pTask->startMsg));

250,929✔

1536

_exit:

250,929✔

1538

  return code;

250,929✔

1542

int32_t tDecodeSStreamUndeployTaskMsg(SDecoder* pDecoder, SStreamUndeployTaskMsg* pUndeploy) {

241,087✔

1543

  int32_t code = 0;

241,087✔

1546

  TAOS_CHECK_EXIT(tDecodeSStreamMsg(pDecoder, &pUndeploy->header));

241,087✔

1547

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pUndeploy->doCheckpoint));

482,174✔

1548

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pUndeploy->doCleanup));

482,174✔

1550

_exit:

241,087✔

1552

  return code;

241,087✔

1556

int32_t tDecodeSStreamTaskUndeploy(SDecoder* pDecoder, SStreamTaskUndeploy* pTask) {

241,087✔

1557

  int32_t code = 0;

241,087✔

1560

  TAOS_CHECK_EXIT(tDecodeStreamTask(pDecoder, (SStreamTask*)&pTask->task));

241,087✔

1561

  TAOS_CHECK_EXIT(tDecodeSStreamUndeployTaskMsg(pDecoder, (SStreamUndeployTaskMsg*)&pTask->undeployMsg));

241,087✔

1563

_exit:

241,087✔

1565

  return code;

241,087✔

1568

int32_t tDecodeSStreamRecalcReq(SDecoder* pDecoder, SStreamRecalcReq* recalc) {

3,328✔

1569

  int32_t code = 0;

3,328✔

1572

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &recalc->recalcId));

6,656✔

1573

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &recalc->start));

6,656✔

1574

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &recalc->end));

6,656✔

1576

_exit:

3,328✔

1578

  return code;

3,328✔

1581

int32_t tDecodeSStreamMgmtRspCont(SDecoder* pDecoder, SStreamMsgType msgType, SStreamMgmtRspCont* pCont) {

69,010✔

1582

  int32_t code = 0;

69,010✔

1585

  switch (msgType) {

69,010✔

1586

    case STREAM_MSG_ORIGTBL_READER_INFO: {

63,317✔

1587

      int32_t vgNum = 0;

63,317✔

1588

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgNum));

63,317✔

1589

      if (vgNum > 0) {

63,317✔

1590

        pCont->vgIds = taosArrayInit_s(sizeof(int32_t), vgNum);

63,317✔

1591

        TSDB_CHECK_NULL(pCont->vgIds, code, lino, _exit, terrno);

63,317✔

1593

      for (int32_t i = 0; i < vgNum; ++i) {

249,813✔

1594

        int32_t *vgId = taosArrayGet(pCont->vgIds, i);

186,496✔

1595

        TAOS_CHECK_EXIT(tDecodeI32(pDecoder, vgId));

186,496✔

1598

      int32_t readerNum = 0;

63,317✔

1599

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &readerNum));

63,317✔

1600

      if (readerNum > 0) {

63,317✔

1601

        pCont->readerList = taosArrayInit_s(sizeof(SStreamTaskAddr), readerNum);

53,450✔

1602

        TSDB_CHECK_NULL(pCont->readerList, code, lino, _exit, terrno);

53,450✔

1604

      for (int32_t i = 0; i < readerNum; ++i) {

124,909✔

1605

        SStreamTaskAddr *addr = taosArrayGet(pCont->readerList, i);

61,592✔

1606

        TAOS_CHECK_EXIT(tDecodeSStreamTaskAddr(pDecoder, addr));

61,592✔

1608

      break;

63,317✔

1623

    case STREAM_MSG_USER_RECALC: {

3,328✔

1624

      int32_t recalcNum = 0;

3,328✔

1625

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &recalcNum));

3,328✔

1626

      if (recalcNum > 0) {

3,328✔

1627

        pCont->recalcList = taosArrayInit_s(sizeof(SStreamRecalcReq), recalcNum);

3,328✔

1628

        TSDB_CHECK_NULL(pCont->recalcList, code, lino, _exit, terrno);

3,328✔

1630

      for (int32_t i = 0; i < recalcNum; ++i) {

6,656✔

1631

        SStreamRecalcReq *recalc = taosArrayGet(pCont->recalcList, i);

3,328✔

1632

        TAOS_CHECK_EXIT(tDecodeSStreamRecalcReq(pDecoder, recalc));

3,328✔

1634

      break;

3,328✔

1636

    case STREAM_MSG_RUNNER_ORIGTBL_READER: {

2,365✔

1637

      int32_t rspNum = 0, vgNum = 0;

2,365✔

1638

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &rspNum));

2,365✔

1639

      if (rspNum > 0) {

2,365✔

1640

        pCont->execRspList = taosArrayInit_s(sizeof(SStreamOReaderDeployRsp), rspNum);

2,365✔

1641

        TSDB_CHECK_NULL(pCont->execRspList, code, lino, _exit, terrno);

2,365✔

1643

      for (int32_t i = 0; i < rspNum; ++i) {

4,730✔

1644

        SStreamOReaderDeployRsp *pDeployRsp = taosArrayGet(pCont->execRspList, i);

2,365✔

1645

        TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pDeployRsp->execId));

4,730✔

1646

        TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgNum));

2,365✔

1647

        if (vgNum > 0) {

2,365✔

1648

          pDeployRsp->vgList = taosArrayInit_s(sizeof(SStreamTaskAddr), vgNum);

2,365✔

1649

          TSDB_CHECK_NULL(pDeployRsp->vgList, code, lino, _exit, terrno);

2,365✔

1651

        for (int32_t n = 0; n < vgNum; ++n) {

4,730✔

1652

          SStreamTaskAddr* pAddr = taosArrayGet(pDeployRsp->vgList, n);

2,365✔

1653

          TAOS_CHECK_EXIT(tDecodeSStreamTaskAddr(pDecoder, pAddr));

2,365✔

1656

      break;

2,365✔

1662

_exit:

69,010✔

1664

  return code;

69,010✔

1668

int32_t tDecodeSStreamMgmtRsp(SDecoder* pDecoder, SStreamMgmtRsp* pRsp) {

69,010✔

1669

  int32_t code = 0;

69,010✔

1672

  TAOS_CHECK_EXIT(tDecodeSStreamMsg(pDecoder, &pRsp->header));

69,010✔

1673

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pRsp->reqId));

138,020✔

1674

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pRsp->code));

138,020✔

1675

  TAOS_CHECK_EXIT(tDecodeStreamTask(pDecoder, &pRsp->task));

69,010✔

1676

  TAOS_CHECK_EXIT(tDecodeSStreamMgmtRspCont(pDecoder, pRsp->header.msgType, &pRsp->cont));

69,010✔

1678

_exit:

69,010✔

1680

  return code;

69,010✔

1683

void tFreeSStreamOReaderDeployRsp(void* param) {

4,730✔

1684

  if (NULL == param) {

4,730✔

1688

  SStreamOReaderDeployRsp* pRsp = (SStreamOReaderDeployRsp*)param;

4,730✔

1689

  taosArrayDestroy(pRsp->vgList);

4,730✔

1692

void tFreeSStreamMgmtRsp(void* param) {

138,020✔

1693

  if (NULL == param) {

138,020✔

1697

  SStreamMgmtRsp* pRsp = (SStreamMgmtRsp*)param;

138,020✔

1699

  taosArrayDestroy(pRsp->cont.vgIds);

138,020✔

1700

  taosArrayDestroy(pRsp->cont.readerList);

138,020✔

1701

  taosArrayDestroy(pRsp->cont.runnerList);

138,020✔

1702

  taosArrayDestroy(pRsp->cont.recalcList);

138,020✔

1703

  taosArrayDestroyEx(pRsp->cont.execRspList, tFreeSStreamOReaderDeployRsp);

138,020✔

1706

void tFreeSStreamReaderDeployMsg(SStreamReaderDeployMsg* pReader) {

686,618✔

1707

  if (NULL == pReader) {

686,618✔

1711

  if (pReader->triggerReader) {

686,618✔

1712

    SStreamReaderDeployFromTrigger* pMsg = (SStreamReaderDeployFromTrigger*)&pReader->msg.trigger;

301,263✔

1713

    taosMemoryFree(pMsg->triggerTblName);

301,263✔

1714

    taosMemoryFree(pMsg->partitionCols);

301,263✔

1715

    taosMemoryFree(pMsg->triggerCols);

301,263✔

1716

    taosMemoryFree(pMsg->triggerScanPlan);

301,263✔

1717

    taosMemoryFree(pMsg->calcCacheScanPlan);

301,263✔

1719

    SStreamReaderDeployFromCalc* pMsg = (SStreamReaderDeployFromCalc*)&pReader->msg.calc;

385,355✔

1720

    taosMemoryFree(pMsg->calcScanPlan);

385,355✔

1732

void tFreeSStreamTriggerDeployMsg(SStreamTriggerDeployMsg* pTrigger) {

191,993✔

1733

  if (NULL == pTrigger) {

191,993✔

1737

  taosArrayDestroyEx(pTrigger->pNotifyAddrUrls, tFreeStreamNotifyUrl);

191,993✔

1738

  switch (pTrigger->triggerType) {

191,993✔

1739

    case WINDOW_TYPE_STATE:

64,273✔

1740

      taosMemoryFree(pTrigger->trigger.stateWin.zeroth);

64,273✔

1741

      taosMemoryFree(pTrigger->trigger.stateWin.expr);

64,273✔

1742

      break;

64,273✔

1743

    case WINDOW_TYPE_EVENT:

23,730✔

1744

      taosMemoryFree(pTrigger->trigger.event.startCond);

23,730✔

1745

      taosMemoryFree(pTrigger->trigger.event.endCond);

23,730✔

1746

      break;

23,730✔

1747

    case WINDOW_TYPE_COUNT:

17,539✔

1748

      taosMemoryFree(pTrigger->trigger.count.condCols);

17,539✔

1749

      break;

17,539✔

1750

    default:

86,451✔

1751

      break;

86,451✔

1754

  taosMemoryFree(pTrigger->partitionCols);

191,993✔

1755

  taosMemoryFree(pTrigger->triggerPrevFilter);

191,993✔

1756

  taosMemoryFree(pTrigger->triggerScanPlan);

191,993✔

1757

  taosMemoryFree(pTrigger->calcCacheScanPlan);

191,993✔

1759

  taosArrayDestroy(pTrigger->readerList);

191,993✔

1760

  taosArrayDestroy(pTrigger->runnerList);

191,993✔

1761

  taosMemoryFree(pTrigger->streamName);

191,993✔

1773

void tFreeSStreamRunnerDeployMsg(SStreamRunnerDeployMsg* pRunner) {

671,839✔

1774

  if (NULL == pRunner) {

671,839✔

1778

  taosMemoryFree(pRunner->streamName);

671,839✔

1779

  taosMemoryFree(pRunner->pPlan);

671,839✔

1780

  taosMemoryFree(pRunner->outDBFName);

671,839✔

1781

  taosMemoryFree(pRunner->outTblName);

671,839✔

1783

  taosArrayDestroyEx(pRunner->pNotifyAddrUrls, tFreeStreamNotifyUrl);

671,839✔

1784

  taosArrayDestroy(pRunner->outCols);

671,839✔

1785

  taosArrayDestroy(pRunner->outTags);

671,839✔

1787

  taosMemoryFree(pRunner->subTblNameExpr);

671,839✔

1788

  taosMemoryFree(pRunner->tagValueExpr);

671,839✔

1789

  taosArrayDestroyEx(pRunner->forceOutCols, tFreeSStreamOutCol);

671,839✔

1792

void tFreeSStmTaskDeploy(void* param) {

1,883,659✔

1793

  if (NULL == param) {

1,883,659✔

1794

    return;

333,209✔

1797

  SStmTaskDeploy* pTask = (SStmTaskDeploy*)param;

1,550,450✔

1798

  switch (pTask->task.type)  {

1,550,450✔

1799

    case STREAM_READER_TASK:

686,618✔

1800

      tFreeSStreamReaderDeployMsg(&pTask->msg.reader);

686,618✔

1801

      break;

686,618✔

1802

    case STREAM_TRIGGER_TASK:

191,993✔

1803

      tFreeSStreamTriggerDeployMsg(&pTask->msg.trigger);

191,993✔

1804

      break;

191,993✔

1805

    case STREAM_RUNNER_TASK:

671,839✔

1806

      tFreeSStreamRunnerDeployMsg(&pTask->msg.runner);

671,839✔

1807

      break;

671,839✔

1814

void tFreeSStmStreamDeploy(void* param) {

262,717✔

1815

  if (NULL == param) {

262,717✔

1819

  SStmStreamDeploy* pDeploy = (SStmStreamDeploy*)param;

262,717✔

1820

  int32_t readerNum = taosArrayGetSize(pDeploy->readerTasks);

262,717✔

1821

  for (int32_t i = 0; i < readerNum; ++i) {

949,656✔

1822

    SStmTaskDeploy* pReader = taosArrayGet(pDeploy->readerTasks, i);

686,939✔

1823

    if (!pReader->msg.reader.triggerReader && pReader->msg.reader.msg.calc.freeScanPlan) {

686,939✔

1824

      taosMemoryFreeClear(pReader->msg.reader.msg.calc.calcScanPlan);

382,474✔

1827

  taosArrayDestroy(pDeploy->readerTasks);

262,717✔

1829

  if (pDeploy->triggerTask) {

262,717✔

1830

    taosArrayDestroy(pDeploy->triggerTask->msg.trigger.readerList);

192,229✔

1831

    taosArrayDestroy(pDeploy->triggerTask->msg.trigger.runnerList);

192,229✔

1832

    taosMemoryFree(pDeploy->triggerTask);

192,229✔

1835

  int32_t runnerNum = taosArrayGetSize(pDeploy->runnerTasks);

262,717✔

1836

  for (int32_t i = 0; i < runnerNum; ++i) {

935,215✔

1837

    SStmTaskDeploy* pRunner = taosArrayGet(pDeploy->runnerTasks, i);

672,498✔

1838

    taosMemoryFree(pRunner->msg.runner.pPlan);

672,498✔

1840

  taosArrayDestroy(pDeploy->runnerTasks);

262,717✔

1843

void tDeepFreeSStmStreamDeploy(void* param) {

525,202✔

1844

  if (NULL == param) {

525,202✔

1848

  SStmStreamDeploy* pDeploy = (SStmStreamDeploy*)param;

525,202✔

1849

  taosArrayDestroyEx(pDeploy->readerTasks, tFreeSStmTaskDeploy);

525,202✔

1850

  tFreeSStmTaskDeploy(pDeploy->triggerTask);

525,202✔

1851

  taosMemoryFree(pDeploy->triggerTask);

525,202✔

1852

  taosArrayDestroyEx(pDeploy->runnerTasks, tFreeSStmTaskDeploy);

525,202✔

1856

void tFreeSMStreamHbRspMsg(SMStreamHbRspMsg* pRsp) {

28,949,092✔

1857

  if (NULL == pRsp) {

28,949,092✔

1860

  taosArrayDestroyEx(pRsp->deploy.streamList, tFreeSStmStreamDeploy);

28,949,092✔

1861

  taosArrayDestroy(pRsp->start.taskList);

28,949,092✔

1862

  taosArrayDestroy(pRsp->undeploy.taskList);

28,949,092✔

1863

  taosArrayDestroyEx(pRsp->rsps.rspList, tFreeSStreamMgmtRsp);

28,949,092✔

1866

void tDeepFreeSMStreamHbRspMsg(SMStreamHbRspMsg* pRsp) {

14,269,345✔

1867

  if (NULL == pRsp) {

14,269,345✔

1870

  taosArrayDestroyEx(pRsp->deploy.streamList, tDeepFreeSStmStreamDeploy);

14,269,345✔

1871

  taosArrayDestroy(pRsp->start.taskList);

14,269,345✔

1872

  taosArrayDestroy(pRsp->undeploy.taskList);

14,269,345✔

1873

  taosArrayDestroyEx(pRsp->rsps.rspList, tFreeSStreamMgmtRsp);

14,269,345✔

1878

int32_t tDecodeStreamHbRsp(SDecoder* pDecoder, SMStreamHbRspMsg* pRsp) {

14,269,345✔

1879

  int32_t code = 0;

14,269,345✔

1882

  TAOS_CHECK_EXIT(tStartDecode(pDecoder));

14,269,345✔

1883

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pRsp->streamGId));

28,538,690✔

1884

  int32_t deployNum = 0;

14,269,345✔

1885

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &deployNum));

14,269,345✔

1886

  if (deployNum > 0) {

14,269,345✔

1887

    pRsp->deploy.streamList = taosArrayInit_s(sizeof(SStmStreamDeploy), deployNum);

67,539✔

1888

    TSDB_CHECK_NULL(pRsp->deploy.streamList, code, lino, _exit, terrno);

67,539✔

1890

  for (int32_t i = 0; i < deployNum; ++i) {

14,531,830✔

1891

    SStmStreamDeploy* pStream = taosArrayGet(pRsp->deploy.streamList, i);

262,485✔

1892

    TAOS_CHECK_EXIT(tDecodeSStmStreamDeploy(pDecoder, pStream));

262,485✔

1895

  int32_t startNum = 0;

14,269,345✔

1896

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &startNum));

14,269,345✔

1897

  if (startNum > 0) {

14,269,345✔

1898

    pRsp->start.taskList = taosArrayInit_s(sizeof(SStreamTaskStart), startNum);

102,579✔

1899

    TSDB_CHECK_NULL(pRsp->start.taskList, code, lino, _exit, terrno);

102,579✔

1901

  for (int32_t i = 0; i < startNum; ++i) {

14,520,274✔

1902

    SStreamTaskStart* pTask = (SStreamTaskStart*)taosArrayGet(pRsp->start.taskList, i);

250,929✔

1903

    TAOS_CHECK_EXIT(tDecodeSStreamTaskStart(pDecoder, pTask));

250,929✔

1906

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pRsp->undeploy.undeployAll));

28,538,690✔

1907

  if (!pRsp->undeploy.undeployAll) {

14,269,345✔

1908

    int32_t undeployNum = 0;

14,269,345✔

1909

    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &undeployNum));

14,269,345✔

1910

    if (undeployNum > 0) {

14,269,345✔

1911

      pRsp->undeploy.taskList = taosArrayInit_s(sizeof(SStreamTaskUndeploy), undeployNum);

31,021✔

1912

      TSDB_CHECK_NULL(pRsp->undeploy.taskList, code, lino, _exit, terrno);

31,021✔

1914

    for (int32_t i = 0; i < undeployNum; ++i) {

14,510,432✔

1915

      SStreamTaskUndeploy* pTask = (SStreamTaskUndeploy*)taosArrayGet(pRsp->undeploy.taskList, i);

241,087✔

1916

      TAOS_CHECK_EXIT(tDecodeSStreamTaskUndeploy(pDecoder, pTask));

241,087✔

1920

  int32_t rspNum = 0;

14,269,345✔

1921

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &rspNum));

14,269,345✔

1922

  if (rspNum > 0) {

14,269,345✔

1923

    pRsp->rsps.rspList = taosArrayInit_s(sizeof(SStreamMgmtRsp), rspNum);

22,676✔

1924

    TSDB_CHECK_NULL(pRsp->rsps.rspList, code, lino, _exit, terrno);

22,676✔

1925

    for (int32_t i = 0; i < rspNum; ++i) {

91,686✔

1926

      SStreamMgmtRsp* pMgmtRsp = (SStreamMgmtRsp*)taosArrayGet(pRsp->rsps.rspList, i);

69,010✔

1927

      TAOS_CHECK_EXIT(tDecodeSStreamMgmtRsp(pDecoder, pMgmtRsp));

69,010✔

1931

  tEndDecode(pDecoder);

14,269,345✔

1933

_exit:

14,269,345✔

1934

  return code;

14,269,345✔

1991

int32_t tSerializeSCMCreateStreamReqImpl(SEncoder* pEncoder, const SCMCreateStreamReq *pReq) {

1,456,604✔

1992

  int32_t code = TSDB_CODE_SUCCESS;

1,456,604✔

1993

  int32_t lino = 0;

1,456,604✔

1995

  char*   json = NULL;

1,456,604✔

1996

  int32_t jsonLen = 0;

1,456,604✔

1997

  TAOS_CHECK_EXIT(scmCreateStreamReqToJson(pReq, false, &json, &jsonLen));

1,456,604✔

1998

  TAOS_CHECK_EXIT(tEncodeCStrWithLen(pEncoder, json, jsonLen));

2,913,208✔

2000

_exit:

1,456,604✔

2001

  taosMemoryFreeClear(json);

1,456,604✔

2002

  if (code) {

1,456,604✔

2006

  return 0;

1,456,604✔

2009

int32_t tSerializeSCMCreateStreamReq(void *buf, int32_t bufLen, const SCMCreateStreamReq *pReq) {

679,068✔

2010

  SEncoder encoder = {0};

679,068✔

2011

  tEncoderInit(&encoder, buf, bufLen);

679,068✔

2012

  int32_t code = 0;

679,068✔

2015

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

679,068✔

2017

  TAOS_CHECK_EXIT(tSerializeSCMCreateStreamReqImpl(&encoder, pReq));

679,068✔

2019

  tEndEncode(&encoder);

679,068✔

2021

_exit:

679,068✔

2022

  if (code) {

679,068✔

2026

    int32_t tlen = encoder.pos;

679,068✔

2027

    tEncoderClear(&encoder);

679,068✔

2028

    return tlen;

679,068✔

2326

int32_t tDeserializeSCMCreateStreamReqImpl(SDecoder *pDecoder, SCMCreateStreamReq *pReq) {

452,297✔

2327

  int32_t code = 0;

452,297✔

2330

  char* json = NULL;

452,297✔

2331

  SJson* pJson = NULL;

452,297✔

2332

  TAOS_CHECK_EXIT(tDecodeCStrAlloc(pDecoder, &json));

452,297✔

2333

  pJson = tjsonParse(json);

452,297✔

2334

  if (pJson == NULL) {

452,297✔

2337

  TAOS_CHECK_EXIT(jsonToSCMCreateStreamReq(pJson, pReq));

452,297✔

2339

_exit:

452,297✔

2340

  taosMemoryFreeClear(json);

452,297✔

2341

  if (NULL != pJson) {

452,297✔

2342

    tjsonDelete(pJson);

452,297✔

2345

  return code;

452,297✔

2349

int32_t tDeserializeSCMCreateStreamReq(void *buf, int32_t bufLen, SCMCreateStreamReq *pReq) {

222,400✔

2350

  SDecoder decoder = {0};

222,400✔

2351

  tDecoderInit(&decoder, buf, bufLen);

222,400✔

2352

  int32_t code = 0;

222,400✔

2355

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

222,400✔

2357

  code = tDeserializeSCMCreateStreamReqImpl(&decoder, pReq);

222,400✔

2358

  if (TSDB_CODE_MND_STREAM_INVALID_JSON == code) {

222,400✔

2367

  tEndDecode(&decoder);

222,400✔

2369

_exit:

222,400✔

2371

  tDecoderClear(&decoder);

222,400✔

2372

  return code;

222,400✔

2376

int32_t tSerializeSMDropStreamReq(void *buf, int32_t bufLen, const SMDropStreamReq *pReq) {

48,378✔

2377

  int32_t  code = 0;

48,378✔

2380

  SEncoder encoder = {0};

48,378✔

2381

  tEncoderInit(&encoder, buf, bufLen);

48,378✔

2383

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

48,378✔

2385

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->count));

96,756✔

2386

  for (int32_t i = 0; i < pReq->count; i++) {

102,828✔

2387

    int32_t nameLen = pReq->name[i] == NULL ? 0 : (int32_t)strlen(pReq->name[i]) + 1;

54,450✔

2388

    TAOS_CHECK_EXIT(tEncodeBinary(&encoder, pReq->name[i], nameLen));

108,900✔

2390

  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->igNotExists));

96,756✔

2392

  tEndEncode(&encoder);

48,378✔

2394

_exit:

48,378✔

2395

  if (code) {

48,378✔

2398

    tlen = encoder.pos;

48,378✔

2400

  tEncoderClear(&encoder);

48,378✔

2401

  return tlen;

48,378✔

2404

int32_t tDeserializeSMDropStreamReq(void *buf, int32_t bufLen, SMDropStreamReq *pReq) {

18,706✔

2405

  SDecoder decoder = {0};

18,706✔

2406

  int32_t  code = 0;

18,706✔

2408

  tDecoderInit(&decoder, buf, bufLen);

18,706✔

2410

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

18,706✔

2411

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->count));

37,412✔

2412

  if (pReq->count > 0) {

18,706✔

2413

    pReq->name = taosMemoryCalloc(pReq->count, sizeof(char*));

18,706✔

2414

    if (pReq->name == NULL) {

18,706✔

2418

    for (int32_t i = 0; i < pReq->count; i++) {

40,448✔

2419

      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void**)&pReq->name[i], NULL));

43,484✔

2422

  TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->igNotExists));

37,412✔

2424

  tEndDecode(&decoder);

18,706✔

2426

_exit:

18,706✔

2427

  tDecoderClear(&decoder);

18,706✔

2428

  return code;

18,706✔

2431

void tFreeMDropStreamReq(SMDropStreamReq *pReq) {

42,895✔

2432

  if (NULL == pReq) {

42,895✔

2435

  if (pReq->name) {

42,895✔

2436

    for (int32_t i = 0; i < pReq->count; i++) {

91,862✔

2437

      taosMemoryFreeClear(pReq->name[i]);

48,967✔

2439

    taosMemoryFreeClear(pReq->name);

42,895✔

2443

static FORCE_INLINE void tFreeStreamCalcScan(void* pScan) {

2,240,896✔

2444

  if (pScan == NULL) {

2,240,896✔

2447

  SStreamCalcScan *pCalcScan = (SStreamCalcScan *)pScan;

2,240,896✔

2448

  taosArrayDestroy(pCalcScan->vgList);

2,240,896✔

2449

  taosMemoryFreeClear(pCalcScan->scanPlan);

2,240,896✔

2452

void tFreeStreamOutCol(void* pCol) {

74,235✔

2453

  if (pCol == NULL) {

74,235✔

2456

  SStreamOutCol *pOutCol = (SStreamOutCol *)pCol;

74,235✔

2457

  taosMemoryFreeClear(pOutCol->expr);

74,235✔

2462

void tFreeSCMCreateStreamReq(SCMCreateStreamReq *pReq) {

1,264,556✔

2463

  if (NULL == pReq) {

1,264,556✔

2464

    return;

198,415✔

2466

  taosMemoryFreeClear(pReq->name);

1,066,141✔

2467

  taosMemoryFreeClear(pReq->sql);

1,066,141✔

2468

  taosMemoryFreeClear(pReq->streamDB);

1,066,141✔

2469

  taosMemoryFreeClear(pReq->triggerDB);

1,066,141✔

2470

  taosMemoryFreeClear(pReq->outDB);

1,066,141✔

2471

  taosMemoryFreeClear(pReq->triggerTblName);

1,066,141✔

2472

  taosMemoryFreeClear(pReq->outTblName);

1,066,141✔

2474

  taosArrayDestroyP(pReq->calcDB, NULL);

1,066,141✔

2475

  pReq->calcDB = NULL;

1,066,141✔

2476

  taosArrayDestroyP(pReq->pNotifyAddrUrls, NULL);

1,066,141✔

2477

  pReq->pNotifyAddrUrls = NULL;

1,066,141✔

2479

  taosMemoryFreeClear(pReq->triggerFilterCols);

1,066,141✔

2480

  taosMemoryFreeClear(pReq->triggerCols);

1,066,141✔

2481

  taosMemoryFreeClear(pReq->partitionCols);

1,066,141✔

2483

  taosArrayDestroy(pReq->outTags);

1,066,141✔

2484

  pReq->outTags = NULL;

1,066,141✔

2485

  taosArrayDestroy(pReq->outCols);

1,066,141✔

2486

  pReq->outCols = NULL;

1,066,141✔

2488

  switch (pReq->triggerType) {

1,066,141✔

2489

    case WINDOW_TYPE_STATE:

296,701✔

2490

      taosMemoryFreeClear(pReq->trigger.stateWin.zeroth);

296,701✔

2491

      taosMemoryFreeClear(pReq->trigger.stateWin.expr);

296,701✔

2492

      break;

296,701✔

2493

    case WINDOW_TYPE_EVENT:

110,766✔

2494

      taosMemoryFreeClear(pReq->trigger.event.startCond);

110,766✔

2495

      taosMemoryFreeClear(pReq->trigger.event.endCond);

110,766✔

2496

      break;

110,766✔

2497

    default:

658,674✔

2498

      break;

658,674✔

2501

  taosMemoryFreeClear(pReq->triggerScanPlan);

1,066,141✔

2502

  taosArrayDestroyEx(pReq->calcScanPlanList, tFreeStreamCalcScan);

1,066,141✔

2503

  pReq->calcScanPlanList = NULL;

1,066,141✔

2504

  taosMemoryFreeClear(pReq->triggerPrevFilter);

1,066,141✔

2506

  taosMemoryFreeClear(pReq->calcPlan);

1,066,141✔

2507

  taosMemoryFreeClear(pReq->subTblNameExpr);

1,066,141✔

2508

  taosMemoryFreeClear(pReq->tagValueExpr);

1,066,141✔

2509

  taosArrayDestroyEx(pReq->forceOutCols, tFreeStreamOutCol);

1,066,141✔

2510

  pReq->forceOutCols = NULL;

1,066,141✔

2511

  taosArrayDestroy(pReq->colCids);

1,066,141✔

2512

  pReq->colCids = NULL;

1,066,141✔

2513

  taosArrayDestroy(pReq->tagCids);

1,066,141✔

2514

  pReq->tagCids = NULL;

1,066,141✔

2517

int32_t tCloneStreamCreateDeployPointers(SCMCreateStreamReq *pSrc, SCMCreateStreamReq** ppDst) {

185,668✔

2518

  int32_t code = 0, lino = 0;

185,668✔

2519

  if (NULL == pSrc) {

185,668✔

2523

  void* p = NULL;

185,668✔

2524

  int32_t num = 0;

185,668✔

2525

  *ppDst = taosMemoryCalloc(1, sizeof(SCMCreateStreamReq));

185,668✔

2526

  TSDB_CHECK_NULL(*ppDst, code, lino, _exit, terrno);

185,668✔

2528

  SCMCreateStreamReq* pDst = *ppDst;

185,668✔

2530

  if (pSrc->outDB) {

185,668✔

2531

    pDst->outDB = COPY_STR(pSrc->outDB);

182,364✔

2532

    TSDB_CHECK_NULL(pDst->outDB, code, lino, _exit, terrno);

182,364✔

2535

  if (pSrc->triggerTblName) {

185,668✔

2536

    pDst->triggerTblName = COPY_STR(pSrc->triggerTblName);

184,675✔

2537

    TSDB_CHECK_NULL(pDst->triggerTblName, code, lino, _exit, terrno);

184,675✔

2540

  if (pSrc->outTblName) {

185,668✔

2541

    pDst->outTblName = COPY_STR(pSrc->outTblName);

182,364✔

2542

    TSDB_CHECK_NULL(pDst->outTblName, code, lino, _exit, terrno);

182,364✔

2545

  if (pSrc->pNotifyAddrUrls) {

185,668✔

2546

    num = taosArrayGetSize(pSrc->pNotifyAddrUrls);

55,064✔

2547

    if (num > 0) {

55,064✔

2548

      pDst->pNotifyAddrUrls = taosArrayInit(num, POINTER_BYTES);

55,064✔

2549

      TSDB_CHECK_NULL(pDst->pNotifyAddrUrls, code, lino, _exit, terrno);

55,064✔

2551

    for (int32_t i = 0; i < num; ++i) {

110,128✔

2552

      p = taosStrdup(taosArrayGetP(pSrc->pNotifyAddrUrls, i));

55,064✔

2553

      TSDB_CHECK_NULL(p, code, lino, _exit, terrno);

55,064✔

2554

      TSDB_CHECK_NULL(taosArrayPush(pDst->pNotifyAddrUrls, &p), code, lino, _exit, terrno);

110,128✔

2558

  if (pSrc->triggerFilterCols) {

185,668✔

2559

    pDst->triggerFilterCols = COPY_STR(pSrc->triggerFilterCols);

17,213✔

2560

    TSDB_CHECK_NULL(pDst->triggerFilterCols, code, lino, _exit, terrno);

17,213✔

2563

  if (pSrc->triggerCols) {

185,668✔

2564

    pDst->triggerCols = COPY_STR(pSrc->triggerCols);

178,577✔

2565

    TSDB_CHECK_NULL(pDst->triggerCols, code, lino, _exit, terrno);

178,577✔

2568

  if (pSrc->partitionCols) {

185,668✔

2569

    pDst->partitionCols = COPY_STR(pSrc->partitionCols);

68,128✔

2570

    TSDB_CHECK_NULL(pDst->partitionCols, code, lino, _exit, terrno);

68,128✔

2573

  if (pSrc->outCols) {

185,668✔

2574

    pDst->outCols = taosArrayDup(pSrc->outCols, NULL);

182,364✔

2575

    TSDB_CHECK_NULL(pDst->outCols, code, lino, _exit, terrno);

182,364✔

2578

  if (pSrc->outTags) {

185,668✔

2579

    pDst->outTags = taosArrayDup(pSrc->outTags, NULL);

68,128✔

2580

    TSDB_CHECK_NULL(pDst->outTags, code, lino, _exit, terrno);

68,128✔

2583

  pDst->triggerType = pSrc->triggerType;

185,668✔

2585

  switch (pSrc->triggerType) {

185,668✔

2586

    case WINDOW_TYPE_STATE:

63,813✔

2587

      pDst->trigger.stateWin.slotId = pSrc->trigger.stateWin.slotId;

63,813✔

2588

      pDst->trigger.stateWin.extend = pSrc->trigger.stateWin.extend;

63,813✔

2589

      pDst->trigger.stateWin.trueForType = pSrc->trigger.stateWin.trueForType;

63,813✔

2590

      pDst->trigger.stateWin.trueForCount = pSrc->trigger.stateWin.trueForCount;

63,813✔

2591

      pDst->trigger.stateWin.trueForDuration = pSrc->trigger.stateWin.trueForDuration;

63,813✔

2592

      if (pSrc->trigger.stateWin.zeroth) {

63,813✔

2596

      if (pSrc->trigger.stateWin.expr) {

63,813✔

2597

        pDst->trigger.stateWin.expr = COPY_STR(pSrc->trigger.stateWin.expr);

63,813✔

2598

        TSDB_CHECK_NULL(pDst->trigger.stateWin.expr, code, lino, _exit, terrno);

63,813✔

2600

      break;

63,813✔

2601

    case WINDOW_TYPE_EVENT:

23,016✔

2602

      if (pSrc->trigger.event.startCond) {

23,016✔

2603

        pDst->trigger.event.startCond = COPY_STR(pSrc->trigger.event.startCond);

23,016✔

2604

        TSDB_CHECK_NULL(pDst->trigger.event.startCond, code, lino, _exit, terrno);

23,016✔

2607

      if (pSrc->trigger.event.endCond) {

23,016✔

2608

        pDst->trigger.event.endCond = COPY_STR(pSrc->trigger.event.endCond);

21,048✔

2609

        TSDB_CHECK_NULL(pDst->trigger.event.endCond, code, lino, _exit, terrno);

21,048✔

2611

      pDst->trigger.event.trueForType = pSrc->trigger.event.trueForType;

23,016✔

2612

      pDst->trigger.event.trueForCount = pSrc->trigger.event.trueForCount;

23,016✔

2613

      pDst->trigger.event.trueForDuration = pSrc->trigger.event.trueForDuration;

23,016✔

2614

      break;

23,016✔

2615

    case WINDOW_TYPE_COUNT:

17,539✔

2616

      pDst->trigger.count.countVal = pSrc->trigger.count.countVal;

17,539✔

2617

      pDst->trigger.count.sliding = pSrc->trigger.count.sliding;

17,539✔

2618

      if (pSrc->trigger.count.condCols) {

17,539✔

2622

      break;

17,539✔

2623

    default:

81,300✔

2624

      pDst->trigger = pSrc->trigger;

81,300✔

2625

      break;

81,300✔

2629

  if (pSrc->triggerScanPlan) {

185,668✔

2630

    pDst->triggerScanPlan = COPY_STR(pSrc->triggerScanPlan);

184,675✔

2631

    TSDB_CHECK_NULL(pDst->triggerScanPlan, code, lino, _exit, terrno);

184,675✔

2634

  if (pSrc->calcScanPlanList) {

185,668✔

2635

    num = taosArrayGetSize(pSrc->calcScanPlanList);

182,364✔

2636

    if (num > 0) {

182,364✔

2637

      pDst->calcScanPlanList = taosArrayInit(num, sizeof(SStreamCalcScan));

182,364✔

2638

      TSDB_CHECK_NULL(pDst->calcScanPlanList, code, lino, _exit, terrno);

182,364✔

2640

    for (int32_t i = 0; i < num; ++i) {

636,689✔

2641

      SStreamCalcScan* sscan = taosArrayGet(pSrc->calcScanPlanList, i);

454,325✔

2642

      SStreamCalcScan  dscan = {.readFromCache = sscan->readFromCache};

454,325✔

2644

      dscan.vgList = taosArrayDup(sscan->vgList, NULL);

454,325✔

2645

      TSDB_CHECK_NULL(dscan.vgList, code, lino, _exit, terrno);

454,325✔

2647

      dscan.scanPlan = COPY_STR(sscan->scanPlan);

454,325✔

2648

      TSDB_CHECK_NULL(dscan.scanPlan, code, lino, _exit, terrno);

454,325✔

2650

      TSDB_CHECK_NULL(taosArrayPush(pDst->calcScanPlanList, &dscan), code, lino, _exit, terrno);

908,650✔

2654

  if (pSrc->triggerPrevFilter) {

185,668✔

2655

    pDst->triggerPrevFilter = COPY_STR(pSrc->triggerPrevFilter);

7,710✔

2656

    TSDB_CHECK_NULL(pDst->triggerPrevFilter, code, lino, _exit, terrno);

7,710✔

2659

  if (pSrc->calcPlan) {

185,668✔

2660

    pDst->calcPlan = COPY_STR(pSrc->calcPlan);

182,364✔

2661

    TSDB_CHECK_NULL(pDst->calcPlan, code, lino, _exit, terrno);

182,364✔

2664

  if (pSrc->subTblNameExpr) {

185,668✔

2665

    pDst->subTblNameExpr = COPY_STR(pSrc->subTblNameExpr);

68,128✔

2666

    TSDB_CHECK_NULL(pDst->subTblNameExpr, code, lino, _exit, terrno);

68,128✔

2669

  if (pSrc->tagValueExpr) {

185,668✔

2670

    pDst->tagValueExpr = COPY_STR(pSrc->tagValueExpr);

68,128✔

2671

    TSDB_CHECK_NULL(pDst->tagValueExpr, code, lino, _exit, terrno);

68,128✔

2674

  if (pSrc->forceOutCols) {

185,668✔

2675

    num = taosArrayGetSize(pSrc->forceOutCols);

3,255✔

2676

    if (num > 0) {

3,255✔

2677

      pDst->forceOutCols = taosArrayInit(num, sizeof(SStreamOutCol));

3,255✔

2678

      TSDB_CHECK_NULL(pDst->forceOutCols, code, lino, _exit, terrno);

3,255✔

2680

    for (int32_t i = 0; i < num; ++i) {

21,490✔

2681

      SStreamOutCol* scol = taosArrayGet(pSrc->forceOutCols, i);

18,235✔

2682

      SStreamOutCol  dcol = {.type = scol->type};

18,235✔

2684

      dcol.expr = COPY_STR(scol->expr);

18,235✔

2685

      TSDB_CHECK_NULL(dcol.expr, code, lino, _exit, terrno);

18,235✔

2687

      TSDB_CHECK_NULL(taosArrayPush(pDst->forceOutCols, &dcol), code, lino, _exit, terrno);

36,470✔

2691

  if (pSrc->colCids) {

185,668✔

2692

    pDst->colCids = taosArrayDup(pSrc->colCids, NULL);

3,997✔

2693

    TSDB_CHECK_NULL(pDst->colCids, code, lino, _exit, terrno);

3,997✔

2696

  if (pSrc->tagCids) {

185,668✔

2697

    pDst->tagCids = taosArrayDup(pSrc->tagCids, NULL);

3,356✔

2698

    TSDB_CHECK_NULL(pDst->tagCids, code, lino, _exit, terrno);

3,356✔

2701

  pDst->triggerTblUid = pSrc->triggerTblUid;

185,668✔

2702

  pDst->triggerTblType = pSrc->triggerTblType;

185,668✔

2703

  pDst->triggerPrec = pSrc->triggerPrec;

185,668✔

2704

  pDst->deleteReCalc = pSrc->deleteReCalc;

185,668✔

2705

  pDst->deleteOutTbl = pSrc->deleteOutTbl;

185,668✔

2706

  pDst->flags = pSrc->flags;

185,668✔

2708

_exit:

185,668✔

2710

  if (code) {

185,668✔

2715

  return code;

185,668✔

2719

int32_t tSerializeSMPauseStreamReq(void *buf, int32_t bufLen, const SMPauseStreamReq *pReq) {

5,836✔

2720

  int32_t  code = 0;

5,836✔

2723

  SEncoder encoder = {0};

5,836✔

2724

  tEncoderInit(&encoder, buf, bufLen);

5,836✔

2725

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

5,836✔

2727

  int32_t nameLen = pReq->name == NULL ? 0 : (int32_t)strlen(pReq->name) + 1;

5,836✔

2728

  TAOS_CHECK_EXIT(tEncodeBinary(&encoder, pReq->name, nameLen));

11,672✔

2729

  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->igNotExists));

11,672✔

2730

  tEndEncode(&encoder);

5,836✔

2732

_exit:

5,836✔

2733

  if (code) {

5,836✔

2736

    tlen = encoder.pos;

5,836✔

2738

  tEncoderClear(&encoder);

5,836✔

2739

  return tlen;

5,836✔

2742

int32_t tDeserializeSMPauseStreamReq(void *buf, int32_t bufLen, SMPauseStreamReq *pReq) {

2,765✔

2743

  SDecoder decoder = {0};

2,765✔

2744

  int32_t  code = 0;

2,765✔

2747

  tDecoderInit(&decoder, buf, bufLen);

2,765✔

2748

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

2,765✔

2749

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void**)&pReq->name, NULL));

5,530✔

2750

  TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->igNotExists));

5,530✔

2751

  tEndDecode(&decoder);

2,765✔

2753

_exit:

2,765✔

2754

  tDecoderClear(&decoder);

2,765✔

2755

  return code;

2,765✔

2758

void tFreeMPauseStreamReq(SMPauseStreamReq *pReq) {

2,918✔

2759

  taosMemoryFreeClear(pReq->name);

2,918✔

2760

2,918✔

2762

int32_t tSerializeSMResumeStreamReq(void *buf, int32_t bufLen, const SMResumeStreamReq *pReq) {

5,164✔

2763

  SEncoder encoder = {0};

5,164✔

2764

  int32_t  code = 0;

5,164✔

2767

  tEncoderInit(&encoder, buf, bufLen);

5,164✔

2768

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

5,164✔

2769

  int32_t nameLen = pReq->name == NULL ? 0 : (int32_t)strlen(pReq->name) + 1;

5,164✔

2770

  TAOS_CHECK_EXIT(tEncodeBinary(&encoder, pReq->name, nameLen));

10,328✔

2771

  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->igNotExists));

10,328✔

2772

  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->igUntreated));

10,328✔

2773

  tEndEncode(&encoder);

5,164✔

2775

_exit:

5,164✔

2776

  if (code) {

5,164✔

2779

    tlen = encoder.pos;

5,164✔

2781

  tEncoderClear(&encoder);

5,164✔

2782

  return tlen;

5,164✔

2785

int32_t tDeserializeSMResumeStreamReq(void *buf, int32_t bufLen, SMResumeStreamReq *pReq) {

2,429✔

2786

  SDecoder decoder = {0};

2,429✔

2787

  int32_t  code = 0;

2,429✔

2790

  tDecoderInit(&decoder, buf, bufLen);

2,429✔

2791

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

2,429✔

2792

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void**)&pReq->name, NULL));

4,858✔

2793

  TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->igNotExists));

4,858✔

2794

  TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->igUntreated));

4,858✔

2795

  tEndDecode(&decoder);

2,429✔

2797

_exit:

2,429✔

2798

  tDecoderClear(&decoder);

2,429✔

2799

  return code;

2,429✔

2802

void tFreeMResumeStreamReq(SMResumeStreamReq *pReq) {

2,582✔

2803

  taosMemoryFreeClear(pReq->name);

2,582✔

2804

2,582✔

2806

int32_t tSerializeSMRecalcStreamReq(void *buf, int32_t bufLen, const SMRecalcStreamReq *pReq) {

23,264✔

2807

  SEncoder encoder = {0};

23,264✔

2808

  int32_t  code = 0;

23,264✔

2811

  tEncoderInit(&encoder, buf, bufLen);

23,264✔

2812

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

23,264✔

2813

  int32_t nameLen = pReq->name == NULL ? 0 : (int32_t)strlen(pReq->name) + 1;

23,264✔

2814

  TAOS_CHECK_EXIT(tEncodeBinary(&encoder, pReq->name, nameLen));

46,528✔

2815

  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->calcAll));

46,528✔

2816

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->timeRange.skey));

46,528✔

2817

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->timeRange.ekey));

46,528✔

2818

  tEndEncode(&encoder);

23,264✔

2820

_exit:

23,264✔

2821

  if (code) {

23,264✔

2824

    tlen = encoder.pos;

23,264✔

2826

  tEncoderClear(&encoder);

23,264✔

2827

  return tlen;

23,264✔

2830

int32_t tDeserializeSMRecalcStreamReq(void *buf, int32_t bufLen, SMRecalcStreamReq *pReq) {

11,585✔

2831

  SDecoder decoder = {0};

11,585✔

2832

  int32_t  code = 0;

11,585✔

2835

  tDecoderInit(&decoder, buf, bufLen);

11,585✔

2836

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

11,585✔

2838

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void**)&pReq->name, NULL));

23,170✔

2839

  TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->calcAll));

23,170✔

2840

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->timeRange.skey));

23,170✔

2841

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->timeRange.ekey));

23,170✔

2842

  tEndDecode(&decoder);

11,585✔

2844

_exit:

11,585✔

2845

  tDecoderClear(&decoder);

11,585✔

2846

  return code;

11,585✔

2849

void tFreeMRecalcStreamReq(SMRecalcStreamReq *pReq) {

23,217✔

2850

  taosMemoryFreeClear(pReq->name);

23,217✔

2851

23,217✔

2853

static int32_t tEncodeStreamProgressReq(SEncoder *pEncoder, const SStreamProgressReq *pReq) {

12,220✔

2854

  int32_t code = 0;

12,220✔

2857

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pReq->streamId));

24,440✔

2858

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pReq->taskId));

24,440✔

2859

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->fetchIdx));

24,440✔

2861

_exit:

12,220✔

2862

  return code;

12,220✔

2865

int32_t tSerializeStreamProgressReq(void *buf, int32_t bufLen, const SStreamProgressReq *pReq) {

12,220✔

2866

  SEncoder encoder = {0};

12,220✔

2867

  int32_t  code = 0;

12,220✔

2870

  tEncoderInit(&encoder, buf, bufLen);

12,220✔

2872

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

12,220✔

2873

  TAOS_CHECK_EXIT(tEncodeStreamProgressReq(&encoder, pReq));

12,220✔

2875

  tEndEncode(&encoder);

12,220✔

2877

_exit:

12,220✔

2878

  if (code) {

12,220✔

2881

    tlen = encoder.pos;

12,220✔

2883

  tEncoderClear(&encoder);

12,220✔

2884

  return tlen;

12,220✔

2887

static int32_t tDecodeStreamProgressReq(SDecoder *pDecoder, SStreamProgressReq *pReq) {

10,140✔

2888

  int32_t code = 0;

10,140✔

2891

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->streamId));

20,280✔

2892

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->taskId));

20,280✔

2893

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->fetchIdx));

20,280✔

2895

_exit:

10,140✔

2896

  return code;

10,140✔

2899

int32_t tDeserializeStreamProgressReq(void *buf, int32_t bufLen, SStreamProgressReq *pReq) {

10,140✔

2900

  SDecoder decoder = {0};

10,140✔

2901

  int32_t  code = 0;

10,140✔

2904

  tDecoderInit(&decoder, (char *)buf, bufLen);

10,140✔

2906

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

10,140✔

2907

  TAOS_CHECK_EXIT(tDecodeStreamProgressReq(&decoder, pReq));

10,140✔

2909

  tEndDecode(&decoder);

10,140✔

2911

_exit:

10,140✔

2912

  tDecoderClear(&decoder);

10,140✔

2913

  return code;

10,140✔

2916

static int32_t tEncodeStreamProgressRsp(SEncoder *pEncoder, const SStreamProgressRsp *pRsp) {

12,220✔

2917

  int32_t code = 0;

12,220✔

2920

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pRsp->streamId));

24,440✔

2921

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pRsp->fillHisFinished));

24,440✔

2922

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pRsp->progressDelay));

24,440✔

2923

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pRsp->fetchIdx));

24,440✔

2925

_exit:

12,220✔

2926

  return code;

12,220✔

2929

int32_t tSerializeStreamProgressRsp(void *buf, int32_t bufLen, const SStreamProgressRsp *pRsp) {

12,220✔

2930

  SEncoder encoder = {0};

12,220✔

2931

  int32_t  code = 0;

12,220✔

2934

  tEncoderInit(&encoder, buf, bufLen);

12,220✔

2936

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

12,220✔

2937

  TAOS_CHECK_EXIT(tEncodeStreamProgressRsp(&encoder, pRsp));

12,220✔

2939

  tEndEncode(&encoder);

12,220✔

2941

_exit:

12,220✔

2942

  if (code) {

12,220✔

2945

    tlen = encoder.pos;

12,220✔

2947

  tEncoderClear(&encoder);

12,220✔

2948

  return tlen;

12,220✔

2951

static int32_t tDecodeStreamProgressRsp(SDecoder *pDecoder, SStreamProgressRsp *pRsp) {

6,110✔

2952

  int32_t code = 0;

6,110✔

2955

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pRsp->streamId));

12,220✔

2956

  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, (int8_t *)&pRsp->fillHisFinished));

12,220✔

2957

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pRsp->progressDelay));

12,220✔

2958

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pRsp->fetchIdx));

12,220✔

2960

_exit:

6,110✔

2961

  return code;

6,110✔

2964

int32_t tDeserializeSStreamProgressRsp(void *buf, int32_t bufLen, SStreamProgressRsp *pRsp) {

6,110✔

2965

  SDecoder decoder = {0};

6,110✔

2966

  int32_t  code = 0;

6,110✔

2969

  tDecoderInit(&decoder, buf, bufLen);

6,110✔

2971

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

6,110✔

2972

  TAOS_CHECK_EXIT(tDecodeStreamProgressRsp(&decoder, pRsp));

6,110✔

2974

  tEndDecode(&decoder);

6,110✔

2976

_exit:

6,110✔

2977

  tDecoderClear(&decoder);

6,110✔

2978

  return code;

6,110✔

2981

int32_t tSerializeSTriggerOrigTableInfoRsp(void* buf, int32_t bufLen, const SSTriggerOrigTableInfoRsp* pRsp){

267,308✔

2982

  SEncoder encoder = {0};

267,308✔

2983

  int32_t  code = TSDB_CODE_SUCCESS;

267,308✔

2984

  int32_t  lino = 0;

267,308✔

2985

  int32_t  tlen = 0;

267,308✔

2987

  tEncoderInit(&encoder, buf, bufLen);

267,308✔

2988

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

267,308✔

2990

  int32_t size = taosArrayGetSize(pRsp->cols);

267,308✔

2991

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, size));

267,308✔

2992

  for (int32_t i = 0; i < size; ++i) {

988,064✔

2993

    OTableInfoRsp* oInfo = taosArrayGet(pRsp->cols, i);

720,756✔

2994

    if (oInfo == NULL) {

720,756✔

2999

    TAOS_CHECK_EXIT(tEncodeI64(&encoder, oInfo->suid));

1,441,512✔

3000

    TAOS_CHECK_EXIT(tEncodeI64(&encoder, oInfo->uid));

1,441,512✔

3001

    TAOS_CHECK_EXIT(tEncodeI16(&encoder, oInfo->cid));

1,441,512✔

3004

  tEndEncode(&encoder);

267,308✔

3006

_exit:

267,102✔

3007

  if (code != TSDB_CODE_SUCCESS) {

267,102✔

3010

    tlen = encoder.pos;

267,102✔

3012

  tEncoderClear(&encoder);

267,102✔

3013

  return tlen;

267,308✔

3016

int32_t tDserializeSTriggerOrigTableInfoRsp(void* buf, int32_t bufLen, SSTriggerOrigTableInfoRsp* pRsp){

133,654✔

3017

  SDecoder decoder = {0};

133,654✔

3018

  int32_t  code = TSDB_CODE_SUCCESS;

133,654✔

3019

  int32_t  lino = 0;

133,654✔

3021

  tDecoderInit(&decoder, buf, bufLen);

133,654✔

3022

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

133,654✔

3024

  int32_t size = 0;

133,654✔

3025

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &size));

133,654✔

3026

  pRsp->cols = taosArrayInit(size, sizeof(OTableInfoRsp));

133,654✔

3027

  if (pRsp->cols == NULL) {

133,654✔

3032

  for (int32_t i = 0; i < size; ++i) {

494,032✔

3033

    OTableInfoRsp* oInfo = taosArrayReserve(pRsp->cols, 1);

360,378✔

3034

    if (oInfo == NULL) {

360,378✔

3039

    TAOS_CHECK_RETURN(tDecodeI64(&decoder, &oInfo->suid));

720,756✔

3040

    TAOS_CHECK_RETURN(tDecodeI64(&decoder, &oInfo->uid));

720,756✔

3041

    TAOS_CHECK_RETURN(tDecodeI16(&decoder, &oInfo->cid));

720,756✔

3044

  tEndDecode(&decoder);

133,654✔

3046

_exit:

133,654✔

3047

  tDecoderClear(&decoder);

133,654✔

3048

  return code;

133,654✔

3051

void    tDestroySTriggerOrigTableInfoRsp(SSTriggerOrigTableInfoRsp* pRsp){

24,730,113✔

3052

  taosArrayDestroy(pRsp->cols);

24,730,113✔

3053

24,729,883✔

3055

void tDestroySTriggerPullRequest(SSTriggerPullRequestUnion* pReq) {

33,371,785✔

3056

  if (pReq == NULL) return;

33,371,785✔

3057

  if (pReq->base.type == STRIGGER_PULL_WAL_DATA_NEW || pReq->base.type == STRIGGER_PULL_WAL_CALC_DATA_NEW) {

41,988,576✔

3058

    SSTriggerWalDataNewRequest* pRequest = (SSTriggerWalDataNewRequest*)pReq;

8,619,029✔

3059

    taosArrayDestroy(pRequest->versions);

8,619,029✔

3060

    tSimpleHashCleanup(pRequest->ranges);

8,617,481✔

3061

  } else if (pReq->base.type == STRIGGER_PULL_TSDB_DATA) {

24,755,473✔

3062

    SSTriggerTsdbDataRequest* pRequest = (SSTriggerTsdbDataRequest*)pReq;

578,709✔

3063

    if (pRequest->cids != NULL) {

578,709✔

3064

      taosArrayDestroy(pRequest->cids);

578,709✔

3065

      pRequest->cids = NULL;

578,709✔

3067

  } else if (pReq->base.type == STRIGGER_PULL_VTABLE_INFO) {

24,177,203✔

3068

    SSTriggerVirTableInfoRequest* pRequest = (SSTriggerVirTableInfoRequest*)pReq;

78,009✔

3069

    if (pRequest->cids != NULL) {

78,009✔

3070

      taosArrayDestroy(pRequest->cids);

78,009✔

3071

      pRequest->cids = NULL;

78,009✔

3073

    if (pRequest->uids != NULL) {

78,009✔

3077

  } else if (pReq->base.type == STRIGGER_PULL_VTABLE_PSEUDO_COL) {

24,097,331✔

3078

    SSTriggerVirTablePseudoColRequest *pRequest = (SSTriggerVirTablePseudoColRequest*)pReq;

959,789✔

3079

    if (pRequest->cids != NULL) {

959,789✔

3080

      taosArrayDestroy(pRequest->cids);

959,789✔

3081

      pRequest->cids = NULL;

959,789✔

3083

  } else if (pReq->base.type == STRIGGER_PULL_OTABLE_INFO) {

23,137,098✔

3084

    SSTriggerOrigTableInfoRequest* pRequest = (SSTriggerOrigTableInfoRequest*)pReq;

133,654✔

3085

    if (pRequest->cols != NULL) {

133,654✔

3086

      taosArrayDestroy(pRequest->cols);

133,654✔

3087

      pRequest->cols = NULL;

133,654✔

3089

  } else if (pReq->base.type == STRIGGER_PULL_SET_TABLE) {

23,003,876✔

3090

    SSTriggerSetTableRequest* pRequest = (SSTriggerSetTableRequest*)pReq;

133,654✔

3091

    tSimpleHashCleanup(pRequest->uidInfoTrigger);

133,654✔

3092

    tSimpleHashCleanup(pRequest->uidInfoCalc);

133,654✔

3096

int32_t encodePlainArray(SEncoder *encoder, SArray *pArr) {

3,395,382✔

3097

  int32_t  code = TSDB_CODE_SUCCESS;

3,395,382✔

3098

  int32_t  lino = 0;

3,395,382✔

3099

  int32_t  nEle = taosArrayGetSize(pArr);

3,395,382✔

3100

  uint8_t* buf = (nEle > 0) ? TARRAY_DATA(pArr) : NULL;

3,395,382✔

3101

  int32_t  len = (nEle > 0) ? (nEle * pArr->elemSize) : 0;

3,395,382✔

3102

  TAOS_CHECK_EXIT(tEncodeBinary(encoder, buf, len));

6,790,764✔

3104

_exit:

3,395,382✔

3105

  return code;

3,395,382✔

3108

int32_t decodePlainArray(SDecoder* decoder, SArray** ppArr, uint32_t elemSize) {

1,694,516✔

3109

  int32_t  code = TSDB_CODE_SUCCESS;

1,694,516✔

3110

  int32_t  lino = 0;

1,694,516✔

3111

  void*    buf = NULL;

1,694,516✔

3112

  uint64_t len = 0;

1,694,516✔

3113

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(decoder, &buf, &len));

1,694,516✔

3115

  if (len > 0) {

1,694,516✔

3116

    *ppArr = taosArrayInit(0, elemSize);

1,616,507✔

3117

    TSDB_CHECK_NULL(*ppArr, code, lino, _exit, terrno);

1,616,507✔

3118

    TSWAP((*ppArr)->pData, buf);

1,615,736✔

3119

    (*ppArr)->size = (*ppArr)->capacity = len / elemSize;

1,616,507✔

3122

_exit:

1,693,745✔

3123

  if (buf != NULL) {

1,694,516✔

3124

    taosMemoryFree(buf);

1,615,736✔

3126

  return code;

1,694,516✔

3129

static int32_t encodeSetTableMapInfo(SEncoder* encoder, SSHashObj* pInfo) {

534,386✔

3130

  int32_t  code = TSDB_CODE_SUCCESS;

534,386✔

3131

  int32_t  lino = 0;

534,386✔

3132

  int32_t size = tSimpleHashGetSize(pInfo);

534,386✔

3133

  TAOS_CHECK_EXIT(tEncodeI32(encoder, size));

534,156✔

3134

  int32_t iter = 0;

534,156✔

3135

  void*   px = tSimpleHashIterate(pInfo, NULL, &iter);

534,156✔

3136

  while (px != NULL) {

1,199,000✔

3137

    int64_t* uid = tSimpleHashGetKey(px, NULL);

664,384✔

3138

    TAOS_CHECK_EXIT(tEncodeI64(encoder, *uid));

1,328,768✔

3139

    TAOS_CHECK_EXIT(tEncodeI64(encoder, *(uid + 1)));

1,328,768✔

3140

    SSHashObj* info = *(SSHashObj**)px;

664,384✔

3141

    int32_t len = tSimpleHashGetSize(info);

664,384✔

3142

    TAOS_CHECK_EXIT(tEncodeI32(encoder, len));

664,384✔

3143

    int32_t iter1 = 0;

664,384✔

3144

    void*   px1 = tSimpleHashIterate(info, NULL, &iter1);

664,154✔

3145

    while (px1 != NULL) {

2,506,356✔

3146

      int16_t* slot = tSimpleHashGetKey(px1, NULL);

1,841,742✔

3147

      int16_t* cid = (int16_t*)px1;

1,841,742✔

3148

      TAOS_CHECK_EXIT(tEncodeI16(encoder, *slot));

3,683,714✔

3149

      TAOS_CHECK_EXIT(tEncodeI16(encoder, *cid));

3,684,174✔

3151

      px1 = tSimpleHashIterate(info, px1, &iter1);

1,842,202✔

3154

    px = tSimpleHashIterate(pInfo, px, &iter);

664,384✔

3157

_exit:

534,616✔

3158

  return code;

534,616✔

3161

int32_t tSerializeSTriggerPullRequest(void* buf, int32_t bufLen, const SSTriggerPullRequest* pReq) {

67,109,125✔

3162

  SEncoder encoder = {0};

67,109,125✔

3163

  int32_t  code = TSDB_CODE_SUCCESS;

67,108,665✔

3164

  int32_t  lino = 0;

67,108,665✔

3165

  int32_t  tlen = 0;

67,108,665✔

3167

  tEncoderInit(&encoder, buf, bufLen);

67,108,665✔

3168

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

67,105,888✔

3170

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->type));

134,212,401✔

3171

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->streamId));

134,204,419✔

3172

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->readerTaskId));

134,201,604✔

3173

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->sessionId));

134,209,689✔

3175

  switch (pReq->type) {

67,105,015✔

3176

    case STRIGGER_PULL_SET_TABLE: {

267,308✔

3177

      SSTriggerSetTableRequest* pRequest = (SSTriggerSetTableRequest*)pReq;

267,308✔

3178

      TAOS_CHECK_EXIT(encodeSetTableMapInfo(&encoder, pRequest->uidInfoTrigger));

267,308✔

3179

      TAOS_CHECK_EXIT(encodeSetTableMapInfo(&encoder, pRequest->uidInfoCalc));

267,308✔

3180

      break;

267,308✔

3182

    case STRIGGER_PULL_LAST_TS: {

570,792✔

3183

      break;

570,792✔

3185

    case STRIGGER_PULL_FIRST_TS: {

526,086✔

3186

      SSTriggerFirstTsRequest* pRequest = (SSTriggerFirstTsRequest*)pReq;

526,086✔

3187

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->gid));

1,052,402✔

3188

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->startTime));

1,052,632✔

3189

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));

1,052,402✔

3190

      break;

526,086✔

3192

    case STRIGGER_PULL_TSDB_META: {

1,080,580✔

3193

      SSTriggerTsdbMetaRequest* pRequest = (SSTriggerTsdbMetaRequest*)pReq;

1,080,580✔

3194

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->startTime));

2,161,160✔

3195

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->endTime));

2,161,160✔

3196

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->gid));

2,161,160✔

3197

      TAOS_CHECK_EXIT(tEncodeI8(&encoder, pRequest->order));

2,161,160✔

3198

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));

2,161,160✔

3199

      break;

1,080,580✔

3204

    case STRIGGER_PULL_TSDB_TS_DATA: {

339,310✔

3205

      SSTriggerTsdbTsDataRequest* pRequest = (SSTriggerTsdbTsDataRequest*)pReq;

339,310✔

3206

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->suid));

678,620✔

3207

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->uid));

678,620✔

3208

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->skey));

678,620✔

3209

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ekey));

678,620✔

3210

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));

678,620✔

3211

      break;

339,310✔

3213

    case STRIGGER_PULL_TSDB_TRIGGER_DATA: {

110,428✔

3214

      SSTriggerTsdbTriggerDataRequest* pRequest = (SSTriggerTsdbTriggerDataRequest*)pReq;

110,428✔

3215

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->startTime));

220,856✔

3216

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->gid));

220,404✔

3217

      TAOS_CHECK_EXIT(tEncodeI8(&encoder, pRequest->order));

220,404✔

3218

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));

220,856✔

3219

      break;

110,428✔

3221

    case STRIGGER_PULL_TSDB_TRIGGER_DATA_NEXT: {

110,202✔

3222

      break;

110,202✔

3224

    case STRIGGER_PULL_TSDB_CALC_DATA: {

12,538,388✔

3225

      SSTriggerTsdbCalcDataRequest* pRequest = (SSTriggerTsdbCalcDataRequest*)pReq;

12,538,388✔

3226

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->gid));

25,076,324✔

3227

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->skey));

25,076,098✔

3228

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ekey));

25,076,324✔

3229

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));

25,076,098✔

3230

      break;

12,537,936✔

3235

    case STRIGGER_PULL_TSDB_DATA: {

1,162,044✔

3236

      SSTriggerTsdbDataRequest* pRequest = (SSTriggerTsdbDataRequest*)pReq;

1,162,044✔

3237

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->suid));

2,324,088✔

3238

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->uid));

2,324,088✔

3239

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->skey));

2,324,088✔

3240

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ekey));

2,324,088✔

3241

      TAOS_CHECK_EXIT(encodePlainArray(&encoder, pRequest->cids));

1,162,044✔

3242

      TAOS_CHECK_EXIT(tEncodeI8(&encoder, pRequest->order));

2,324,088✔

3243

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));

2,324,088✔

3244

      break;

1,162,044✔

3249

    case STRIGGER_PULL_WAL_META_NEW: {

23,325,259✔

3250

      SSTriggerWalMetaNewRequest* pRequest = (SSTriggerWalMetaNewRequest*)pReq;

23,325,259✔

3251

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->lastVer));

46,648,455✔

3252

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ctime));

46,647,753✔

3253

      break;

23,324,557✔

3255

    case STRIGGER_PULL_WAL_DATA_NEW:

17,234,728✔

3257

      SSTriggerWalDataNewRequest* pRequest = (SSTriggerWalDataNewRequest*)pReq;

17,234,728✔

3258

      int32_t                     nVersion = taosArrayGetSize(pRequest->versions);

17,234,728✔

3259

      TAOS_CHECK_EXIT(tEncodeI32(&encoder, nVersion));

17,234,498✔

3260

      for (int32_t i = 0; i < nVersion; i++) {

34,157,450✔

3261

        int64_t ver = *(int64_t*)TARRAY_GET_ELEM(pRequest->versions, i);

16,923,178✔

3262

        TAOS_CHECK_EXIT(tEncodeI64(&encoder, ver));

16,922,952✔

3264

      int32_t nRanges = tSimpleHashGetSize(pRequest->ranges);

17,234,272✔

3265

      TAOS_CHECK_EXIT(tEncodeI32(&encoder, nRanges));

17,232,658✔

3266

      int32_t iter = 0;

17,232,658✔

3267

      void*   px = tSimpleHashIterate(pRequest->ranges, NULL, &iter);

17,234,268✔

3268

      while (px != NULL) {

22,659,644✔

3269

        uint64_t* gid = tSimpleHashGetKey(px, NULL);

5,427,680✔

3270

        TAOS_CHECK_EXIT(tEncodeU64(&encoder, *gid));

10,855,360✔

3271

        int64_t* key = (int64_t*)px;

5,427,680✔

3272

        TAOS_CHECK_EXIT(tEncodeI64(&encoder, key[0]));

10,855,134✔

3273

        TAOS_CHECK_EXIT(tEncodeI64(&encoder, key[1]));

10,854,682✔

3275

        px = tSimpleHashIterate(pRequest->ranges, px, &iter);

5,427,228✔

3277

      break;

17,231,964✔

3279

    case STRIGGER_PULL_WAL_META_DATA_NEW: {

6,893,596✔

3280

      SSTriggerWalMetaDataNewRequest* pRequest = (SSTriggerWalMetaDataNewRequest*)pReq;

6,893,596✔

3281

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->lastVer));

13,789,004✔

3282

      break;

6,895,408✔

3284

    case STRIGGER_PULL_GROUP_COL_VALUE: {

602,954✔

3285

      SSTriggerGroupColValueRequest* pRequest = (SSTriggerGroupColValueRequest*)pReq;

602,954✔

3286

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->gid));

1,205,908✔

3287

      break;

602,954✔

3289

    case STRIGGER_PULL_VTABLE_INFO: {

156,880✔

3290

      SSTriggerVirTableInfoRequest* pRequest = (SSTriggerVirTableInfoRequest*)pReq;

156,880✔

3291

      TAOS_CHECK_EXIT(encodePlainArray(&encoder, pRequest->cids));

156,880✔

3292

      TAOS_CHECK_EXIT(encodePlainArray(&encoder, pRequest->uids));

156,880✔

3293

      TAOS_CHECK_EXIT(tEncodeBool(&encoder, pRequest->fetchAllTable));

156,880✔

3294

      break;

156,880✔

3296

    case STRIGGER_PULL_VTABLE_PSEUDO_COL: {

1,919,578✔

3297

      SSTriggerVirTablePseudoColRequest* pRequest = (SSTriggerVirTablePseudoColRequest*)pReq;

1,919,578✔

3298

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->uid));

3,839,156✔

3299

      TAOS_CHECK_EXIT(encodePlainArray(&encoder, pRequest->cids));

1,919,578✔

3300

      break;

1,919,578✔

3302

    case STRIGGER_PULL_OTABLE_INFO: {

267,308✔

3303

      SSTriggerOrigTableInfoRequest* pRequest = (SSTriggerOrigTableInfoRequest*)pReq;

267,308✔

3304

      int32_t size = taosArrayGetSize(pRequest->cols);

267,308✔

3305

      TAOS_CHECK_EXIT(tEncodeI32(&encoder, size));

267,308✔

3306

      for (int32_t i = 0; i < size; ++i) {

988,064✔

3307

        OTableInfo* oInfo = taosArrayGet(pRequest->cols, i);

720,756✔

3308

        if (oInfo == NULL) {

720,526✔

3313

        TAOS_CHECK_EXIT(tEncodeCStr(&encoder, oInfo->refTableName));

1,441,282✔

3314

        TAOS_CHECK_EXIT(tEncodeCStr(&encoder, oInfo->refColName));

1,441,512✔

3316

      break;

267,308✔

3325

  tEndEncode(&encoder);

67,104,025✔

3327

_exit:

67,095,235✔

3328

  if (code != TSDB_CODE_SUCCESS) {

67,096,926✔

3331

    tlen = encoder.pos;

67,096,926✔

3333

  tEncoderClear(&encoder);

67,096,926✔

3334

  return tlen;

67,100,477✔

3337

static void destroyHash(void* data){

332,192✔

3338

  if (data){

332,192✔

3339

    SSHashObj* tmp = *(SSHashObj**)data;

332,192✔

3340

    tSimpleHashCleanup(tmp);

332,192✔

3342

332,192✔

3344

static int32_t decodeSetTableMapInfo(SDecoder* decoder, SSHashObj** ppInfo) {

267,308✔

3345

  int32_t  code = TSDB_CODE_SUCCESS;

267,308✔

3346

  int32_t  lino = 0;

267,308✔

3347

  int32_t size = 0;

267,308✔

3348

  TAOS_CHECK_EXIT(tDecodeI32(decoder, &size));

267,308✔

3349

  *ppInfo = tSimpleHashInit(size, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY));

267,308✔

3350

  if (*ppInfo == NULL) {

267,308✔

3353

  tSimpleHashSetFreeFp(*ppInfo, destroyHash);

267,308✔

3355

  for (int32_t i = 0; i < size; ++i) {

599,270✔

3356

    int64_t id[2] = {0};

331,962✔

3357

    TAOS_CHECK_EXIT(tDecodeI64(decoder, id));

332,192✔

3358

    TAOS_CHECK_EXIT(tDecodeI64(decoder, id+1));

664,154✔

3359

    int32_t len = 0;

331,962✔

3360

    TAOS_CHECK_EXIT(tDecodeI32(decoder, &len));

332,192✔

3361

    SSHashObj* tmp = tSimpleHashInit(len, taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT));

332,192✔

3362

    if (tmp == NULL) {

331,732✔

3365

    TAOS_CHECK_EXIT(tSimpleHashPut(*ppInfo, id, sizeof(id), &tmp, POINTER_BYTES));

331,732✔

3367

    for (int32_t j = 0; j < len; ++j) {

1,253,293✔

3368

      int16_t slotId = 0;

921,331✔

3369

      int16_t cid = 0;

920,871✔

3370

      TAOS_CHECK_EXIT(tDecodeI16(decoder, &slotId));

921,101✔

3371

      TAOS_CHECK_EXIT(tDecodeI16(decoder, &cid));

921,101✔

3372

      TAOS_CHECK_EXIT(tSimpleHashPut(tmp, &slotId, sizeof(slotId), &cid, sizeof(cid)));

921,101✔

3375

_exit:

267,308✔

3376

  if (code != TSDB_CODE_SUCCESS) {

267,308✔

3380

  return code;

267,308✔

3383

int32_t tDeserializeSTriggerPullRequest(void* buf, int32_t bufLen, SSTriggerPullRequestUnion* pReq) {

33,373,253✔

3384

  SDecoder decoder = {0};

33,373,253✔

3385

  int32_t  code = TSDB_CODE_SUCCESS;

33,374,254✔

3386

  int32_t  lino = 0;

33,374,254✔

3388

  tDecoderInit(&decoder, buf, bufLen);

33,374,254✔

3389

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

33,374,434✔

3391

  int32_t type = 0;

33,376,722✔

3392

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &type));

33,377,199✔

3393

  SSTriggerPullRequest* pBase = &(pReq->base);

33,377,199✔

3394

  pBase->type = type;

33,376,973✔

3395

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pBase->streamId));

66,753,033✔

3396

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pBase->readerTaskId));

66,752,814✔

3397

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pBase->sessionId));

66,754,102✔

3399

  switch (type) {

33,376,921✔

3400

    case STRIGGER_PULL_SET_TABLE: {

133,654✔

3401

      SSTriggerSetTableRequest* pRequest = &(pReq->setTableReq);

133,654✔

3402

      TAOS_CHECK_EXIT(decodeSetTableMapInfo(&decoder, &pRequest->uidInfoTrigger));

133,654✔

3403

      TAOS_CHECK_EXIT(decodeSetTableMapInfo(&decoder, &pRequest->uidInfoCalc));

133,654✔

3404

      break;

133,654✔

3406

    case STRIGGER_PULL_LAST_TS: {

285,310✔

3407

      break;

285,310✔

3409

    case STRIGGER_PULL_FIRST_TS: {

261,262✔

3410

      SSTriggerFirstTsRequest* pRequest = &(pReq->firstTsReq);

261,262✔

3411

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));

522,524✔

3412

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->startTime));

522,524✔

3413

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));

522,524✔

3414

      break;

261,262✔

3416

    case STRIGGER_PULL_TSDB_META: {

540,228✔

3417

      SSTriggerTsdbMetaRequest* pRequest = &(pReq->tsdbMetaReq);

540,228✔

3418

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->startTime));

1,080,456✔

3419

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->endTime));

1,080,456✔

3420

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));

1,080,456✔

3421

      TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pRequest->order));

1,080,456✔

3422

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));

1,080,456✔

3423

      break;

540,228✔

3428

    case STRIGGER_PULL_TSDB_TS_DATA: {

169,655✔

3429

      SSTriggerTsdbTsDataRequest* pRequest = &(pReq->tsdbTsDataReq);

169,655✔

3430

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->suid));

339,310✔

3431

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->uid));

339,310✔

3432

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->skey));

339,310✔

3433

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ekey));

339,310✔

3434

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));

339,310✔

3435

      break;

169,655✔

3437

    case STRIGGER_PULL_TSDB_TRIGGER_DATA: {

55,214✔

3438

      SSTriggerTsdbTriggerDataRequest* pRequest = &(pReq->tsdbTriggerDataReq);

55,214✔

3439

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->startTime));

110,428✔

3440

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));

110,428✔

3441

      TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pRequest->order));

110,428✔

3442

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));

110,428✔

3443

      break;

55,214✔

3445

    case STRIGGER_PULL_TSDB_TRIGGER_DATA_NEXT: {

55,214✔

3446

      break;

55,214✔

3448

    case STRIGGER_PULL_TSDB_CALC_DATA: {

6,268,574✔

3449

      SSTriggerTsdbCalcDataRequest* pRequest = &(pReq->tsdbCalcDataReq);

6,268,574✔

3450

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));

12,537,148✔

3451

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->skey));

12,537,148✔

3452

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ekey));

12,537,148✔

3453

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));

12,537,148✔

3454

      break;

6,268,574✔

3459

    case STRIGGER_PULL_TSDB_DATA: {

578,709✔

3460

      SSTriggerTsdbDataRequest* pRequest = &(pReq->tsdbDataReq);

578,709✔

3461

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->suid));

1,157,418✔

3462

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->uid));

1,157,418✔

3463

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->skey));

1,157,418✔

3464

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ekey));

1,157,418✔

3465

      TAOS_CHECK_EXIT(decodePlainArray(&decoder, &pRequest->cids, sizeof(col_id_t)));

578,709✔

3466

      TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pRequest->order));

1,157,418✔

3467

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));

1,157,418✔

3468

      break;

578,709✔

3473

    case STRIGGER_PULL_WAL_META_NEW: {

11,562,122✔

3474

      SSTriggerWalMetaNewRequest* pRequest = &(pReq->walMetaNewReq);

11,562,122✔

3475

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->lastVer));

23,125,959✔

3476

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ctime));

23,127,396✔

3477

      break;

11,564,100✔

3479

    case STRIGGER_PULL_WAL_DATA_NEW:

8,617,477✔

3481

      SSTriggerWalDataNewRequest* pRequest = &(pReq->walDataNewReq);

8,617,477✔

3482

      int32_t                     nVersion = 0;

8,617,477✔

3483

      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nVersion));

8,617,937✔

3484

      pRequest->versions = taosArrayInit_s(sizeof(int64_t), nVersion);

8,617,937✔

3485

      for (int32_t i = 0; i < nVersion; i++) {

17,079,062✔

3486

        int64_t* pVer = TARRAY_GET_ELEM(pRequest->versions, i);

8,461,585✔

3487

        TAOS_CHECK_EXIT(tDecodeI64(&decoder, pVer));

8,461,815✔

3489

      int32_t nRanges = 0;

8,617,477✔

3490

      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nRanges));

8,617,707✔

3491

      pRequest->ranges = tSimpleHashInit(nRanges, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT));

8,617,707✔

3492

      if (pRequest->ranges == NULL) {

8,617,021✔

3495

      for (int32_t i = 0; i < nRanges; i++) {

11,329,860✔

3496

        uint64_t gid = 0;

2,713,069✔

3497

        int64_t pRange[2] = {0};

2,713,069✔

3498

        TAOS_CHECK_EXIT(tDecodeU64(&decoder, &gid));

2,713,840✔

3499

        TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRange[0]));

2,713,840✔

3500

        TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRange[1]));

2,713,840✔

3501

        TAOS_CHECK_EXIT(tSimpleHashPut(pRequest->ranges, &gid, sizeof(gid), pRange, sizeof(pRange)));

2,713,840✔

3503

      break;

8,616,791✔

3505

    case STRIGGER_PULL_WAL_META_DATA_NEW: {

3,372,841✔

3506

      SSTriggerWalMetaDataNewRequest* pRequest = &(pReq->walMetaDataNewReq);

3,372,841✔

3507

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->lastVer));

6,746,938✔

3508

      break;

3,373,737✔

3510

    case STRIGGER_PULL_GROUP_COL_VALUE: {

301,433✔

3511

      SSTriggerGroupColValueRequest* pRequest = &(pReq->groupColValueReq);

301,433✔

3512

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));

602,866✔

3513

      break;

301,433✔

3515

    case STRIGGER_PULL_VTABLE_INFO: {

78,009✔

3516

      SSTriggerVirTableInfoRequest* pRequest = &(pReq->virTableInfoReq);

78,009✔

3517

      TAOS_CHECK_EXIT(decodePlainArray(&decoder, &pRequest->cids, sizeof(col_id_t)));

78,009✔

3518

      TAOS_CHECK_EXIT(decodePlainArray(&decoder, &pRequest->uids, sizeof(int64_t)));

78,009✔

3519

      TAOS_CHECK_EXIT(tDecodeBool(&decoder, &pRequest->fetchAllTable));

78,009✔

3520

      break;

78,009✔

3522

    case STRIGGER_PULL_VTABLE_PSEUDO_COL: {

959,789✔

3523

      SSTriggerVirTablePseudoColRequest* pRequest = &(pReq->virTablePseudoColReq);

959,789✔

3524

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->uid));

1,919,578✔

3525

      TAOS_CHECK_EXIT(decodePlainArray(&decoder, &pRequest->cids, sizeof(col_id_t)));

959,789✔

3526

      break;

959,789✔

3528

    case STRIGGER_PULL_OTABLE_INFO: {

133,654✔

3529

      SSTriggerOrigTableInfoRequest* pRequest = &(pReq->origTableInfoReq);

133,654✔

3530

      int32_t size = 0;

133,654✔

3531

      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &size));

133,654✔

3532

      pRequest->cols = taosArrayInit(size, sizeof(OTableInfo));

133,654✔

3533

      if (pRequest->cols == NULL) {

133,654✔

3538

      for (int32_t i = 0; i < size; ++i) {

493,831✔

3539

        OTableInfo* oInfo = taosArrayReserve(pRequest->cols, 1);

360,378✔

3540

        if (oInfo == NULL) {

360,378✔

3545

        TAOS_CHECK_RETURN(tDecodeCStrTo(&decoder, oInfo->refTableName));

360,378✔

3546

        TAOS_CHECK_RETURN(tDecodeCStrTo(&decoder, oInfo->refColName));

360,378✔

3548

      break;

133,453✔

3550

    default: {

3,776✔

3551

      uError("unknown pull type %d", type);

3,776✔

3557

  tEndDecode(&decoder);

33,376,019✔

3559

_exit:

33,372,156✔

3560

  tDecoderClear(&decoder);

33,373,701✔

3561

  return code;

33,370,325✔

3564

static int32_t tSerializeSTriggerCalcParam(SEncoder* pEncoder, SArray* pParams, bool ignoreNotificationInfo, bool full) {

36,754,047✔

3565

  int32_t size = full ? taosArrayGetSize(pParams) : 0;

36,754,047✔

3566

  int32_t code = 0;

36,753,339✔

3567

  int32_t lino = 0;

36,753,339✔

3568

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, size));

36,754,768✔

3569

  for (int32_t i = 0; i < size; ++i) {

2,147,483,647✔

3570

    SSTriggerCalcParam* param = taosArrayGet(pParams, i);

2,147,483,647✔

3571

    if (param == NULL) {

2,147,483,647✔

3574

    int64_t plainFieldSize = offsetof(SSTriggerCalcParam, notifyType);

2,147,483,647✔

3575

    if (pEncoder->data) {

2,147,483,647✔

3576

      TAOS_MEMCPY(pEncoder->data + pEncoder->pos, param, plainFieldSize);

2,147,483,647✔

3578

    pEncoder->pos += plainFieldSize;

2,147,483,647✔

3580

    if (!ignoreNotificationInfo) {

2,147,483,647✔

3581

      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, param->notifyType));

1,097,511,483✔

3582

      uint64_t len = (param->extraNotifyContent != NULL) ? strlen(param->extraNotifyContent) + 1 : 0;

548,655,965✔

3583

      TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, (uint8_t*)param->extraNotifyContent, len));

891,763,414✔

3586

_exit:

5,140,028✔

3587

  return code;

5,140,028✔

3590

void tDestroySSTriggerCalcParam(void* ptr) {

2,147,483,647✔

3591

  SSTriggerCalcParam* pParam = ptr;

2,147,483,647✔

3592

  if (pParam && pParam->extraNotifyContent != NULL) {

2,147,483,647✔

3593

    taosMemoryFreeClear(pParam->extraNotifyContent);

256,557✔

3595

  if (pParam && pParam->resultNotifyContent != NULL) {

2,147,483,647✔

3598

2,147,483,647✔

3600

void tDestroySStreamGroupValue(void* ptr) {

26,308,456✔

3601

  SStreamGroupValue* pValue = ptr;

26,308,456✔

3602

  if ((pValue != NULL) && (IS_VAR_DATA_TYPE(pValue->data.type) || pValue->data.type == TSDB_DATA_TYPE_DECIMAL)) {

26,308,456✔

3603

    taosMemoryFreeClear(pValue->data.pData);

17,917,845✔

3604

    pValue->data.nData = 0;

17,918,335✔

3606

26,308,707✔

3608

static int32_t tDeserializeSTriggerCalcParam(SDecoder* pDecoder, SArray**ppParams, bool ignoreNotificationInfo) {

18,366,101✔

3609

  int32_t size = 0, code = 0, lino = 0;

18,366,101✔

3610

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &size));

18,365,862✔

3611

  *ppParams = taosArrayInit(size, sizeof(SSTriggerCalcParam));

18,365,862✔

3612

  if (*ppParams == NULL) {

18,366,489✔

3615

  for (int32_t i = 0; i < size; ++i) {

2,147,483,647✔

3616

    SSTriggerCalcParam* param = taosArrayReserve(*ppParams, 1);

2,147,483,647✔

3617

    if (param == NULL) {

2,147,483,647✔

3620

    int64_t plainFieldSize = offsetof(SSTriggerCalcParam, notifyType);

2,147,483,647✔

3621

    TAOS_MEMCPY(param, pDecoder->data + pDecoder->pos, plainFieldSize);

2,147,483,647✔

3622

    pDecoder->pos += plainFieldSize;

2,147,483,647✔

3624

    if (!ignoreNotificationInfo) {

2,147,483,647✔

3625

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &param->notifyType));

549,751,466✔

3626

      uint64_t len = 0;

274,875,733✔

3627

      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&param->extraNotifyContent, &len));

549,750,176✔

3631

_exit:

2,148,048✔

3632

  return code;

18,366,619✔

3635

static int32_t tSerializeStriggerGroupColVals(SEncoder* pEncoder, SArray* pGroupColVals, int32_t vgId) {

37,357,240✔

3636

  int32_t code = TSDB_CODE_SUCCESS;

37,357,240✔

3637

  int32_t lino = 0;

37,357,240✔

3639

  int32_t size = taosArrayGetSize(pGroupColVals);

37,357,240✔

3640

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, size));

37,358,486✔

3641

  for (int32_t i = 0; i < size; ++i) {

87,324,764✔

3642

    SStreamGroupValue* pValue = taosArrayGet(pGroupColVals, i);

49,967,930✔

3643

    if (pValue == NULL) {

49,966,727✔

3646

    TAOS_CHECK_EXIT(tEncodeBool(pEncoder, pValue->isNull));

49,966,727✔

3647

    if (pValue->isNull) {

49,965,810✔

3648

      continue;

15,570✔

3650

    TAOS_CHECK_EXIT(tEncodeBool(pEncoder, pValue->isTbname));

49,950,466✔

3651

    if (pValue->isTbname) {

49,951,182✔

3652

      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pValue->uid));

46,631,479✔

3653

      if (vgId != -1) { pValue->vgId = vgId; }

23,315,399✔

3654

      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pValue->vgId));

46,630,875✔

3656

    TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pValue->data.type));

99,902,555✔

3657

    if (IS_VAR_DATA_TYPE(pValue->data.type)) {

49,951,718✔

3658

      TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pValue->data.pData, pValue->data.nData));

68,338,888✔

3660

      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pValue->data.val));

31,563,547✔

3664

_exit:

37,356,834✔

3665

  return code;

37,356,834✔

3668

static int32_t tDeserializeStriggerGroupColVals(SDecoder* pDecoder, SArray** ppGroupColVals) {

18,667,970✔

3669

  int32_t code = TSDB_CODE_SUCCESS;

18,667,970✔

3670

  int32_t lino = 0;

18,667,970✔

3671

  int32_t size = 0;

18,667,970✔

3673

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &size));

18,668,326✔

3674

  taosArrayClearEx(*ppGroupColVals, tDestroySStreamGroupValue);

18,668,326✔

3675

  if (size > 0) {

18,667,957✔

3676

    if (*ppGroupColVals == NULL) {

12,738,568✔

3677

      *ppGroupColVals = taosArrayInit(size, sizeof(SStreamGroupValue));

12,738,937✔

3678

      if (*ppGroupColVals == NULL) {

12,737,918✔

3685

  for (int32_t i = 0; i < size; ++i) {

43,648,195✔

3686

    SStreamGroupValue* pValue = taosArrayReserve(*ppGroupColVals, 1);

24,980,245✔

3687

    if (pValue == NULL) {

24,981,433✔

3690

    TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &pValue->isNull));

24,981,433✔

3691

    if (pValue->isNull) {

24,981,709✔

3692

      continue;

7,785✔

3694

    TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &pValue->isTbname));

24,973,446✔

3695

    if (pValue->isTbname) {

24,974,380✔

3696

      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pValue->uid));

23,312,881✔

3697

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pValue->vgId));

23,312,881✔

3699

    TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pValue->data.type));

49,948,643✔

3700

    if (IS_VAR_DATA_TYPE(pValue->data.type)) {

42,056,228✔

3701

      uint64_t len = 0;

17,080,707✔

3702

      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pValue->data.pData, &len));

34,164,651✔

3703

      pValue->data.nData = len;

17,082,380✔

3705

      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pValue->data.val));

15,782,290✔

3708

_exit:

18,668,721✔

3709

  return code;

18,667,957✔

3712

int32_t tSerializeSStreamGroupInfo(void* buf, int32_t bufLen, const SStreamGroupInfo* gInfo, int32_t vgId) {

602,640✔

3713

  SEncoder encoder = {0};

602,640✔

3714

  int32_t  code = TSDB_CODE_SUCCESS;

602,640✔

3715

  int32_t  lino = 0;

602,640✔

3716

  int32_t  tlen = 0;

602,640✔

3718

  tEncoderInit(&encoder, buf, bufLen);

602,640✔

3719

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

602,217✔

3721

  TAOS_CHECK_EXIT(tSerializeStriggerGroupColVals(&encoder, gInfo->gInfo, vgId));

602,640✔

3723

  tEndEncode(&encoder);

601,991✔

3725

_exit:

602,636✔

3726

  if (code != TSDB_CODE_SUCCESS) {

602,636✔

3729

    tlen = encoder.pos;

602,636✔

3731

  tEncoderClear(&encoder);

602,636✔

3732

  return tlen;

601,621✔

3735

int32_t tDeserializeSStreamGroupInfo(void* buf, int32_t bufLen, SStreamGroupInfo* gInfo) {

301,257✔

3736

  SDecoder decoder = {0};

301,257✔

3737

  int32_t  code = TSDB_CODE_SUCCESS;

301,257✔

3738

  int32_t  lino = 0;

301,257✔

3739

  int32_t  size = 0;

301,257✔

3741

  tDecoderInit(&decoder, buf, bufLen);

301,257✔

3742

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

301,477✔

3744

  TAOS_CHECK_EXIT(tDeserializeStriggerGroupColVals(&decoder, &gInfo->gInfo));

301,477✔

3746

  tEndDecode(&decoder);

301,477✔

3748

_exit:

301,477✔

3749

  tDecoderClear(&decoder);

301,477✔

3750

  return code;

301,477✔

3753

int32_t tSerializeSTriggerCalcRequest(void* buf, int32_t bufLen, const SSTriggerCalcRequest* pReq) {

6,505,004✔

3754

  SEncoder encoder = {0};

6,505,004✔

3755

  int32_t  code = TSDB_CODE_SUCCESS;

6,505,004✔

3756

  int32_t  lino = 0;

6,505,004✔

3757

  int32_t  tlen = 0;

6,505,004✔

3759

  tEncoderInit(&encoder, buf, bufLen);

6,505,004✔

3760

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

6,504,789✔

3762

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->streamId));

13,009,363✔

3763

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->runnerTaskId));

13,009,563✔

3764

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->sessionId));

13,009,563✔

3765

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->triggerType));

13,009,148✔

3766

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->gid));

13,008,862✔

3768

  TAOS_CHECK_EXIT(tSerializeSTriggerCalcParam(&encoder, pReq->params, false, true));

6,504,503✔

3769

  TAOS_CHECK_EXIT(tSerializeStriggerGroupColVals(&encoder, pReq->groupColVals, -1));

6,504,774✔

3770

  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->createTable));

13,008,687✔

3771

  TAOS_CHECK_EXIT(tEncodeBool(&encoder, pReq->isWindowTrigger));

6,504,099✔

3772

  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->precision));

13,007,798✔

3774

  tEndEncode(&encoder);

6,503,899✔

3776

_exit:

6,504,114✔

3777

  if (code != TSDB_CODE_SUCCESS) {

6,504,114✔

3780

    tlen = encoder.pos;

6,504,114✔

3782

  tEncoderClear(&encoder);

6,504,114✔

3783

  return tlen;

6,504,789✔

3786

int32_t tDeserializeSTriggerCalcRequest(void* buf, int32_t bufLen, SSTriggerCalcRequest* pReq) {

3,251,528✔

3787

  SDecoder decoder = {0};

3,251,528✔

3788

  int32_t  code = TSDB_CODE_SUCCESS;

3,251,528✔

3789

  int32_t  lino = 0;

3,251,528✔

3791

  tDecoderInit(&decoder, buf, bufLen);

3,251,528✔

3792

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

3,251,743✔

3794

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->streamId));

6,503,271✔

3795

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->runnerTaskId));

6,503,486✔

3796

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->sessionId));

6,503,486✔

3797

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->triggerType));

6,503,486✔

3798

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->gid));

6,503,486✔

3800

  TAOS_CHECK_EXIT(tDeserializeSTriggerCalcParam(&decoder, &pReq->params, false));

3,251,743✔

3801

  TAOS_CHECK_EXIT(tDeserializeStriggerGroupColVals(&decoder, &pReq->groupColVals));

3,251,743✔

3802

  TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->createTable));

6,503,486✔

3803

  if (!tDecodeIsEnd(&decoder)) {

3,251,528✔

3804

    TAOS_CHECK_EXIT(tDecodeBool(&decoder, &pReq->isWindowTrigger));

3,251,528✔

3805

    TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->precision));

6,503,271✔

3808

  tEndDecode(&decoder);

3,251,743✔

3810

_exit:

3,251,743✔

3811

  tDecoderClear(&decoder);

3,251,743✔

3812

  return code;

3,251,743✔

3815

void tDestroySTriggerCalcRequest(SSTriggerCalcRequest* pReq) {

8,775,596✔

3816

  if (pReq != NULL) {

8,775,596✔

3817

    if (pReq->params != NULL) {

8,775,596✔

3818

      taosArrayDestroyEx(pReq->params, tDestroySSTriggerCalcParam);

5,954,258✔

3819

      pReq->params = NULL;

5,954,258✔

3821

    if (pReq->groupColVals != NULL) {

8,775,596✔

3822

      taosArrayDestroyEx(pReq->groupColVals, tDestroySStreamGroupValue);

3,122,759✔

3823

      pReq->groupColVals = NULL;

3,122,759✔

3825

    blockDataDestroy(pReq->pOutBlock);

8,775,596✔

3827

8,775,596✔

3888

int32_t tSerializeSTriggerCtrlRequest(void* buf, int32_t bufLen, const SSTriggerCtrlRequest* pReq) {

37,203,998✔

3889

  SEncoder encoder = {0};

37,203,998✔

3890

  int32_t  code = TSDB_CODE_SUCCESS;

37,203,998✔

3891

  int32_t  lino = 0;

37,203,998✔

3892

  int32_t  tlen = 0;

37,203,998✔

3894

  tEncoderInit(&encoder, buf, bufLen);

37,203,998✔

3895

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

37,203,998✔

3897

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->type));

74,406,454✔

3898

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->streamId));

74,406,851✔

3899

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->taskId));

74,406,851✔

3900

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->sessionId));

74,407,225✔

3902

  tEndEncode(&encoder);

37,203,998✔

3904

_exit:

37,203,998✔

3905

  if (code != TSDB_CODE_SUCCESS) {

37,203,998✔

3908

    tlen = encoder.pos;

37,203,998✔

3910

  tEncoderClear(&encoder);

37,203,998✔

3911

  return tlen;

37,203,227✔

3914

int32_t tDeserializeSTriggerCtrlRequest(void* buf, int32_t bufLen, SSTriggerCtrlRequest* pReq) {

55,765,837✔

3915

  SDecoder decoder = {0};

55,765,837✔

3916

  int32_t  code = TSDB_CODE_SUCCESS;

55,766,293✔

3917

  int32_t  lino = 0;

55,766,293✔

3919

  tDecoderInit(&decoder, buf, bufLen);

55,766,293✔

3920

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

55,770,342✔

3922

  int32_t type = 0;

55,776,484✔

3923

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &type));

55,778,656✔

3924

  pReq->type = type;

55,778,656✔

3925

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->streamId));

111,556,515✔

3926

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->taskId));

111,568,632✔

3927

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->sessionId));

111,568,402✔

3929

  tEndDecode(&decoder);

55,782,567✔

3931

_exit:

55,767,856✔

3932

  tDecoderClear(&decoder);

55,769,429✔

3933

  return code;

55,760,722✔

3936

int32_t tSerializeStRtFuncInfo(SEncoder* pEncoder, const SStreamRuntimeFuncInfo* pInfo, bool full) {

30,249,970✔

3937

  int32_t code = 0, lino = 0;

30,249,970✔

3938

  TAOS_CHECK_EXIT(tSerializeSTriggerCalcParam(pEncoder, pInfo->pStreamPesudoFuncVals, true, full));

30,249,970✔

3939

  TAOS_CHECK_EXIT(tSerializeStriggerGroupColVals(pEncoder, pInfo->pStreamPartColVals, -1));

30,249,724✔

3940

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->curWindow.skey));

60,499,243✔

3941

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->curWindow.ekey));

60,499,186✔

3942

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->groupId));

60,497,968✔

3943

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pInfo->curIdx));

60,497,344✔

3944

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->sessionId));

60,496,718✔

3945

  TAOS_CHECK_EXIT(tEncodeBool(pEncoder, pInfo->withExternalWindow));

30,248,294✔

3946

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pInfo->triggerType));

60,498,477✔

3947

  TAOS_CHECK_EXIT(tEncodeBool(pEncoder, pInfo->isWindowTrigger));

30,250,102✔

3948

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pInfo->precision));

60,495,747✔

3949

_exit:

30,248,032✔

3950

  return code;

30,248,032✔

3953

int32_t tDeserializeStRtFuncInfo(SDecoder* pDecoder, SStreamRuntimeFuncInfo* pInfo) {

15,115,106✔

3954

  int32_t code = 0, lino = 0;

15,115,106✔

3955

  int32_t size = 0;

15,115,106✔

3956

  TAOS_CHECK_EXIT(tDeserializeSTriggerCalcParam(pDecoder, &pInfo->pStreamPesudoFuncVals, true));

15,115,106✔

3957

  TAOS_CHECK_EXIT(tDeserializeStriggerGroupColVals(pDecoder, &pInfo->pStreamPartColVals));

15,114,637✔

3958

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->curWindow.skey));

30,228,600✔

3959

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->curWindow.ekey));

30,228,596✔

3960

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->groupId));

30,228,968✔

3961

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pInfo->curIdx));

30,229,604✔

3962

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->sessionId));

30,229,973✔

3963

  TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &pInfo->withExternalWindow));

15,115,106✔

3964

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pInfo->triggerType));

30,229,973✔

3965

  if (!tDecodeIsEnd(pDecoder)) {

15,115,106✔

3966

    TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &pInfo->isWindowTrigger));

15,114,389✔

3967

    TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pInfo->precision));

30,229,331✔

3969

_exit:

15,115,437✔

3970

  return code;

15,115,437✔

3973

void tDestroyStRtFuncInfo(SStreamRuntimeFuncInfo* pInfo){

24,171,225✔

3974

  if (pInfo == NULL) return;

24,171,225✔

3975

  if (pInfo->pStreamPesudoFuncVals != NULL) {

24,171,225✔

3976

    taosArrayDestroyEx(pInfo->pStreamPesudoFuncVals, tDestroySSTriggerCalcParam);

12,895,921✔

3977

    pInfo->pStreamPesudoFuncVals = NULL;

12,895,284✔

3979

  if (pInfo->pStreamPartColVals != NULL) {

24,249,164✔

3980

    taosArrayDestroyEx(pInfo->pStreamPartColVals, tDestroySStreamGroupValue);

9,798,006✔

3981

    pInfo->pStreamPartColVals = NULL;

9,798,018✔

3985

int32_t tSerializeSStreamMsgVTableInfo(void* buf, int32_t bufLen, const SStreamMsgVTableInfo* pRsp){

156,018✔

3986

  SEncoder encoder = {0};

156,018✔

3987

  int32_t  code = TSDB_CODE_SUCCESS;

156,018✔

3988

  int32_t  lino = 0;

156,018✔

3989

  int32_t  tlen = 0;

156,018✔

3991

  tEncoderInit(&encoder, buf, bufLen);

156,018✔

3992

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

156,018✔

3994

  int32_t size = taosArrayGetSize(pRsp->infos);

156,018✔

3995

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, size));

156,018✔

3996

  for (int32_t i = 0; i < size; ++i) {

529,010✔

3997

    VTableInfo* info = taosArrayGet(pRsp->infos, i);

372,992✔

3998

    if (info == NULL) {

372,992✔

4001

    TAOS_CHECK_EXIT(tEncodeI64(&encoder, info->gId));

745,984✔

4002

    TAOS_CHECK_EXIT(tEncodeI64(&encoder, info->uid));

745,984✔

4003

    TAOS_CHECK_EXIT(tEncodeSColRefWrapper(&encoder, &info->cols));

372,992✔

4006

  tEndEncode(&encoder);

156,018✔

4008

_exit:

156,018✔

4009

  if (code != TSDB_CODE_SUCCESS) {

156,018✔

4012

    tlen = encoder.pos;

156,018✔

4014

  tEncoderClear(&encoder);

156,018✔

4015

  return tlen;

156,018✔

4018

int32_t tDeserializeSStreamMsgVTableInfo(void* buf, int32_t bufLen, SStreamMsgVTableInfo *vTableInfo){

78,009✔

4019

  SDecoder decoder = {0};

78,009✔

4020

  int32_t  code = TSDB_CODE_SUCCESS;

78,009✔

4021

  int32_t  lino = 0;

78,009✔

4022

  int32_t  size = 0;

78,009✔

4024

  tDecoderInit(&decoder, buf, bufLen);

78,009✔

4025

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

78,009✔

4027

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &size));

78,009✔

4028

  vTableInfo->infos = taosArrayInit(size, sizeof(VTableInfo));

78,009✔

4029

  if (vTableInfo->infos == NULL) {

78,009✔

4032

  for (int32_t i = 0; i < size; ++i) {

264,505✔

4033

    VTableInfo* info = taosArrayReserve(vTableInfo->infos, 1);

186,496✔

4034

    if (info == NULL) {

186,496✔

4037

    TAOS_CHECK_EXIT(tDecodeI64(&decoder, &info->gId));

372,992✔

4038

    TAOS_CHECK_EXIT(tDecodeI64(&decoder, &info->uid));

372,992✔

4039

    TAOS_CHECK_EXIT(tDecodeSColRefWrapperEx(&decoder, &info->cols, false));

186,496✔

4042

  tEndDecode(&decoder);

78,009✔

4044

_exit:

78,009✔

4045

  tDecoderClear(&decoder);

78,009✔

4046

  return code;

78,009✔

4050

void tDestroyVTableInfo(void *ptr) {

372,992✔

4051

  if (NULL == ptr) {

372,992✔

4054

  VTableInfo* pTable = (VTableInfo*)ptr;

372,992✔

4055

  taosMemoryFree(pTable->cols.pColRef);

372,992✔

4058

void tDestroySStreamMsgVTableInfo(SStreamMsgVTableInfo *ptr) {

24,674,267✔

4059

  if (ptr == NULL) return;

24,674,267✔

4060

  taosArrayDestroyEx(ptr->infos, tDestroyVTableInfo);

24,674,267✔

4061

  ptr->infos = NULL;

24,674,497✔

4064

int32_t tSerializeSStreamTsResponse(void* buf, int32_t bufLen, const SStreamTsResponse* pRsp) {

1,091,547✔

4065

  SEncoder encoder = {0};

1,091,547✔

4066

  int32_t  code = TSDB_CODE_SUCCESS;

1,092,670✔

4067

  int32_t  lino = 0;

1,092,670✔

4068

  int32_t  tlen = 0;

1,092,670✔

4070

  tEncoderInit(&encoder, buf, bufLen);

1,092,670✔

4071

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

1,090,628✔

4073

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRsp->ver));

2,181,770✔

4074

  int32_t size = taosArrayGetSize(pRsp->tsInfo);

1,090,192✔

4075

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, size));

1,090,196✔

4076

  for (int32_t i = 0; i < size; ++i) {

2,533,746✔

4077

    STsInfo* tsInfo = taosArrayGet(pRsp->tsInfo, i);

1,443,190✔

4078

    TAOS_CHECK_EXIT(tEncodeI64(&encoder, tsInfo->gId));

2,887,104✔

4079

    TAOS_CHECK_EXIT(tEncodeI64(&encoder, tsInfo->ts));

2,887,782✔

4082

  tEndEncode(&encoder);

1,090,556✔

4084

_exit:

1,089,744✔

4085

  if (code != TSDB_CODE_SUCCESS) {

1,089,744✔

4088

    tlen = encoder.pos;

1,089,744✔

4090

  tEncoderClear(&encoder);

1,089,744✔

4091

  return tlen;

1,089,766✔

4094

int32_t tDeserializeSStreamTsResponse(void* buf, int32_t bufLen, void *pBlock) {

546,744✔

4095

  SDecoder decoder = {0};

546,744✔

4096

  int32_t  code = TSDB_CODE_SUCCESS;

546,744✔

4097

  int32_t  lino = 0;

546,744✔

4098

  SSDataBlock *pResBlock = pBlock;

546,744✔

4100

  tDecoderInit(&decoder, buf, bufLen);

546,744✔

4101

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

546,744✔

4103

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, (int64_t*)&pResBlock->info.id.groupId));

1,093,488✔

4104

  int32_t numOfCols = 2;

546,744✔

4105

  if (pResBlock->pDataBlock == NULL) {

546,744✔

4106

    pResBlock->pDataBlock = taosArrayInit_s(sizeof(SColumnInfoData), numOfCols);

546,744✔

4107

    if (pResBlock->pDataBlock == NULL) {

546,744✔

4110

    for (int32_t i = 0; i< numOfCols; ++i) {

1,639,994✔

4111

      SColumnInfoData *pColInfoData = taosArrayGet(pResBlock->pDataBlock, i);

1,093,250✔

4112

      if (pColInfoData == NULL) {

1,093,488✔

4115

      pColInfoData->info.type = TSDB_DATA_TYPE_BIGINT;

1,093,488✔

4116

      pColInfoData->info.bytes = sizeof(int64_t);

1,093,488✔

4119

  int32_t numOfRows = 0;

546,744✔

4120

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &numOfRows));

546,744✔

4121

  TAOS_CHECK_EXIT(blockDataEnsureCapacity(pResBlock, numOfRows));

546,744✔

4122

  for (int32_t i = 0; i < numOfRows; ++i) {

1,269,284✔

4123

    for (int32_t j = 0; j < numOfCols; ++j) {

2,168,334✔

4124

      SColumnInfoData *pColInfoData = taosArrayGet(pResBlock->pDataBlock, j);

1,445,556✔

4125

      if (pColInfoData == NULL) {

1,445,556✔

4128

      int64_t value = 0;

1,445,556✔

4129

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &value));

1,445,556✔

4130

      colDataSetInt64(pColInfoData, i, &value);

1,445,556✔

4134

  pResBlock->info.dataLoad = 1;

546,506✔

4135

  pResBlock->info.rows = numOfRows;

546,744✔

4137

  tEndDecode(&decoder);

546,561✔

4139

_exit:

546,744✔

4140

  tDecoderClear(&decoder);

546,744✔

4141

  return code;

546,744✔

4144

static int32_t encodeData(SEncoder* encoder, void* pBlock, SSHashObj* indexHash) {

2,092,162✔

4145

  int32_t code = TSDB_CODE_SUCCESS;

2,092,162✔

4146

  int32_t lino = 0;

2,092,162✔

4147

  int32_t len = 0;

2,092,162✔

4148

  if (encoder->data == NULL){

2,092,162✔

4149

    len = blockGetEncodeSize(pBlock);

1,045,855✔

4151

    len = blockEncode(pBlock, (char*)(encoder->data + encoder->pos), encoder->size - encoder->pos, blockDataGetNumOfCols(pBlock));

1,046,081✔

4152

    if (len < 0) {

1,046,081✔

4156

  encoder->pos += len;

2,092,392✔

4158

  if (indexHash == NULL) {

2,092,162✔

4159

    goto _exit;

964,458✔

4162

  uint32_t pos = encoder->pos;

1,127,704✔

4163

  encoder->pos += sizeof(uint32_t); // reserve space for tables

1,127,704✔

4164

  int32_t tables = 0;

1,127,704✔

4166

  void*   pe = NULL;

1,127,704✔

4167

  int32_t iter = 0;

1,127,704✔

4168

  while ((pe = tSimpleHashIterate(indexHash, pe, &iter)) != NULL) {

2,502,036✔

4169

    SStreamWalDataSlice* pInfo = (SStreamWalDataSlice*)pe;

1,374,788✔

4170

    if (pInfo->gId == -1){

1,374,788✔

4173

    int64_t uid = *(int64_t*)(tSimpleHashGetKey(pe, NULL));

1,375,014✔

4174

    TAOS_CHECK_EXIT(tEncodeI64(encoder, uid));

1,374,788✔

4175

    TAOS_CHECK_EXIT(tEncodeU64(encoder, pInfo->gId));

2,749,202✔

4176

    TAOS_CHECK_EXIT(tEncodeI32(encoder, pInfo->startRowIdx));

2,749,054✔

4177

    TAOS_CHECK_EXIT(tEncodeI32(encoder, pInfo->numRows));

2,748,972✔

4178

    tables++;

1,374,332✔

4180

  uint32_t tmpPos = encoder->pos;

1,126,792✔

4181

  encoder->pos = pos;

1,127,248✔

4182

  TAOS_CHECK_EXIT(tEncodeI32(encoder, tables));

1,127,252✔

4183

  encoder->pos = tmpPos;

1,127,252✔

4184

_exit:

2,092,162✔

4185

  return code;

2,092,162✔

4188

static int32_t encodeBlock(SEncoder* encoder, void* block, SSHashObj* indexHash) {

7,410,340✔

4189

  int32_t  code = TSDB_CODE_SUCCESS;

7,410,340✔

4190

  int32_t  lino = 0;

7,410,340✔

4191

  if (block != NULL && ((SSDataBlock*)block)->info.rows > 0) {

7,410,340✔

4192

    TAOS_CHECK_EXIT(tEncodeI8(encoder, 1));

2,092,392✔

4193

    TAOS_CHECK_EXIT(encodeData(encoder, block, indexHash));

2,092,392✔

4195

    TAOS_CHECK_EXIT(tEncodeI8(encoder, 0));

5,318,777✔

4198

_exit:

5,318,777✔

4199

  return code;

7,410,939✔

4202

int32_t tSerializeSStreamWalDataResponse(void* buf, int32_t bufLen, SSTriggerWalNewRsp* rsp) {

1,853,040✔

4203

  SEncoder encoder = {0};

1,853,040✔

4204

  int32_t  code = TSDB_CODE_SUCCESS;

1,852,814✔

4205

  int32_t  lino = 0;

1,852,814✔

4206

  int32_t  tlen = 0;

1,852,814✔

4208

  tEncoderInit(&encoder, buf, bufLen);

1,852,814✔

4209

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

1,852,843✔

4211

  TAOS_CHECK_EXIT(encodeBlock(&encoder, rsp->dataBlock, rsp->indexHash));

1,853,266✔

4212

  TAOS_CHECK_EXIT(encodeBlock(&encoder, rsp->metaBlock, NULL));

1,852,806✔

4213

  TAOS_CHECK_EXIT(encodeBlock(&encoder, rsp->deleteBlock, NULL));

1,852,580✔

4214

  TAOS_CHECK_EXIT(encodeBlock(&encoder, rsp->tableBlock, NULL));

1,852,308✔

4216

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, rsp->ver));

3,705,574✔

4217

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, rsp->verTime));

3,705,394✔

4218

  tEndEncode(&encoder);

1,852,584✔

4220

_exit:

1,851,931✔

4221

  if (code != TSDB_CODE_SUCCESS) {

1,851,931✔

4224

    tlen = encoder.pos;

1,851,931✔

4226

  tEncoderClear(&encoder);

1,851,931✔

4227

  return tlen;

1,853,040✔

4230

static int32_t decodeBlock(SDecoder* decoder, void* pBlock) {

2,779,037✔

4231

  int32_t  code = TSDB_CODE_SUCCESS;

2,779,037✔

4232

  int32_t  lino = 0;

2,779,037✔

4234

  int8_t hasData = false;

2,779,037✔

4235

  TAOS_CHECK_EXIT(tDecodeI8(decoder, &hasData));

2,779,686✔

4236

  if (hasData) {

2,779,686✔

4237

    TAOS_CHECK_EXIT(pBlock != NULL ? TSDB_CODE_SUCCESS : TSDB_CODE_INVALID_PARA);

482,521✔

4238

    const char* pEndPos = NULL;

482,521✔

4239

    TAOS_CHECK_EXIT(blockDecode(pBlock, (char*)decoder->data + decoder->pos, &pEndPos));

482,521✔

4240

    decoder->pos = (uint8_t*)pEndPos - decoder->data;

482,521✔

4241

  } else if (pBlock != NULL) {

2,297,165✔

4242

    blockDataEmpty(pBlock);

959,072✔

4245

_exit:

2,778,150✔

4246

  return code;

2,779,686✔

4249

int32_t tDeserializeSStreamWalDataResponse(void* buf, int32_t bufLen, SSTriggerWalNewRsp* pRsp, SArray* pSlices){

926,695✔

4250

  SDecoder     decoder = {0};

926,695✔

4251

  int32_t      code = TSDB_CODE_SUCCESS;

926,695✔

4252

  int32_t      lino = 0;

926,695✔

4253

  SSDataBlock* pBlock = NULL;

926,695✔

4255

  tDecoderInit(&decoder, buf, bufLen);

926,695✔

4256

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

926,695✔

4259

  int8_t hasData = false;

926,695✔

4260

  TAOS_CHECK_EXIT(tDecodeI8(&decoder, &hasData));

926,695✔

4261

  pBlock = pRsp->dataBlock;

926,695✔

4262

  if (hasData) {

926,695✔

4263

    TAOS_CHECK_EXIT(pBlock != NULL ? TSDB_CODE_SUCCESS : TSDB_CODE_INVALID_PARA);

563,852✔

4264

    const char* pEndPos = NULL;

563,852✔

4265

    TAOS_CHECK_EXIT(blockDecode(pBlock, (char*)decoder.data + decoder.pos, &pEndPos));

563,852✔

4266

    decoder.pos = (uint8_t*)pEndPos - decoder.data;

563,626✔

4268

    int32_t nSlices = 0;

563,626✔

4269

    TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nSlices));

563,626✔

4270

    TAOS_CHECK_EXIT(taosArrayEnsureCap(pSlices, nSlices));

563,626✔

4271

    taosArrayClear(pSlices);

563,626✔

4272

    int64_t  uid = 0;

563,626✔

4273

    uint64_t gid = 0;

563,626✔

4274

    int32_t  startIdx = 0;

563,626✔

4275

    int32_t  numRows = 0;

563,626✔

4276

    for (int32_t i = 0; i < nSlices; i++) {

1,250,907✔

4277

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &uid));

687,281✔

4278

      TAOS_CHECK_EXIT(tDecodeU64(&decoder, &gid));

687,507✔

4279

      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &startIdx));

687,507✔

4280

      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &numRows));

687,507✔

4281

      int32_t endIdx = startIdx + numRows;

687,507✔

4282

      int64_t value[3] = {gid, uid, (int64_t)startIdx << 32 | endIdx};

687,507✔

4283

      void*   px = taosArrayPush(pSlices, value);

687,281✔

4284

      if (px == NULL) {

687,281✔

4289

  } else if (pBlock != NULL) {

362,843✔

4290

    blockDataEmpty(pBlock);

3,259✔

4291

    taosArrayClear(pSlices);

3,259✔

4294

  TAOS_CHECK_EXIT(decodeBlock(&decoder, pRsp->metaBlock));

926,469✔

4295

  TAOS_CHECK_EXIT(decodeBlock(&decoder, pRsp->deleteBlock));

926,469✔

4296

  TAOS_CHECK_EXIT(decodeBlock(&decoder, pRsp->tableBlock));

926,695✔

4298

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->ver));

1,853,164✔

4299

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->verTime));

1,853,164✔

4301

  tEndDecode(&decoder);

926,695✔

4303

_exit:

926,695✔

4304

  if (code != TSDB_CODE_SUCCESS) {

926,695✔

4307

  tDecoderClear(&decoder);

926,695✔

4308

  return code;

926,457✔

taosdata / TDengine / #5000

Source File
Press 'n' to go to next uncovered line, 'b' for previous

taosdata / TDengine / #5000

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous