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

27

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

130,610✔

28

  int32_t code = 0;

130,610✔

29

  int32_t lino = 0;

130,610✔

30

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

261,220✔

31

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

261,220✔

32

  switch (pReq->type) {

130,610✔

33

    case STREAM_MGMT_REQ_TRIGGER_ORIGTBL_READER: {

125,726✔

34

      if (pReq->cont.pReqs) {

125,726✔

35

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

125,726✔

36

        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, num));

125,726✔

37

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

495,418✔

38

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

369,692✔

39

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

739,384✔

40

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

739,384✔

45

      break;

125,726✔

47

    case STREAM_MGMT_REQ_RUNNER_ORIGTBL_READER: {

4,884✔

48

      if (pReq->cont.pReqs) {

4,884✔

49

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

4,884✔

50

        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, num));

4,884✔

51

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

9,768✔

52

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

4,884✔

53

          int32_t vgIdNum = taosArrayGetSize(pDeploy->vgIds);

4,884✔

54

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

9,768✔

55

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

9,768✔

56

          TAOS_CHECK_EXIT(tEncodeI32(pEncoder, vgIdNum));

4,884✔

57

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

9,768✔

58

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

9,768✔

64

      break;

4,884✔

71

_exit:

130,610✔

73

  return code;

130,610✔

76

void tFreeRunnerOReaderDeployReq(void* param) {

7,326✔

77

  SStreamOReaderDeployReq* pReq = (SStreamOReaderDeployReq*)param;

7,326✔

78

  if (pReq) {

7,326✔

79

    taosArrayDestroy(pReq->vgIds);

7,326✔

81

7,326✔

83

void tFreeSStreamMgmtReq(SStreamMgmtReq* pReq) {

261,220✔

84

  if (NULL == pReq) {

261,220✔

85

    return;

65,305✔

88

  switch (pReq->type) {

195,915✔

89

    case STREAM_MGMT_REQ_TRIGGER_ORIGTBL_READER:

188,589✔

90

      taosArrayDestroy(pReq->cont.pReqs);

188,589✔

91

      break;

188,589✔

92

    case STREAM_MGMT_REQ_RUNNER_ORIGTBL_READER:

7,326✔

93

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

7,326✔

94

      break;

7,326✔

101

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

65,305✔

102

  *ppDst = NULL;

65,305✔

104

  if (NULL == pSrc) {

65,305✔

108

  int32_t code = 0, lino = 0;

65,305✔

109

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

65,305✔

110

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

65,305✔

112

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

65,305✔

113

  if (pSrc->cont.pReqs) {

65,305✔

114

    switch (pSrc->type) {

65,305✔

115

      case STREAM_MGMT_REQ_TRIGGER_ORIGTBL_READER:

62,863✔

116

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

62,863✔

117

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

62,863✔

118

        break;

62,863✔

119

      case STREAM_MGMT_REQ_RUNNER_ORIGTBL_READER: {

2,442✔

120

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

2,442✔

121

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

2,442✔

122

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

2,442✔

123

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

4,884✔

124

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

2,442✔

125

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

2,442✔

126

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

2,442✔

127

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

2,442✔

128

          pNew->execId = pReq->execId;

2,442✔

129

          pNew->uid = pReq->uid;

2,442✔

131

        break;

2,442✔

140

  if (code) {

65,305✔

146

  return code;

65,305✔

150

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

65,305✔

151

  int32_t code = 0;

65,305✔

152

  int32_t lino = 0;

65,305✔

154

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

130,610✔

155

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

130,610✔

156

  switch (pReq->type) {

65,305✔

157

    case STREAM_MGMT_REQ_TRIGGER_ORIGTBL_READER: {

62,863✔

158

      int32_t num = 0;

62,863✔

159

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &num));

62,863✔

160

      if (num > 0) {

62,863✔

161

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

62,863✔

162

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

62,863✔

163

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

247,709✔

164

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

184,846✔

165

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

184,846✔

166

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

184,846✔

169

      break;

62,863✔

171

    case STREAM_MGMT_REQ_RUNNER_ORIGTBL_READER: {

2,442✔

172

      int32_t num = 0, vgIdNum = 0;

2,442✔

173

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &num));

2,442✔

174

      if (num > 0) {

2,442✔

175

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

2,442✔

176

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

2,442✔

177

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

4,884✔

178

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

2,442✔

179

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

4,884✔

180

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

4,884✔

181

          TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgIdNum));

2,442✔

182

          if (vgIdNum > 0) {

2,442✔

183

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

2,442✔

184

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

2,442✔

186

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

4,884✔

187

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

2,442✔

188

            TAOS_CHECK_EXIT(tDecodeI32(pDecoder, vgId));

2,442✔

192

      break;

2,442✔

199

_exit:

65,305✔

201

  return code;

65,305✔

204

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

77,418,236✔

205

  int32_t code = 0;

77,418,236✔

208

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

154,836,472✔

209

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

154,836,472✔

210

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

154,836,472✔

212

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

154,836,472✔

213

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

154,836,472✔

214

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

154,836,472✔

215

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

154,836,472✔

217

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

154,836,472✔

218

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

154,836,472✔

219

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

154,836,472✔

220

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

154,836,472✔

221

  if (pTask->pMgmtReq) {

77,418,236✔

222

    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, 1));

130,610✔

223

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

130,610✔

225

    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, 0));

77,287,626✔

228

_exit:

77,287,626✔

230

  return code;

77,418,236✔

234

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

37,105,188✔

235

  int32_t code = 0;

37,105,188✔

238

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

74,210,376✔

239

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

74,210,376✔

240

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

74,210,376✔

242

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

74,210,376✔

243

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

74,210,376✔

244

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

74,210,376✔

245

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

74,210,376✔

247

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

74,210,376✔

248

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

74,210,376✔

249

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

74,210,376✔

250

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

74,210,376✔

251

  int32_t req = 0;

37,105,188✔

252

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &req));

37,105,188✔

253

  if (req) {

37,105,188✔

254

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

65,305✔

255

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

65,305✔

256

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

65,305✔

259

_exit:

37,105,188✔

261

  return code;

37,105,188✔

293

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

4,537,242✔

294

  int32_t code = 0;

4,537,242✔

297

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

9,074,484✔

298

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

9,074,484✔

299

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

9,074,484✔

300

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

9,074,484✔

301

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

9,074,484✔

303

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

4,537,242✔

304

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, recalcNum));

4,537,242✔

305

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

4,537,242✔

310

_exit:

4,537,242✔

312

  return code;

4,537,242✔

315

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

2,136,713✔

316

  int32_t code = 0;

2,136,713✔

319

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

4,273,426✔

320

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

4,273,426✔

321

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

4,273,426✔

322

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

4,273,426✔

323

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

4,273,426✔

325

  int32_t recalcNum = 0;

2,136,713✔

326

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &recalcNum));

2,136,713✔

327

  if (recalcNum > 0) {

2,136,713✔

335

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

2,136,713✔

340

_exit:

2,136,713✔

342

  return code;

2,136,713✔

346

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

33,571,226✔

347

  int32_t code = 0;

33,571,226✔

350

  TAOS_CHECK_EXIT(tStartEncode(pEncoder));

33,571,226✔

351

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

67,142,452✔

352

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

67,142,452✔

353

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

67,142,452✔

354

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

67,142,452✔

356

  int32_t vgLeaderNum = taosArrayGetSize(pReq->pVgLeaders);

33,571,226✔

357

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, vgLeaderNum));

33,571,226✔

358

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

132,337,372✔

359

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

98,766,146✔

360

    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, *vgId));

197,532,292✔

363

  int32_t statusNum = taosArrayGetSize(pReq->pStreamStatus);

33,571,226✔

364

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, statusNum));

33,571,226✔

365

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

106,827,344✔

366

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

73,256,118✔

367

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

73,256,118✔

370

  int32_t reqNum = taosArrayGetSize(pReq->pStreamReq);

33,571,226✔

371

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, reqNum));

33,571,226✔

372

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

33,701,836✔

373

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

130,610✔

374

    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, *idx));

261,220✔

377

  int32_t triggerNum = taosArrayGetSize(pReq->pTriggerStatus);

33,571,226✔

378

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, triggerNum));

33,571,226✔

379

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

38,108,468✔

380

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

4,537,242✔

381

    TAOS_CHECK_EXIT(tEncodeSSTriggerRuntimeStatus(pEncoder, pTrigger));

4,537,242✔

384

  tEndEncode(pEncoder);

33,571,226✔

386

_exit:

33,571,226✔

387

  if (code) {

33,571,226✔

390

    return pEncoder->pos;

33,571,226✔

394

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

16,098,855✔

395

  int32_t code = 0;

16,098,855✔

398

  TAOS_CHECK_EXIT(tStartDecode(pDecoder));

16,098,855✔

399

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

32,197,710✔

400

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

32,197,710✔

401

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

32,197,710✔

402

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

32,197,710✔

404

  int32_t vgLearderNum = 0;

16,098,855✔

405

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgLearderNum));

16,098,855✔

406

  if (vgLearderNum > 0) {

16,098,855✔

407

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

12,609,088✔

408

    if (NULL == pReq->pVgLeaders) {

12,609,088✔

413

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

64,247,125✔

414

    int32_t vgId = 0;

48,148,270✔

415

    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgId));

48,148,270✔

416

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

96,296,540✔

423

  int32_t statusNum = 0;

16,098,855✔

424

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &statusNum));

16,098,855✔

425

  if (statusNum > 0) {

16,098,855✔

426

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

1,073,704✔

427

    if (NULL == pReq->pStreamStatus) {

1,073,704✔

432

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

51,122,356✔

433

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

35,023,501✔

434

    if (NULL == pTask) {

35,023,501✔

438

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

35,023,501✔

442

  int32_t reqNum = 0;

16,098,855✔

443

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &reqNum));

16,098,855✔

444

  if (reqNum > 0) {

16,098,855✔

445

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

20,159✔

446

    if (NULL == pReq->pStreamReq) {

20,159✔

451

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

16,164,160✔

452

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

65,305✔

453

    if (NULL == pIdx) {

65,305✔

457

    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, pIdx));

65,305✔

461

  int32_t triggerNum = 0;

16,098,855✔

462

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &triggerNum));

16,098,855✔

463

  if (triggerNum > 0) {

16,098,855✔

464

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

482,506✔

465

    if (NULL == pReq->pTriggerStatus) {

482,506✔

470

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

18,235,568✔

471

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

2,136,713✔

472

    if (NULL == pStatus) {

2,136,713✔

476

    TAOS_CHECK_EXIT(tDecodeSSTriggerRuntimeStatus(pDecoder, pStatus));

2,136,713✔

480

  tEndDecode(pDecoder);

16,098,855✔

482

_exit:

16,098,855✔

483

  return code;

16,098,855✔

486

void tFreeSSTriggerRuntimeStatus(void* param) {

4,405,334✔

487

  SSTriggerRuntimeStatus* pStatus = (SSTriggerRuntimeStatus*)param;

4,405,334✔

488

  if (NULL == pStatus) {

4,405,334✔

491

  taosArrayDestroy(pStatus->userRecalcs);

4,405,334✔

494

void tCleanupStreamHbMsg(SStreamHbMsg* pMsg, bool deepClean) {

97,579,249✔

495

  if (pMsg == NULL) {

97,579,249✔

499

  taosArrayDestroy(pMsg->pVgLeaders);

97,579,249✔

500

  if (deepClean) {

97,579,249✔

501

    int32_t reqNum = taosArrayGetSize(pMsg->pStreamReq);

97,579,249✔

502

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

97,709,859✔

503

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

130,610✔

504

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

130,610✔

505

      if (NULL == pTask) {

130,610✔

509

      tFreeSStreamMgmtReq(pTask->pMgmtReq);

130,610✔

510

      taosMemoryFree(pTask->pMgmtReq);

130,610✔

513

  taosArrayDestroy(pMsg->pStreamReq);

97,579,249✔

514

  taosArrayDestroy(pMsg->pStreamStatus);

97,579,249✔

515

  taosArrayDestroyEx(pMsg->pTriggerStatus, tFreeSSTriggerRuntimeStatus);

97,579,249✔

518

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

595,720✔

519

  int32_t code = 0;

595,720✔

522

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

1,191,440✔

523

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

1,191,440✔

524

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

1,191,440✔

525

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

1,191,440✔

526

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

1,191,440✔

527

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

1,191,440✔

528

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

1,191,440✔

529

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

1,191,440✔

530

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

1,191,440✔

532

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

1,191,440✔

533

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

1,191,440✔

535

_exit:

595,720✔

537

  return code;

595,720✔

540

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

746,646✔

541

  int32_t code = 0;

746,646✔

544

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

1,493,292✔

545

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

1,493,292✔

547

_exit:

746,646✔

549

  return code;

746,646✔

553

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

1,342,366✔

554

  int32_t code = 0;

1,342,366✔

557

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

2,684,732✔

558

  if (pMsg->triggerReader) {

1,342,366✔

559

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

595,720✔

561

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

746,646✔

564

_exit:

746,646✔

566

  return code;

1,342,366✔

569

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

1,745,792✔

570

  int32_t code = 0;

1,745,792✔

573

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

3,491,584✔

574

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

3,491,584✔

575

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

1,745,792✔

577

_exit:

1,745,792✔

579

  return code;

1,745,792✔

582

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

1,124,778✔

583

  int32_t code = 0;

1,124,778✔

586

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

1,124,778✔

587

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

2,249,556✔

589

_exit:

1,124,778✔

591

  return code;

1,124,778✔

595

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

381,486✔

596

  int32_t code = 0;

381,486✔

599

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

762,972✔

600

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

762,972✔

601

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

762,972✔

602

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

762,972✔

603

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

762,972✔

604

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

762,972✔

605

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

762,972✔

606

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

762,972✔

607

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

762,972✔

608

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

381,486✔

609

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

762,972✔

611

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

381,486✔

612

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, addrSize));

381,486✔

613

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

490,788✔

614

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

109,302✔

615

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

218,604✔

617

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

762,972✔

618

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

762,972✔

619

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

762,972✔

621

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

762,972✔

622

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

762,972✔

623

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

762,972✔

624

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

762,972✔

626

  switch (pMsg->triggerType) {

381,486✔

627

    case WINDOW_TYPE_SESSION: {

16,638✔

629

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

33,276✔

630

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

33,276✔

631

      break;

16,638✔

633

    case WINDOW_TYPE_STATE: {

125,856✔

635

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

251,712✔

636

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

251,712✔

637

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

251,712✔

638

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

251,712✔

639

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

251,712✔

640

      int32_t stateWindowZerothLen =

125,856✔

641

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

125,856✔

642

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

251,712✔

643

      int32_t stateWindowExprLen =

125,856✔

644

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

125,856✔

645

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

251,712✔

646

      break;

125,856✔

648

    case WINDOW_TYPE_INTERVAL: {

143,048✔

650

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

286,096✔

651

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

286,096✔

652

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

286,096✔

653

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

286,096✔

654

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

286,096✔

655

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

286,096✔

656

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

286,096✔

657

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

286,096✔

658

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

286,096✔

659

      break;

143,048✔

661

    case WINDOW_TYPE_EVENT: {

47,400✔

663

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

47,400✔

664

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

47,400✔

666

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

94,800✔

667

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

94,800✔

668

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

94,800✔

669

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

94,800✔

670

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

94,800✔

671

      break;

47,400✔

673

    case WINDOW_TYPE_COUNT: {

34,014✔

675

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

34,014✔

676

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

68,028✔

678

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

68,028✔

679

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

68,028✔

680

      break;

34,014✔

682

    case WINDOW_TYPE_PERIOD: {

14,530✔

684

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

29,060✔

685

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

29,060✔

686

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

29,060✔

687

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

29,060✔

688

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

29,060✔

689

      break;

14,530✔

696

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

762,972✔

697

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

762,972✔

698

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

762,972✔

699

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

762,972✔

700

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

762,972✔

701

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

762,972✔

702

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

381,486✔

703

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

762,972✔

704

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

381,486✔

705

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

762,972✔

706

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

381,486✔

707

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

762,972✔

709

  int32_t readerNum = taosArrayGetSize(pMsg->readerList);

381,486✔

710

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, readerNum));

381,486✔

711

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

854,548✔

712

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

473,062✔

713

    TAOS_CHECK_EXIT(tEncodeSStreamTaskAddr(pEncoder, pAddr));

473,062✔

716

  int32_t runnerNum = taosArrayGetSize(pMsg->runnerList);

381,486✔

717

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, runnerNum));

381,486✔

718

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

1,506,264✔

719

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

1,124,778✔

720

    TAOS_CHECK_EXIT(tEncodeSStreamRunnerTarget(pEncoder, pTarget));

1,124,778✔

723

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

762,972✔

724

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

762,972✔

725

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

762,972✔

727

_exit:

381,486✔

729

  return code;

381,486✔

733

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

6,517,836✔

734

  int32_t code = 0;

6,517,836✔

737

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

13,035,672✔

738

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

13,035,672✔

739

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

13,035,672✔

740

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

13,035,672✔

741

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

13,035,672✔

742

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

13,035,672✔

744

_exit:

6,517,836✔

746

  return code;

6,517,836✔

750

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

1,325,208✔

751

  int32_t code = 0;

1,325,208✔

754

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

2,650,416✔

755

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

2,650,416✔

756

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

2,650,416✔

757

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

2,650,416✔

758

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

2,650,416✔

759

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

2,650,416✔

760

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

2,650,416✔

761

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

2,650,416✔

763

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

1,325,208✔

764

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, addrSize));

1,325,208✔

765

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

1,633,434✔

766

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

308,226✔

767

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

616,452✔

769

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

2,650,416✔

771

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

1,325,208✔

772

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, outColNum));

1,325,208✔

773

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

6,778,104✔

774

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

5,452,896✔

775

    TAOS_CHECK_EXIT(tSerializeSFieldWithOptions(pEncoder, pCol));

5,452,896✔

778

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

1,325,208✔

779

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, outTagNum));

1,325,208✔

780

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

2,390,148✔

781

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

1,064,940✔

782

    TAOS_CHECK_EXIT(tSerializeSFieldWithOptions(pEncoder, pTag));

1,064,940✔

785

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

2,650,416✔

786

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

2,650,416✔

788

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

2,650,416✔

789

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

2,650,416✔

791

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

1,325,208✔

792

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, forceOutColsSize));

1,325,208✔

793

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

1,455,828✔

794

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

130,620✔

795

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

130,620✔

797

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

261,240✔

798

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

261,240✔

799

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

261,240✔

800

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

261,240✔

801

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

261,240✔

804

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

2,650,416✔

807

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

1,325,208✔

808

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, colCidsSize));

1,325,208✔

809

  if (colCidsSize > 0) {

1,325,208✔

810

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

75,642✔

811

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

57,174✔

812

      TAOS_CHECK_EXIT(tEncodeI16(pEncoder, *pCid));

114,348✔

816

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

1,325,208✔

817

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, tagCidsSize));

1,325,208✔

818

  if (tagCidsSize > 0) {

1,325,208✔

819

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

37,386✔

820

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

22,896✔

821

      TAOS_CHECK_EXIT(tEncodeI16(pEncoder, *pCid));

45,792✔

825

_exit:

1,325,208✔

827

  return code;

1,325,208✔

830

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

3,049,060✔

831

  int32_t code = 0;

3,049,060✔

834

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

3,049,060✔

835

  switch (pTask->task.type) {

3,049,060✔

836

    case STREAM_READER_TASK:

1,342,366✔

837

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

1,342,366✔

838

      break;

1,342,366✔

839

    case STREAM_TRIGGER_TASK:

381,486✔

840

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

381,486✔

841

      break;

381,486✔

842

    case STREAM_RUNNER_TASK:

1,325,208✔

843

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

1,325,208✔

844

      break;

1,325,208✔

850

_exit:

3,049,060✔

852

  return code;

3,049,060✔

856

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

522,390✔

857

  int32_t code = 0;

522,390✔

860

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

1,044,780✔

862

  int32_t readerNum = taosArrayGetSize(pStream->readerTasks);

522,390✔

863

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, readerNum));

522,390✔

864

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

1,864,756✔

865

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

1,342,366✔

866

    TAOS_CHECK_EXIT(tEncodeSStmTaskDeploy(pEncoder, pDeploy));

1,342,366✔

869

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

1,044,780✔

870

  if (pStream->triggerTask) {

522,390✔

871

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

381,486✔

874

  int32_t runnerNum = taosArrayGetSize(pStream->runnerTasks);

522,390✔

875

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, runnerNum));

522,390✔

876

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

1,847,598✔

877

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

1,325,208✔

878

    TAOS_CHECK_EXIT(tEncodeSStmTaskDeploy(pEncoder, pDeploy));

1,325,208✔

881

_exit:

522,390✔

883

  return code;

522,390✔

886

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

1,113,058✔

887

  int32_t code = 0;

1,113,058✔

888

  int32_t lino = 0;

1,113,058✔

890

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

2,226,116✔

892

_exit:

1,113,058✔

893

  return code;

1,113,058✔

896

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

556,715✔

897

  int32_t code = 0;

556,715✔

900

  int32_t type = 0;

556,715✔

901

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &type));

556,715✔

902

  pMsg->msgType = type;

556,715✔

904

_exit:

556,715✔

905

  return code;

556,715✔

908

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

500,778✔

909

  int32_t code = 0;

500,778✔

912

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

500,778✔

914

_exit:

500,778✔

916

  return code;

500,778✔

919

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

500,778✔

920

  int32_t code = 0;

500,778✔

923

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

500,778✔

924

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

500,778✔

926

_exit:

500,778✔

928

  return code;

500,778✔

931

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

474,942✔

932

  int32_t code = 0;

474,942✔

935

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

474,942✔

936

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

949,884✔

937

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

949,884✔

939

_exit:

474,942✔

941

  return code;

474,942✔

944

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

474,942✔

945

  int32_t code = 0;

474,942✔

948

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

474,942✔

949

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

474,942✔

951

_exit:

474,942✔

953

  return code;

474,942✔

957

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

6,728✔

958

  int32_t code = 0;

6,728✔

961

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

13,456✔

962

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

13,456✔

963

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

13,456✔

965

_exit:

6,728✔

967

  return code;

6,728✔

970

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

137,338✔

971

  int32_t code = 0;

137,338✔

974

  switch (msgType) {

137,338✔

975

    case STREAM_MSG_ORIGTBL_READER_INFO: {

125,726✔

976

      int32_t vgNum = taosArrayGetSize(pRsp->vgIds);

125,726✔

977

      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, vgNum));

125,726✔

979

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

495,418✔

980

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

369,692✔

981

        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, *vgId));

739,384✔

984

      int32_t readerNum = taosArrayGetSize(pRsp->readerList);

125,726✔

985

      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, readerNum));

125,726✔

987

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

247,790✔

988

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

122,064✔

989

        TAOS_CHECK_EXIT(tEncodeSStreamTaskAddr(pEncoder, addr));

122,064✔

991

      break;

125,726✔

1003

    case STREAM_MSG_USER_RECALC: {

6,728✔

1004

      int32_t recalcNum = taosArrayGetSize(pRsp->recalcList);

6,728✔

1005

      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, recalcNum));

6,728✔

1007

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

13,456✔

1008

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

6,728✔

1009

        TAOS_CHECK_EXIT(tEncodeSStreamRecalcReq(pEncoder, recalc));

6,728✔

1011

      break;

6,728✔

1013

    case STREAM_MSG_RUNNER_ORIGTBL_READER: {

4,884✔

1014

      int32_t rspNum = taosArrayGetSize(pRsp->execRspList);

4,884✔

1015

      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, rspNum));

4,884✔

1017

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

9,768✔

1018

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

4,884✔

1019

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

9,768✔

1020

        int32_t vgNum = taosArrayGetSize(pDeployRsp->vgList);

4,884✔

1021

        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, vgNum));

4,884✔

1022

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

9,768✔

1023

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

4,884✔

1026

      break;

4,884✔

1032

_exit:

137,338✔

1034

  return code;

137,338✔

1037

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

137,338✔

1038

  int32_t code = 0;

137,338✔

1041

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

137,338✔

1042

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

274,676✔

1043

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

274,676✔

1044

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

137,338✔

1045

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

137,338✔

1047

_exit:

137,338✔

1049

  return code;

137,338✔

1053

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

31,913,930✔

1054

  int32_t code = 0;

31,913,930✔

1057

  TAOS_CHECK_EXIT(tStartEncode(pEncoder));

31,913,930✔

1058

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

63,827,860✔

1059

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

31,913,930✔

1060

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, deployNum));

31,913,930✔

1061

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

32,436,320✔

1062

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

522,390✔

1063

    TAOS_CHECK_EXIT(tEncodeSStmStreamDeploy(pEncoder, pStream));

522,390✔

1066

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

31,913,930✔

1067

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, startNum));

31,913,930✔

1068

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

32,414,708✔

1069

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

500,778✔

1070

    TAOS_CHECK_EXIT(tEncodeSStreamTaskStart(pEncoder, pTask));

500,778✔

1073

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

63,827,860✔

1074

  if (!pRsp->undeploy.undeployAll) {

31,913,930✔

1075

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

31,913,930✔

1076

    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, undeployNum));

31,913,930✔

1077

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

32,388,872✔

1078

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

474,942✔

1079

      TAOS_CHECK_EXIT(tEncodeSStreamTaskUndeploy(pEncoder, pTask));

474,942✔

1083

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

31,913,930✔

1084

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, rspNum));

31,913,930✔

1085

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

32,051,268✔

1086

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

137,338✔

1087

    TAOS_CHECK_EXIT(tEncodeSStreamMgmtRsp(pEncoder, pMgmtRsp));

137,338✔

1090

_exit:

31,913,930✔

1092

  tEndEncode(pEncoder);

31,913,930✔

1094

  return code;

31,913,930✔

1097

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

297,924✔

1098

  int32_t code = 0;

297,924✔

1101

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

595,848✔

1102

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

595,848✔

1103

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

595,848✔

1104

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

595,848✔

1105

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

595,848✔

1106

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

595,848✔

1107

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

595,848✔

1108

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

595,848✔

1109

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

595,848✔

1110

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

595,848✔

1111

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

595,848✔

1113

_exit:

297,924✔

1115

  return code;

297,924✔

1119

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

373,380✔

1120

  int32_t code = 0;

373,380✔

1123

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

746,760✔

1124

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

746,760✔

1126

_exit:

373,380✔

1128

  return code;

373,380✔

1132

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

671,304✔

1133

  int32_t code = 0;

671,304✔

1136

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

1,342,608✔

1137

  if (pMsg->triggerReader) {

671,304✔

1138

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

297,924✔

1140

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

373,380✔

1143

_exit:

373,380✔

1145

  return code;

671,304✔

1149

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

873,294✔

1150

  int32_t code = 0;

873,294✔

1153

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

1,746,588✔

1154

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

1,746,588✔

1155

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

873,294✔

1157

_exit:

873,294✔

1159

  return code;

873,294✔

1163

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

562,590✔

1164

  int32_t code = 0;

562,590✔

1167

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

562,590✔

1168

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

1,125,180✔

1170

_exit:

562,590✔

1172

  return code;

562,590✔

1176

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

190,810✔

1177

  int32_t code = 0;

190,810✔

1180

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

381,620✔

1181

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

381,620✔

1182

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

381,620✔

1183

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

381,620✔

1184

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

381,620✔

1185

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

381,620✔

1186

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

381,620✔

1187

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

381,620✔

1188

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

381,620✔

1189

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

381,620✔

1191

  int32_t addrSize = 0;

190,810✔

1192

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &addrSize));

190,810✔

1193

  if (addrSize > 0) {

190,810✔

1194

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

54,651✔

1195

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

54,651✔

1197

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

245,461✔

1198

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

54,651✔

1199

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

54,651✔

1201

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

381,620✔

1202

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

381,620✔

1203

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

381,620✔

1205

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

381,620✔

1206

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

381,620✔

1207

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

381,620✔

1208

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

381,620✔

1210

  switch (pMsg->triggerType) {

190,810✔

1211

    case WINDOW_TYPE_SESSION:

8,319✔

1213

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

16,638✔

1214

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

16,638✔

1215

      break;

8,319✔

1216

    case WINDOW_TYPE_STATE:

62,928✔

1218

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

125,856✔

1219

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

125,856✔

1220

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

125,856✔

1221

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

125,856✔

1222

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

125,856✔

1223

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

125,856✔

1224

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

125,856✔

1225

      break;

62,928✔

1227

    case WINDOW_TYPE_INTERVAL:

71,579✔

1229

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

143,158✔

1230

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

143,158✔

1231

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

143,158✔

1232

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

143,158✔

1233

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

143,158✔

1234

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

143,158✔

1235

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

143,158✔

1236

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

143,158✔

1237

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

143,158✔

1238

      break;

71,579✔

1240

    case WINDOW_TYPE_EVENT:

23,700✔

1242

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

47,400✔

1243

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

47,400✔

1244

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

47,400✔

1245

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

47,400✔

1246

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

47,400✔

1247

      break;

23,700✔

1249

    case WINDOW_TYPE_COUNT:

17,019✔

1251

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

34,038✔

1253

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

34,038✔

1254

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

34,038✔

1255

      break;

17,019✔

1257

    case WINDOW_TYPE_PERIOD:

7,265✔

1259

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

14,530✔

1260

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

14,530✔

1261

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

14,530✔

1262

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

14,530✔

1263

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

14,530✔

1264

      break;

7,265✔

1270

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

381,620✔

1271

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

381,620✔

1272

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

381,620✔

1273

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

381,620✔

1274

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

381,620✔

1275

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

381,620✔

1276

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

381,620✔

1277

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

381,620✔

1278

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

381,620✔

1280

  int32_t readerNum = 0;

190,810✔

1281

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &readerNum));

190,810✔

1282

  if (readerNum > 0) {

190,810✔

1283

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

189,815✔

1284

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

189,815✔

1286

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

427,449✔

1287

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

236,639✔

1288

    TAOS_CHECK_EXIT(tDecodeSStreamTaskAddr(pDecoder, pAddr));

236,639✔

1291

  int32_t runnerNum = 0;

190,810✔

1292

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &runnerNum));

190,810✔

1293

  if (runnerNum > 0) {

190,810✔

1294

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

187,530✔

1295

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

187,530✔

1297

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

753,400✔

1298

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

562,590✔

1299

    TAOS_CHECK_EXIT(tDecodeSStreamRunnerTarget(pDecoder, pTarget));

562,590✔

1302

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

381,620✔

1303

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

381,620✔

1304

  if (!tDecodeIsEnd(pDecoder)) {

190,810✔

1305

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

381,620✔

1308

_exit:

190,810✔

1310

  return code;

190,810✔

1315

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

3,259,794✔

1316

  int32_t code = 0;

3,259,794✔

1319

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

3,259,794✔

1320

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

6,519,588✔

1321

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

6,519,588✔

1322

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

6,519,588✔

1323

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

6,519,588✔

1324

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

6,519,588✔

1326

_exit:

3,259,794✔

1328

  return code;

3,259,794✔

1331

void destroySStreamOutCols(void* p){

65,310✔

1332

  if (p == NULL) return;

65,310✔

1333

  SStreamOutCol* col = (SStreamOutCol*)p;

65,310✔

1334

  taosMemoryFreeClear(col->expr);

65,310✔

1337

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

662,858✔

1338

  int32_t code = 0;

662,858✔

1341

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

1,325,716✔

1342

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

1,325,716✔

1343

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

1,325,716✔

1344

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

1,325,716✔

1345

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

1,325,716✔

1346

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

1,325,716✔

1347

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

1,325,716✔

1348

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

1,325,716✔

1350

  int32_t addrSize = 0;

662,858✔

1351

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &addrSize));

662,858✔

1352

  if (addrSize > 0) {

662,858✔

1353

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

154,113✔

1354

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

154,113✔

1356

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

816,971✔

1357

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

154,113✔

1358

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

154,113✔

1360

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

1,325,716✔

1362

  int32_t outColNum = 0;

662,858✔

1363

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &outColNum));

662,858✔

1364

  if (outColNum > 0) {

662,858✔

1365

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

662,858✔

1366

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

662,858✔

1368

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

3,389,977✔

1369

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

2,727,119✔

1370

    TAOS_CHECK_EXIT(tDeserializeSFieldWithOptions(pDecoder, pCol));

2,727,119✔

1373

  int32_t outTagNum = 0;

662,858✔

1374

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &outTagNum));

662,858✔

1375

  if (outTagNum > 0) {

662,858✔

1376

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

275,896✔

1377

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

275,896✔

1379

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

1,195,533✔

1380

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

532,675✔

1381

    TAOS_CHECK_EXIT(tDeserializeSFieldWithOptions(pDecoder, pTag));

532,675✔

1384

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

1,325,716✔

1385

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

1,325,716✔

1387

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

1,325,716✔

1388

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

1,325,716✔

1390

  int32_t forceOutColsSize = 0;

662,858✔

1391

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &forceOutColsSize));

662,858✔

1392

  if (forceOutColsSize > 0) {

662,858✔

1393

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

11,853✔

1394

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

11,853✔

1396

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

728,168✔

1397

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

65,310✔

1399

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

130,620✔

1400

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

130,620✔

1401

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

130,620✔

1402

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

130,620✔

1403

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

130,620✔

1406

  if (!tDecodeIsEnd(pDecoder)) {

662,858✔

1407

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

1,325,716✔

1412

  if (!tDecodeIsEnd(pDecoder)) {

662,858✔

1413

    int32_t colCidsSize = 0;

662,858✔

1414

    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &colCidsSize));

662,858✔

1415

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

662,858✔

1416

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

9,234✔

1417

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

9,234✔

1418

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

37,821✔

1419

        int16_t cid = 0;

28,587✔

1420

        TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &cid));

28,587✔

1421

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

57,174✔

1428

  if (!tDecodeIsEnd(pDecoder)) {

662,858✔

1429

    int32_t tagCidsSize = 0;

662,858✔

1430

    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &tagCidsSize));

662,858✔

1431

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

662,858✔

1432

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

7,245✔

1433

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

7,245✔

1434

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

18,693✔

1435

        int16_t cid = 0;

11,448✔

1436

        TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &cid));

11,448✔

1437

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

22,896✔

1444

_exit:

661,442✔

1446

  return code;

662,858✔

1449

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

1,524,972✔

1450

  int32_t code = 0;

1,524,972✔

1453

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

1,524,972✔

1454

  switch (pTask->task.type) {

1,524,972✔

1455

    case STREAM_READER_TASK:

671,304✔

1456

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

671,304✔

1457

      break;

671,304✔

1458

    case STREAM_TRIGGER_TASK:

190,810✔

1459

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

190,810✔

1460

      break;

190,810✔

1461

    case STREAM_RUNNER_TASK:

662,858✔

1462

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

662,858✔

1463

      break;

662,858✔

1469

_exit:

1,524,972✔

1471

  return code;

1,524,972✔

1475

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

261,321✔

1476

  int32_t code = 0;

261,321✔

1479

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

522,642✔

1481

  int32_t readerNum = 0;

261,321✔

1482

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &readerNum));

261,321✔

1483

  if (readerNum > 0) {

261,321✔

1484

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

249,129✔

1485

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

249,129✔

1487

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

932,625✔

1488

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

671,304✔

1489

    TAOS_CHECK_EXIT(tDecodeSStmTaskDeploy(pDecoder, pTask));

671,304✔

1492

  int32_t triggerTask = 0;

261,321✔

1493

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &triggerTask));

261,321✔

1494

  if (triggerTask) {

261,321✔

1495

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

190,810✔

1496

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

190,810✔

1497

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

190,810✔

1500

  int32_t runnerNum = 0;

261,321✔

1501

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &runnerNum));

261,321✔

1502

  if (runnerNum > 0) {

261,321✔

1503

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

195,594✔

1504

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

195,594✔

1506

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

924,179✔

1507

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

662,858✔

1508

    TAOS_CHECK_EXIT(tDecodeSStmTaskDeploy(pDecoder, pTask));

662,858✔

1511

_exit:

261,321✔

1513

  return code;

261,321✔

1517

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

250,444✔

1518

  int32_t code = 0;

250,444✔

1521

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

250,444✔

1523

_exit:

250,444✔

1525

  return code;

250,444✔

1529

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

250,444✔

1530

  int32_t code = 0;

250,444✔

1533

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

250,444✔

1534

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

250,444✔

1536

_exit:

250,444✔

1538

  return code;

250,444✔

1542

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

237,602✔

1543

  int32_t code = 0;

237,602✔

1546

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

237,602✔

1547

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

475,204✔

1548

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

475,204✔

1550

_exit:

237,602✔

1552

  return code;

237,602✔

1556

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

237,602✔

1557

  int32_t code = 0;

237,602✔

1560

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

237,602✔

1561

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

237,602✔

1563

_exit:

237,602✔

1565

  return code;

237,602✔

1568

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

3,364✔

1569

  int32_t code = 0;

3,364✔

1572

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

6,728✔

1573

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

6,728✔

1574

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

6,728✔

1576

_exit:

3,364✔

1578

  return code;

3,364✔

1581

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

68,669✔

1582

  int32_t code = 0;

68,669✔

1585

  switch (msgType) {

68,669✔

1586

    case STREAM_MSG_ORIGTBL_READER_INFO: {

62,863✔

1587

      int32_t vgNum = 0;

62,863✔

1588

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgNum));

62,863✔

1589

      if (vgNum > 0) {

62,863✔

1590

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

62,863✔

1591

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

62,863✔

1593

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

247,709✔

1594

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

184,846✔

1595

        TAOS_CHECK_EXIT(tDecodeI32(pDecoder, vgId));

184,846✔

1598

      int32_t readerNum = 0;

62,863✔

1599

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &readerNum));

62,863✔

1600

      if (readerNum > 0) {

62,863✔

1601

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

52,974✔

1602

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

52,974✔

1604

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

123,895✔

1605

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

61,032✔

1606

        TAOS_CHECK_EXIT(tDecodeSStreamTaskAddr(pDecoder, addr));

61,032✔

1608

      break;

62,863✔

1623

    case STREAM_MSG_USER_RECALC: {

3,364✔

1624

      int32_t recalcNum = 0;

3,364✔

1625

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &recalcNum));

3,364✔

1626

      if (recalcNum > 0) {

3,364✔

1627

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

3,364✔

1628

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

3,364✔

1630

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

6,728✔

1631

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

3,364✔

1632

        TAOS_CHECK_EXIT(tDecodeSStreamRecalcReq(pDecoder, recalc));

3,364✔

1634

      break;

3,364✔

1636

    case STREAM_MSG_RUNNER_ORIGTBL_READER: {

2,442✔

1637

      int32_t rspNum = 0, vgNum = 0;

2,442✔

1638

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &rspNum));

2,442✔

1639

      if (rspNum > 0) {

2,442✔

1640

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

2,442✔

1641

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

2,442✔

1643

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

4,884✔

1644

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

2,442✔

1645

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

4,884✔

1646

        TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgNum));

2,442✔

1647

        if (vgNum > 0) {

2,442✔

1648

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

2,442✔

1649

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

2,442✔

1651

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

4,884✔

1652

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

2,442✔

1653

          TAOS_CHECK_EXIT(tDecodeSStreamTaskAddr(pDecoder, pAddr));

2,442✔

1656

      break;

2,442✔

1662

_exit:

68,669✔

1664

  return code;

68,669✔

1668

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

68,669✔

1669

  int32_t code = 0;

68,669✔

1672

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

68,669✔

1673

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

137,338✔

1674

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

137,338✔

1675

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

68,669✔

1676

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

68,669✔

1678

_exit:

68,669✔

1680

  return code;

68,669✔

1683

void tFreeSStreamOReaderDeployRsp(void* param) {

4,884✔

1684

  if (NULL == param) {

4,884✔

1688

  SStreamOReaderDeployRsp* pRsp = (SStreamOReaderDeployRsp*)param;

4,884✔

1689

  taosArrayDestroy(pRsp->vgList);

4,884✔

1692

void tFreeSStreamMgmtRsp(void* param) {

137,338✔

1693

  if (NULL == param) {

137,338✔

1697

  SStreamMgmtRsp* pRsp = (SStreamMgmtRsp*)param;

137,338✔

1699

  taosArrayDestroy(pRsp->cont.vgIds);

137,338✔

1700

  taosArrayDestroy(pRsp->cont.readerList);

137,338✔

1701

  taosArrayDestroy(pRsp->cont.runnerList);

137,338✔

1702

  taosArrayDestroy(pRsp->cont.recalcList);

137,338✔

1703

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

137,338✔

1706

void tFreeSStreamReaderDeployMsg(SStreamReaderDeployMsg* pReader) {

671,304✔

1707

  if (NULL == pReader) {

671,304✔

1711

  if (pReader->triggerReader) {

671,304✔

1712

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

297,924✔

1713

    taosMemoryFree(pMsg->triggerTblName);

297,924✔

1714

    taosMemoryFree(pMsg->partitionCols);

297,924✔

1715

    taosMemoryFree(pMsg->triggerCols);

297,924✔

1716

    taosMemoryFree(pMsg->triggerScanPlan);

297,924✔

1717

    taosMemoryFree(pMsg->calcCacheScanPlan);

297,924✔

1719

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

373,380✔

1720

    taosMemoryFree(pMsg->calcScanPlan);

373,380✔

1732

void tFreeSStreamTriggerDeployMsg(SStreamTriggerDeployMsg* pTrigger) {

190,810✔

1733

  if (NULL == pTrigger) {

190,810✔

1737

  taosArrayDestroyEx(pTrigger->pNotifyAddrUrls, tFreeStreamNotifyUrl);

190,810✔

1738

  switch (pTrigger->triggerType) {

190,810✔

1739

    case WINDOW_TYPE_STATE:

62,928✔

1740

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

62,928✔

1741

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

62,928✔

1742

      break;

62,928✔

1743

    case WINDOW_TYPE_EVENT:

23,700✔

1744

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

23,700✔

1745

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

23,700✔

1746

      break;

23,700✔

1747

    case WINDOW_TYPE_COUNT:

17,019✔

1748

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

17,019✔

1749

      break;

17,019✔

1750

    default:

87,163✔

1751

      break;

87,163✔

1754

  taosMemoryFree(pTrigger->partitionCols);

190,810✔

1755

  taosMemoryFree(pTrigger->triggerPrevFilter);

190,810✔

1756

  taosMemoryFree(pTrigger->triggerScanPlan);

190,810✔

1757

  taosMemoryFree(pTrigger->calcCacheScanPlan);

190,810✔

1759

  taosArrayDestroy(pTrigger->readerList);

190,810✔

1760

  taosArrayDestroy(pTrigger->runnerList);

190,810✔

1761

  taosMemoryFree(pTrigger->streamName);

190,810✔

1773

void tFreeSStreamRunnerDeployMsg(SStreamRunnerDeployMsg* pRunner) {

662,858✔

1774

  if (NULL == pRunner) {

662,858✔

1778

  taosMemoryFree(pRunner->streamName);

662,858✔

1779

  taosMemoryFree(pRunner->pPlan);

662,858✔

1780

  taosMemoryFree(pRunner->outDBFName);

662,858✔

1781

  taosMemoryFree(pRunner->outTblName);

662,858✔

1783

  taosArrayDestroyEx(pRunner->pNotifyAddrUrls, tFreeStreamNotifyUrl);

662,858✔

1784

  taosArrayDestroy(pRunner->outCols);

662,858✔

1785

  taosArrayDestroy(pRunner->outTags);

662,858✔

1787

  taosMemoryFree(pRunner->subTblNameExpr);

662,858✔

1788

  taosMemoryFree(pRunner->tagValueExpr);

662,858✔

1789

  taosArrayDestroyEx(pRunner->forceOutCols, tFreeSStreamOutCol);

662,858✔

1792

void tFreeSStmTaskDeploy(void* param) {

1,856,678✔

1793

  if (NULL == param) {

1,856,678✔

1794

    return;

331,706✔

1797

  SStmTaskDeploy* pTask = (SStmTaskDeploy*)param;

1,524,972✔

1798

  switch (pTask->task.type)  {

1,524,972✔

1799

    case STREAM_READER_TASK:

671,304✔

1800

      tFreeSStreamReaderDeployMsg(&pTask->msg.reader);

671,304✔

1801

      break;

671,304✔

1802

    case STREAM_TRIGGER_TASK:

190,810✔

1803

      tFreeSStreamTriggerDeployMsg(&pTask->msg.trigger);

190,810✔

1804

      break;

190,810✔

1805

    case STREAM_RUNNER_TASK:

662,858✔

1806

      tFreeSStreamRunnerDeployMsg(&pTask->msg.runner);

662,858✔

1807

      break;

662,858✔

1814

void tFreeSStmStreamDeploy(void* param) {

261,195✔

1815

  if (NULL == param) {

261,195✔

1819

  SStmStreamDeploy* pDeploy = (SStmStreamDeploy*)param;

261,195✔

1820

  int32_t readerNum = taosArrayGetSize(pDeploy->readerTasks);

261,195✔

1821

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

932,378✔

1822

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

671,183✔

1823

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

671,183✔

1824

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

369,582✔

1827

  taosArrayDestroy(pDeploy->readerTasks);

261,195✔

1829

  if (pDeploy->triggerTask) {

261,195✔

1830

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

190,743✔

1831

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

190,743✔

1832

    taosMemoryFree(pDeploy->triggerTask);

190,743✔

1835

  int32_t runnerNum = taosArrayGetSize(pDeploy->runnerTasks);

261,195✔

1836

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

923,799✔

1837

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

662,604✔

1838

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

662,604✔

1840

  taosArrayDestroy(pDeploy->runnerTasks);

261,195✔

1843

void tDeepFreeSStmStreamDeploy(void* param) {

522,516✔

1844

  if (NULL == param) {

522,516✔

1848

  SStmStreamDeploy* pDeploy = (SStmStreamDeploy*)param;

522,516✔

1849

  taosArrayDestroyEx(pDeploy->readerTasks, tFreeSStmTaskDeploy);

522,516✔

1850

  tFreeSStmTaskDeploy(pDeploy->triggerTask);

522,516✔

1851

  taosMemoryFree(pDeploy->triggerTask);

522,516✔

1852

  taosArrayDestroyEx(pDeploy->runnerTasks, tFreeSStmTaskDeploy);

522,516✔

1856

void tFreeSMStreamHbRspMsg(SMStreamHbRspMsg* pRsp) {

32,197,710✔

1857

  if (NULL == pRsp) {

32,197,710✔

1860

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

32,197,710✔

1861

  taosArrayDestroy(pRsp->start.taskList);

32,197,710✔

1862

  taosArrayDestroy(pRsp->undeploy.taskList);

32,197,710✔

1863

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

32,197,710✔

1866

void tDeepFreeSMStreamHbRspMsg(SMStreamHbRspMsg* pRsp) {

15,884,967✔

1867

  if (NULL == pRsp) {

15,884,967✔

1870

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

15,884,967✔

1871

  taosArrayDestroy(pRsp->start.taskList);

15,884,967✔

1872

  taosArrayDestroy(pRsp->undeploy.taskList);

15,884,967✔

1873

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

15,884,967✔

1878

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

15,884,967✔

1879

  int32_t code = 0;

15,884,967✔

1882

  TAOS_CHECK_EXIT(tStartDecode(pDecoder));

15,884,967✔

1883

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

31,769,934✔

1884

  int32_t deployNum = 0;

15,884,967✔

1885

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &deployNum));

15,884,967✔

1886

  if (deployNum > 0) {

15,884,967✔

1887

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

68,484✔

1888

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

68,484✔

1890

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

16,146,288✔

1891

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

261,321✔

1892

    TAOS_CHECK_EXIT(tDecodeSStmStreamDeploy(pDecoder, pStream));

261,321✔

1895

  int32_t startNum = 0;

15,884,967✔

1896

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &startNum));

15,884,967✔

1897

  if (startNum > 0) {

15,884,967✔

1898

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

104,757✔

1899

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

104,757✔

1901

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

16,135,411✔

1902

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

250,444✔

1903

    TAOS_CHECK_EXIT(tDecodeSStreamTaskStart(pDecoder, pTask));

250,444✔

1906

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

31,769,934✔

1907

  if (!pRsp->undeploy.undeployAll) {

15,884,967✔

1908

    int32_t undeployNum = 0;

15,884,967✔

1909

    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &undeployNum));

15,884,967✔

1910

    if (undeployNum > 0) {

15,884,967✔

1911

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

32,906✔

1912

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

32,906✔

1914

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

16,122,569✔

1915

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

237,602✔

1916

      TAOS_CHECK_EXIT(tDecodeSStreamTaskUndeploy(pDecoder, pTask));

237,602✔

1920

  int32_t rspNum = 0;

15,884,967✔

1921

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &rspNum));

15,884,967✔

1922

  if (rspNum > 0) {

15,884,967✔

1923

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

23,324✔

1924

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

23,324✔

1925

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

91,993✔

1926

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

68,669✔

1927

      TAOS_CHECK_EXIT(tDecodeSStreamMgmtRsp(pDecoder, pMgmtRsp));

68,669✔

1931

  tEndDecode(pDecoder);

15,884,967✔

1933

_exit:

15,884,967✔

1934

  return code;

15,884,967✔

1991

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

1,461,134✔

1992

  int32_t code = TSDB_CODE_SUCCESS;

1,461,134✔

1993

  int32_t lino = 0;

1,461,134✔

1995

  char*   json = NULL;

1,461,134✔

1996

  int32_t jsonLen = 0;

1,461,134✔

1997

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

1,461,134✔

1998

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

2,922,268✔

2000

_exit:

1,461,134✔

2001

  taosMemoryFreeClear(json);

1,461,134✔

2002

  if (code) {

1,461,134✔

2006

  return 0;

1,461,134✔

2009

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

683,468✔

2010

  SEncoder encoder = {0};

683,468✔

2011

  tEncoderInit(&encoder, buf, bufLen);

683,468✔

2012

  int32_t code = 0;

683,468✔

2015

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

683,468✔

2017

  TAOS_CHECK_EXIT(tSerializeSCMCreateStreamReqImpl(&encoder, pReq));

683,468✔

2019

  tEndEncode(&encoder);

683,468✔

2021

_exit:

683,468✔

2022

  if (code) {

683,468✔

2026

    int32_t tlen = encoder.pos;

683,468✔

2027

    tEncoderClear(&encoder);

683,468✔

2028

    return tlen;

683,468✔

2326

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

451,592✔

2327

  int32_t code = 0;

451,592✔

2330

  char* json = NULL;

451,592✔

2331

  SJson* pJson = NULL;

451,592✔

2332

  TAOS_CHECK_EXIT(tDecodeCStrAlloc(pDecoder, &json));

451,592✔

2333

  pJson = tjsonParse(json);

451,592✔

2334

  if (pJson == NULL) {

451,592✔

2337

  TAOS_CHECK_EXIT(jsonToSCMCreateStreamReq(pJson, pReq));

451,592✔

2339

_exit:

451,592✔

2340

  taosMemoryFreeClear(json);

451,592✔

2341

  if (NULL != pJson) {

451,592✔

2342

    tjsonDelete(pJson);

451,592✔

2345

  return code;

451,592✔

2349

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

221,825✔

2350

  SDecoder decoder = {0};

221,825✔

2351

  tDecoderInit(&decoder, buf, bufLen);

221,825✔

2352

  int32_t code = 0;

221,825✔

2355

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

221,825✔

2357

  code = tDeserializeSCMCreateStreamReqImpl(&decoder, pReq);

221,825✔

2358

  if (TSDB_CODE_MND_STREAM_INVALID_JSON == code) {

221,825✔

2367

  tEndDecode(&decoder);

221,825✔

2369

_exit:

221,825✔

2371

  tDecoderClear(&decoder);

221,825✔

2372

  return code;

221,825✔

2376

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

47,434✔

2377

  int32_t  code = 0;

47,434✔

2380

  SEncoder encoder = {0};

47,434✔

2381

  tEncoderInit(&encoder, buf, bufLen);

47,434✔

2383

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

47,434✔

2385

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

94,868✔

2386

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

101,156✔

2387

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

53,722✔

2388

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

107,444✔

2390

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

94,868✔

2392

  tEndEncode(&encoder);

47,434✔

2394

_exit:

47,434✔

2395

  if (code) {

47,434✔

2398

    tlen = encoder.pos;

47,434✔

2400

  tEncoderClear(&encoder);

47,434✔

2401

  return tlen;

47,434✔

2404

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

18,121✔

2405

  SDecoder decoder = {0};

18,121✔

2406

  int32_t  code = 0;

18,121✔

2408

  tDecoderInit(&decoder, buf, bufLen);

18,121✔

2410

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

18,121✔

2411

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

36,242✔

2412

  if (pReq->count > 0) {

18,121✔

2413

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

18,121✔

2414

    if (pReq->name == NULL) {

18,121✔

2418

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

39,386✔

2419

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

42,530✔

2422

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

36,242✔

2424

  tEndDecode(&decoder);

18,121✔

2426

_exit:

18,121✔

2427

  tDecoderClear(&decoder);

18,121✔

2428

  return code;

18,121✔

2431

void tFreeMDropStreamReq(SMDropStreamReq *pReq) {

41,838✔

2432

  if (NULL == pReq) {

41,838✔

2435

  if (pReq->name) {

41,838✔

2436

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

89,964✔

2437

      taosMemoryFreeClear(pReq->name[i]);

48,126✔

2439

    taosMemoryFreeClear(pReq->name);

41,838✔

2443

static FORCE_INLINE void tFreeStreamCalcScan(void* pScan) {

2,243,816✔

2444

  if (pScan == NULL) {

2,243,816✔

2447

  SStreamCalcScan *pCalcScan = (SStreamCalcScan *)pScan;

2,243,816✔

2448

  taosArrayDestroy(pCalcScan->vgList);

2,243,816✔

2449

  taosMemoryFreeClear(pCalcScan->scanPlan);

2,243,816✔

2452

void tFreeStreamOutCol(void* pCol) {

74,677✔

2453

  if (pCol == NULL) {

74,677✔

2456

  SStreamOutCol *pOutCol = (SStreamOutCol *)pCol;

74,677✔

2457

  taosMemoryFreeClear(pOutCol->expr);

74,677✔

2462

void tFreeSCMCreateStreamReq(SCMCreateStreamReq *pReq) {

1,265,110✔

2463

  if (NULL == pReq) {

1,265,110✔

2464

    return;

197,840✔

2466

  taosMemoryFreeClear(pReq->name);

1,067,270✔

2467

  taosMemoryFreeClear(pReq->sql);

1,067,270✔

2468

  taosMemoryFreeClear(pReq->streamDB);

1,067,270✔

2469

  taosMemoryFreeClear(pReq->triggerDB);

1,067,270✔

2470

  taosMemoryFreeClear(pReq->outDB);

1,067,270✔

2471

  taosMemoryFreeClear(pReq->triggerTblName);

1,067,270✔

2472

  taosMemoryFreeClear(pReq->outTblName);

1,067,270✔

2474

  taosArrayDestroyP(pReq->calcDB, NULL);

1,067,270✔

2475

  pReq->calcDB = NULL;

1,067,270✔

2476

  taosArrayDestroyP(pReq->pNotifyAddrUrls, NULL);

1,067,270✔

2477

  pReq->pNotifyAddrUrls = NULL;

1,067,270✔

2479

  taosMemoryFreeClear(pReq->triggerFilterCols);

1,067,270✔

2480

  taosMemoryFreeClear(pReq->triggerCols);

1,067,270✔

2481

  taosMemoryFreeClear(pReq->partitionCols);

1,067,270✔

2483

  taosArrayDestroy(pReq->outTags);

1,067,270✔

2484

  pReq->outTags = NULL;

1,067,270✔

2485

  taosArrayDestroy(pReq->outCols);

1,067,270✔

2486

  pReq->outCols = NULL;

1,067,270✔

2488

  switch (pReq->triggerType) {

1,067,270✔

2489

    case WINDOW_TYPE_STATE:

295,410✔

2490

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

295,410✔

2491

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

295,410✔

2492

      break;

295,410✔

2493

    case WINDOW_TYPE_EVENT:

110,668✔

2494

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

110,668✔

2495

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

110,668✔

2496

      break;

110,668✔

2497

    default:

661,192✔

2498

      break;

661,192✔

2501

  taosMemoryFreeClear(pReq->triggerScanPlan);

1,067,270✔

2502

  taosArrayDestroyEx(pReq->calcScanPlanList, tFreeStreamCalcScan);

1,067,270✔

2503

  pReq->calcScanPlanList = NULL;

1,067,270✔

2504

  taosMemoryFreeClear(pReq->triggerPrevFilter);

1,067,270✔

2506

  taosMemoryFreeClear(pReq->calcPlan);

1,067,270✔

2507

  taosMemoryFreeClear(pReq->subTblNameExpr);

1,067,270✔

2508

  taosMemoryFreeClear(pReq->tagValueExpr);

1,067,270✔

2509

  taosArrayDestroyEx(pReq->forceOutCols, tFreeStreamOutCol);

1,067,270✔

2510

  pReq->forceOutCols = NULL;

1,067,270✔

2511

  taosArrayDestroy(pReq->colCids);

1,067,270✔

2512

  pReq->colCids = NULL;

1,067,270✔

2513

  taosArrayDestroy(pReq->tagCids);

1,067,270✔

2514

  pReq->tagCids = NULL;

1,067,270✔

2517

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

183,831✔

2518

  int32_t code = 0, lino = 0;

183,831✔

2519

  if (NULL == pSrc) {

183,831✔

2523

  void* p = NULL;

183,831✔

2524

  int32_t num = 0;

183,831✔

2525

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

183,831✔

2526

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

183,831✔

2528

  SCMCreateStreamReq* pDst = *ppDst;

183,831✔

2530

  if (pSrc->outDB) {

183,831✔

2531

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

180,551✔

2532

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

180,551✔

2535

  if (pSrc->triggerTblName) {

183,831✔

2536

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

182,836✔

2537

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

182,836✔

2540

  if (pSrc->outTblName) {

183,831✔

2541

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

180,551✔

2542

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

180,551✔

2545

  if (pSrc->pNotifyAddrUrls) {

183,831✔

2546

    num = taosArrayGetSize(pSrc->pNotifyAddrUrls);

54,651✔

2547

    if (num > 0) {

54,651✔

2548

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

54,651✔

2549

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

54,651✔

2551

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

109,302✔

2552

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

54,651✔

2553

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

54,651✔

2554

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

109,302✔

2558

  if (pSrc->triggerFilterCols) {

183,831✔

2559

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

17,200✔

2560

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

17,200✔

2563

  if (pSrc->triggerCols) {

183,831✔

2564

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

176,765✔

2565

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

176,765✔

2568

  if (pSrc->partitionCols) {

183,831✔

2569

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

66,637✔

2570

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

66,637✔

2573

  if (pSrc->outCols) {

183,831✔

2574

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

180,551✔

2575

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

180,551✔

2578

  if (pSrc->outTags) {

183,831✔

2579

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

66,637✔

2580

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

66,637✔

2583

  pDst->triggerType = pSrc->triggerType;

183,831✔

2585

  switch (pSrc->triggerType) {

183,831✔

2586

    case WINDOW_TYPE_STATE:

62,472✔

2587

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

62,472✔

2588

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

62,472✔

2589

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

62,472✔

2590

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

62,472✔

2591

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

62,472✔

2592

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

62,472✔

2596

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

62,472✔

2597

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

62,472✔

2598

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

62,472✔

2600

      break;

62,472✔

2601

    case WINDOW_TYPE_EVENT:

22,979✔

2602

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

22,979✔

2603

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

22,979✔

2604

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

22,979✔

2607

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

22,979✔

2608

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

21,019✔

2609

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

21,019✔

2611

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

22,979✔

2612

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

22,979✔

2613

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

22,979✔

2614

      break;

22,979✔

2615

    case WINDOW_TYPE_COUNT:

17,007✔

2616

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

17,007✔

2617

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

17,007✔

2618

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

17,007✔

2622

      break;

17,007✔

2623

    default:

81,373✔

2624

      pDst->trigger = pSrc->trigger;

81,373✔

2625

      break;

81,373✔

2629

  if (pSrc->triggerScanPlan) {

183,831✔

2630

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

182,836✔

2631

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

182,836✔

2634

  if (pSrc->calcScanPlanList) {

183,831✔

2635

    num = taosArrayGetSize(pSrc->calcScanPlanList);

180,551✔

2636

    if (num > 0) {

180,551✔

2637

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

180,551✔

2638

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

180,551✔

2640

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

622,977✔

2641

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

442,426✔

2642

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

442,426✔

2644

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

442,426✔

2645

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

442,426✔

2647

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

442,426✔

2648

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

442,426✔

2650

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

884,852✔

2654

  if (pSrc->triggerPrevFilter) {

183,831✔

2655

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

7,620✔

2656

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

7,620✔

2659

  if (pSrc->calcPlan) {

183,831✔

2660

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

180,551✔

2661

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

180,551✔

2664

  if (pSrc->subTblNameExpr) {

183,831✔

2665

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

66,637✔

2666

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

66,637✔

2669

  if (pSrc->tagValueExpr) {

183,831✔

2670

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

66,637✔

2671

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

66,637✔

2674

  if (pSrc->forceOutCols) {

183,831✔

2675

    num = taosArrayGetSize(pSrc->forceOutCols);

3,267✔

2676

    if (num > 0) {

3,267✔

2677

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

3,267✔

2678

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

3,267✔

2680

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

21,617✔

2681

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

18,350✔

2682

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

18,350✔

2684

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

18,350✔

2685

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

18,350✔

2687

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

36,700✔

2691

  if (pSrc->colCids) {

183,831✔

2692

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

3,078✔

2693

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

3,078✔

2696

  if (pSrc->tagCids) {

183,831✔

2697

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

2,415✔

2698

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

2,415✔

2701

  pDst->triggerTblUid = pSrc->triggerTblUid;

183,831✔

2702

  pDst->triggerTblType = pSrc->triggerTblType;

183,831✔

2703

  pDst->triggerPrec = pSrc->triggerPrec;

183,831✔

2704

  pDst->deleteReCalc = pSrc->deleteReCalc;

183,831✔

2705

  pDst->deleteOutTbl = pSrc->deleteOutTbl;

183,831✔

2706

  pDst->flags = pSrc->flags;

183,831✔

2708

_exit:

183,831✔

2710

  if (code) {

183,831✔

2715

  return code;

183,831✔

2719

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

5,906✔

2720

  int32_t  code = 0;

5,906✔

2723

  SEncoder encoder = {0};

5,906✔

2724

  tEncoderInit(&encoder, buf, bufLen);

5,906✔

2725

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

5,906✔

2727

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

5,906✔

2728

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

11,812✔

2729

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

11,812✔

2730

  tEndEncode(&encoder);

5,906✔

2732

_exit:

5,906✔

2733

  if (code) {

5,906✔

2736

    tlen = encoder.pos;

5,906✔

2738

  tEncoderClear(&encoder);

5,906✔

2739

  return tlen;

5,906✔

2742

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

2,791✔

2743

  SDecoder decoder = {0};

2,791✔

2744

  int32_t  code = 0;

2,791✔

2747

  tDecoderInit(&decoder, buf, bufLen);

2,791✔

2748

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

2,791✔

2749

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

5,582✔

2750

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

5,582✔

2751

  tEndDecode(&decoder);

2,791✔

2753

_exit:

2,791✔

2754

  tDecoderClear(&decoder);

2,791✔

2755

  return code;

2,791✔

2758

void tFreeMPauseStreamReq(SMPauseStreamReq *pReq) {

2,953✔

2759

  taosMemoryFreeClear(pReq->name);

2,953✔

2760

2,953✔

2762

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

5,210✔

2763

  SEncoder encoder = {0};

5,210✔

2764

  int32_t  code = 0;

5,210✔

2767

  tEncoderInit(&encoder, buf, bufLen);

5,210✔

2768

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

5,210✔

2769

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

5,210✔

2770

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

10,420✔

2771

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

10,420✔

2772

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

10,420✔

2773

  tEndEncode(&encoder);

5,210✔

2775

_exit:

5,210✔

2776

  if (code) {

5,210✔

2779

    tlen = encoder.pos;

5,210✔

2781

  tEncoderClear(&encoder);

5,210✔

2782

  return tlen;

5,210✔

2785

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

2,443✔

2786

  SDecoder decoder = {0};

2,443✔

2787

  int32_t  code = 0;

2,443✔

2790

  tDecoderInit(&decoder, buf, bufLen);

2,443✔

2791

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

2,443✔

2792

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

4,886✔

2793

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

4,886✔

2794

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

4,886✔

2795

  tEndDecode(&decoder);

2,443✔

2797

_exit:

2,443✔

2798

  tDecoderClear(&decoder);

2,443✔

2799

  return code;

2,443✔

2802

void tFreeMResumeStreamReq(SMResumeStreamReq *pReq) {

2,605✔

2803

  taosMemoryFreeClear(pReq->name);

2,605✔

2804

2,605✔

2806

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

23,310✔

2807

  SEncoder encoder = {0};

23,310✔

2808

  int32_t  code = 0;

23,310✔

2811

  tEncoderInit(&encoder, buf, bufLen);

23,310✔

2812

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

23,310✔

2813

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

23,310✔

2814

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

46,620✔

2815

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

46,620✔

2816

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

46,620✔

2817

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

46,620✔

2818

  tEndEncode(&encoder);

23,310✔

2820

_exit:

23,310✔

2821

  if (code) {

23,310✔

2824

    tlen = encoder.pos;

23,310✔

2826

  tEncoderClear(&encoder);

23,310✔

2827

  return tlen;

23,310✔

2830

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

11,642✔

2831

  SDecoder decoder = {0};

11,642✔

2832

  int32_t  code = 0;

11,642✔

2835

  tDecoderInit(&decoder, buf, bufLen);

11,642✔

2836

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

11,642✔

2838

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

23,284✔

2839

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

23,284✔

2840

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

23,284✔

2841

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

23,284✔

2842

  tEndDecode(&decoder);

11,642✔

2844

_exit:

11,642✔

2845

  tDecoderClear(&decoder);

11,642✔

2846

  return code;

11,642✔

2849

void tFreeMRecalcStreamReq(SMRecalcStreamReq *pReq) {

23,297✔

2850

  taosMemoryFreeClear(pReq->name);

23,297✔

2851

23,297✔

2853

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

11,186✔

2854

  int32_t code = 0;

11,186✔

2857

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

22,372✔

2858

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

22,372✔

2859

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

22,372✔

2861

_exit:

11,186✔

2862

  return code;

11,186✔

2865

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

11,186✔

2866

  SEncoder encoder = {0};

11,186✔

2867

  int32_t  code = 0;

11,186✔

2870

  tEncoderInit(&encoder, buf, bufLen);

11,186✔

2872

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

11,186✔

2873

  TAOS_CHECK_EXIT(tEncodeStreamProgressReq(&encoder, pReq));

11,186✔

2875

  tEndEncode(&encoder);

11,186✔

2877

_exit:

11,186✔

2878

  if (code) {

11,186✔

2881

    tlen = encoder.pos;

11,186✔

2883

  tEncoderClear(&encoder);

11,186✔

2884

  return tlen;

11,186✔

2887

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

9,204✔

2888

  int32_t code = 0;

9,204✔

2891

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

18,408✔

2892

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

18,408✔

2893

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

18,408✔

2895

_exit:

9,204✔

2896

  return code;

9,204✔

2899

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

9,204✔

2900

  SDecoder decoder = {0};

9,204✔

2901

  int32_t  code = 0;

9,204✔

2904

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

9,204✔

2906

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

9,204✔

2907

  TAOS_CHECK_EXIT(tDecodeStreamProgressReq(&decoder, pReq));

9,204✔

2909

  tEndDecode(&decoder);

9,204✔

2911

_exit:

9,204✔

2912

  tDecoderClear(&decoder);

9,204✔

2913

  return code;

9,204✔

2916

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

11,092✔

2917

  int32_t code = 0;

11,092✔

2920

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

22,184✔

2921

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

22,184✔

2922

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

22,184✔

2923

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

22,184✔

2925

_exit:

11,092✔

2926

  return code;

11,092✔

2929

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

11,092✔

2930

  SEncoder encoder = {0};

11,092✔

2931

  int32_t  code = 0;

11,092✔

2934

  tEncoderInit(&encoder, buf, bufLen);

11,092✔

2936

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

11,092✔

2937

  TAOS_CHECK_EXIT(tEncodeStreamProgressRsp(&encoder, pRsp));

11,092✔

2939

  tEndEncode(&encoder);

11,092✔

2941

_exit:

11,092✔

2942

  if (code) {

11,092✔

2945

    tlen = encoder.pos;

11,092✔

2947

  tEncoderClear(&encoder);

11,092✔

2948

  return tlen;

11,092✔

2951

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

5,593✔

2952

  int32_t code = 0;

5,593✔

2955

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

11,186✔

2956

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

11,186✔

2957

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

11,186✔

2958

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

11,186✔

2960

_exit:

5,593✔

2961

  return code;

5,593✔

2964

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

5,593✔

2965

  SDecoder decoder = {0};

5,593✔

2966

  int32_t  code = 0;

5,593✔

2969

  tDecoderInit(&decoder, buf, bufLen);

5,593✔

2971

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

5,593✔

2972

  TAOS_CHECK_EXIT(tDecodeStreamProgressRsp(&decoder, pRsp));

5,593✔

2974

  tEndDecode(&decoder);

5,593✔

2976

_exit:

5,593✔

2977

  tDecoderClear(&decoder);

5,593✔

2978

  return code;

5,593✔

2981

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

265,100✔

2982

  SEncoder encoder = {0};

265,100✔

2983

  int32_t  code = TSDB_CODE_SUCCESS;

265,100✔

2984

  int32_t  lino = 0;

265,100✔

2985

  int32_t  tlen = 0;

265,100✔

2987

  tEncoderInit(&encoder, buf, bufLen);

265,100✔

2988

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

265,100✔

2990

  int32_t size = taosArrayGetSize(pRsp->cols);

265,100✔

2991

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, size));

265,100✔

2992

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

978,812✔

2993

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

713,712✔

2994

    if (oInfo == NULL) {

713,712✔

2999

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

1,427,424✔

3000

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

1,427,192✔

3001

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

1,427,192✔

3004

  tEndEncode(&encoder);

265,100✔

3006

_exit:

265,100✔

3007

  if (code != TSDB_CODE_SUCCESS) {

265,100✔

3010

    tlen = encoder.pos;

265,100✔

3012

  tEncoderClear(&encoder);

265,100✔

3013

  return tlen;

265,100✔

3016

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

132,550✔

3017

  SDecoder decoder = {0};

132,550✔

3018

  int32_t  code = TSDB_CODE_SUCCESS;

132,550✔

3019

  int32_t  lino = 0;

132,550✔

3021

  tDecoderInit(&decoder, buf, bufLen);

132,550✔

3022

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

132,550✔

3024

  int32_t size = 0;

132,550✔

3025

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

132,550✔

3026

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

132,550✔

3027

  if (pRsp->cols == NULL) {

132,550✔

3032

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

489,406✔

3033

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

356,856✔

3034

    if (oInfo == NULL) {

356,856✔

3039

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

713,712✔

3040

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

713,712✔

3041

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

713,712✔

3044

  tEndDecode(&decoder);

132,550✔

3046

_exit:

132,340✔

3047

  tDecoderClear(&decoder);

132,550✔

3048

  return code;

132,550✔

3051

void    tDestroySTriggerOrigTableInfoRsp(SSTriggerOrigTableInfoRsp* pRsp){

27,824,632✔

3052

  taosArrayDestroy(pRsp->cols);

27,824,632✔

3053

27,824,860✔

3055

void tDestroySTriggerPullRequest(SSTriggerPullRequestUnion* pReq) {

36,206,642✔

3056

  if (pReq == NULL) return;

36,206,642✔

3057

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

46,051,661✔

3058

    SSTriggerWalDataNewRequest* pRequest = (SSTriggerWalDataNewRequest*)pReq;

9,847,992✔

3059

    taosArrayDestroy(pRequest->versions);

9,847,992✔

3060

    tSimpleHashCleanup(pRequest->ranges);

9,845,022✔

3061

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

26,365,128✔

3062

    SSTriggerTsdbDataRequest* pRequest = (SSTriggerTsdbDataRequest*)pReq;

455,506✔

3063

    if (pRequest->cids != NULL) {

455,506✔

3064

      taosArrayDestroy(pRequest->cids);

455,506✔

3065

      pRequest->cids = NULL;

455,506✔

3067

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

25,909,903✔

3068

    SSTriggerVirTableInfoRequest* pRequest = (SSTriggerVirTableInfoRequest*)pReq;

75,191✔

3069

    if (pRequest->cids != NULL) {

75,191✔

3070

      taosArrayDestroy(pRequest->cids);

75,191✔

3071

      pRequest->cids = NULL;

75,191✔

3073

    if (pRequest->uids != NULL) {

75,191✔

3077

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

25,832,504✔

3078

    SSTriggerVirTablePseudoColRequest *pRequest = (SSTriggerVirTablePseudoColRequest*)pReq;

942,972✔

3079

    if (pRequest->cids != NULL) {

942,972✔

3080

      taosArrayDestroy(pRequest->cids);

942,972✔

3081

      pRequest->cids = NULL;

942,972✔

3083

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

24,888,866✔

3084

    SSTriggerOrigTableInfoRequest* pRequest = (SSTriggerOrigTableInfoRequest*)pReq;

132,550✔

3085

    if (pRequest->cols != NULL) {

132,550✔

3086

      taosArrayDestroy(pRequest->cols);

132,550✔

3087

      pRequest->cols = NULL;

132,550✔

3089

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

24,755,170✔

3090

    SSTriggerSetTableRequest* pRequest = (SSTriggerSetTableRequest*)pReq;

132,550✔

3091

    tSimpleHashCleanup(pRequest->uidInfoTrigger);

132,550✔

3092

    tSimpleHashCleanup(pRequest->uidInfoCalc);

132,550✔

3096

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

3,104,000✔

3097

  int32_t  code = TSDB_CODE_SUCCESS;

3,104,000✔

3098

  int32_t  lino = 0;

3,104,000✔

3099

  int32_t  nEle = taosArrayGetSize(pArr);

3,104,000✔

3100

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

3,104,000✔

3101

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

3,104,000✔

3102

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

6,208,000✔

3104

_exit:

3,104,000✔

3105

  return code;

3,104,000✔

3108

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

1,548,860✔

3109

  int32_t  code = TSDB_CODE_SUCCESS;

1,548,860✔

3110

  int32_t  lino = 0;

1,548,860✔

3111

  void*    buf = NULL;

1,548,860✔

3112

  uint64_t len = 0;

1,548,860✔

3113

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

1,548,860✔

3115

  if (len > 0) {

1,548,860✔

3116

    *ppArr = taosArrayInit(0, elemSize);

1,473,669✔

3117

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

1,473,669✔

3118

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

1,473,669✔

3119

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

1,473,669✔

3122

_exit:

1,548,860✔

3123

  if (buf != NULL) {

1,548,860✔

3124

    taosMemoryFree(buf);

1,473,669✔

3126

  return code;

1,548,860✔

3129

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

529,990✔

3130

  int32_t  code = TSDB_CODE_SUCCESS;

529,990✔

3131

  int32_t  lino = 0;

529,990✔

3132

  int32_t size = tSimpleHashGetSize(pInfo);

529,990✔

3133

  TAOS_CHECK_EXIT(tEncodeI32(encoder, size));

529,972✔

3134

  int32_t iter = 0;

529,972✔

3135

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

529,972✔

3136

  while (px != NULL) {

1,188,612✔

3137

    int64_t* uid = tSimpleHashGetKey(px, NULL);

658,640✔

3138

    TAOS_CHECK_EXIT(tEncodeI64(encoder, *uid));

1,317,048✔

3139

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

1,317,048✔

3140

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

658,640✔

3141

    int32_t len = tSimpleHashGetSize(info);

658,640✔

3142

    TAOS_CHECK_EXIT(tEncodeI32(encoder, len));

658,430✔

3143

    int32_t iter1 = 0;

658,430✔

3144

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

658,430✔

3145

    while (px1 != NULL) {

2,482,786✔

3146

      int16_t* slot = tSimpleHashGetKey(px1, NULL);

1,824,610✔

3147

      int16_t* cid = (int16_t*)px1;

1,824,610✔

3148

      TAOS_CHECK_EXIT(tEncodeI16(encoder, *slot));

3,649,434✔

3149

      TAOS_CHECK_EXIT(tEncodeI16(encoder, *cid));

3,650,332✔

3151

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

1,825,508✔

3154

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

657,948✔

3157

_exit:

529,972✔

3158

  return code;

529,972✔

3161

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

72,773,423✔

3162

  SEncoder encoder = {0};

72,773,423✔

3163

  int32_t  code = TSDB_CODE_SUCCESS;

72,773,879✔

3164

  int32_t  lino = 0;

72,773,879✔

3165

  int32_t  tlen = 0;

72,773,879✔

3167

  tEncoderInit(&encoder, buf, bufLen);

72,773,879✔

3168

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

72,773,402✔

3170

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

145,545,352✔

3171

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

145,543,204✔

3172

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

145,543,054✔

3173

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

145,543,545✔

3175

  switch (pReq->type) {

72,770,603✔

3176

    case STRIGGER_PULL_SET_TABLE: {

264,890✔

3177

      SSTriggerSetTableRequest* pRequest = (SSTriggerSetTableRequest*)pReq;

264,890✔

3178

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

264,890✔

3179

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

265,100✔

3180

      break;

265,100✔

3182

    case STRIGGER_PULL_LAST_TS: {

570,170✔

3183

      break;

570,170✔

3185

    case STRIGGER_PULL_FIRST_TS: {

456,499✔

3186

      SSTriggerFirstTsRequest* pRequest = (SSTriggerFirstTsRequest*)pReq;

456,499✔

3187

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

912,999✔

3188

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

913,230✔

3189

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

913,460✔

3190

      break;

456,730✔

3192

    case STRIGGER_PULL_TSDB_META: {

1,008,380✔

3193

      SSTriggerTsdbMetaRequest* pRequest = (SSTriggerTsdbMetaRequest*)pReq;

1,008,380✔

3194

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

2,016,760✔

3195

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

2,016,760✔

3196

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

2,016,760✔

3197

      TAOS_CHECK_EXIT(tEncodeI8(&encoder, pRequest->order));

2,016,760✔

3198

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));

2,016,760✔

3199

      break;

1,008,380✔

3204

    case STRIGGER_PULL_TSDB_TS_DATA: {

328,758✔

3205

      SSTriggerTsdbTsDataRequest* pRequest = (SSTriggerTsdbTsDataRequest*)pReq;

328,758✔

3206

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->suid));

657,516✔

3207

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->uid));

657,516✔

3208

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->skey));

657,516✔

3209

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ekey));

657,516✔

3210

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));

657,516✔

3211

      break;

328,758✔

3213

    case STRIGGER_PULL_TSDB_TRIGGER_DATA: {

111,184✔

3214

      SSTriggerTsdbTriggerDataRequest* pRequest = (SSTriggerTsdbTriggerDataRequest*)pReq;

111,184✔

3215

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->startTime));

222,368✔

3216

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->gid));

222,368✔

3217

      TAOS_CHECK_EXIT(tEncodeI8(&encoder, pRequest->order));

222,368✔

3218

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));

222,368✔

3219

      break;

111,184✔

3221

    case STRIGGER_PULL_TSDB_TRIGGER_DATA_NEXT: {

111,184✔

3222

      break;

111,184✔

3224

    case STRIGGER_PULL_TSDB_CALC_DATA: {

12,603,656✔

3225

      SSTriggerTsdbCalcDataRequest* pRequest = (SSTriggerTsdbCalcDataRequest*)pReq;

12,603,656✔

3226

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->gid));

25,207,312✔

3227

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->skey));

25,207,082✔

3228

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ekey));

25,207,082✔

3229

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));

25,207,312✔

3230

      break;

12,603,656✔

3235

    case STRIGGER_PULL_TSDB_DATA: {

914,060✔

3236

      SSTriggerTsdbDataRequest* pRequest = (SSTriggerTsdbDataRequest*)pReq;

914,060✔

3237

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->suid));

1,828,120✔

3238

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->uid));

1,828,120✔

3239

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->skey));

1,828,120✔

3240

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ekey));

1,828,120✔

3241

      TAOS_CHECK_EXIT(encodePlainArray(&encoder, pRequest->cids));

914,060✔

3242

      TAOS_CHECK_EXIT(tEncodeI8(&encoder, pRequest->order));

1,828,120✔

3243

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));

1,828,120✔

3244

      break;

914,060✔

3249

    case STRIGGER_PULL_WAL_META_NEW: {

26,628,119✔

3250

      SSTriggerWalMetaNewRequest* pRequest = (SSTriggerWalMetaNewRequest*)pReq;

26,628,119✔

3251

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->lastVer));

53,254,792✔

3252

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ctime));

53,253,742✔

3253

      break;

26,627,069✔

3255

    case STRIGGER_PULL_WAL_DATA_NEW:

19,696,230✔

3257

      SSTriggerWalDataNewRequest* pRequest = (SSTriggerWalDataNewRequest*)pReq;

19,696,230✔

3258

      int32_t                     nVersion = taosArrayGetSize(pRequest->versions);

19,696,230✔

3259

      TAOS_CHECK_EXIT(tEncodeI32(&encoder, nVersion));

19,694,089✔

3260

      for (int32_t i = 0; i < nVersion; i++) {

36,459,521✔

3261

        int64_t ver = *(int64_t*)TARRAY_GET_ELEM(pRequest->versions, i);

16,765,884✔

3262

        TAOS_CHECK_EXIT(tEncodeI64(&encoder, ver));

16,765,432✔

3264

      int32_t nRanges = tSimpleHashGetSize(pRequest->ranges);

19,693,637✔

3265

      TAOS_CHECK_EXIT(tEncodeI32(&encoder, nRanges));

19,693,329✔

3266

      int32_t iter = 0;

19,693,329✔

3267

      void*   px = tSimpleHashIterate(pRequest->ranges, NULL, &iter);

19,693,101✔

3268

      while (px != NULL) {

27,547,978✔

3269

        uint64_t* gid = tSimpleHashGetKey(px, NULL);

7,853,208✔

3270

        TAOS_CHECK_EXIT(tEncodeU64(&encoder, *gid));

15,706,184✔

3271

        int64_t* key = (int64_t*)px;

7,852,976✔

3272

        TAOS_CHECK_EXIT(tEncodeI64(&encoder, key[0]));

15,705,490✔

3273

        TAOS_CHECK_EXIT(tEncodeI64(&encoder, key[1]));

15,705,032✔

3275

        px = tSimpleHashIterate(pRequest->ranges, px, &iter);

7,852,518✔

3277

      break;

19,695,002✔

3279

    case STRIGGER_PULL_WAL_META_DATA_NEW: {

7,177,373✔

3280

      SSTriggerWalMetaDataNewRequest* pRequest = (SSTriggerWalMetaDataNewRequest*)pReq;

7,177,373✔

3281

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->lastVer));

14,354,764✔

3282

      break;

7,177,391✔

3284

    case STRIGGER_PULL_GROUP_COL_VALUE: {

597,298✔

3285

      SSTriggerGroupColValueRequest* pRequest = (SSTriggerGroupColValueRequest*)pReq;

597,298✔

3286

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->gid));

1,194,365✔

3287

      break;

597,067✔

3289

    case STRIGGER_PULL_VTABLE_INFO: {

151,236✔

3290

      SSTriggerVirTableInfoRequest* pRequest = (SSTriggerVirTableInfoRequest*)pReq;

151,236✔

3291

      TAOS_CHECK_EXIT(encodePlainArray(&encoder, pRequest->cids));

151,236✔

3292

      TAOS_CHECK_EXIT(encodePlainArray(&encoder, pRequest->uids));

151,236✔

3293

      TAOS_CHECK_EXIT(tEncodeBool(&encoder, pRequest->fetchAllTable));

151,236✔

3294

      break;

151,236✔

3296

    case STRIGGER_PULL_VTABLE_PSEUDO_COL: {

1,887,468✔

3297

      SSTriggerVirTablePseudoColRequest* pRequest = (SSTriggerVirTablePseudoColRequest*)pReq;

1,887,468✔

3298

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->uid));

3,774,936✔

3299

      TAOS_CHECK_EXIT(encodePlainArray(&encoder, pRequest->cids));

1,887,468✔

3300

      break;

1,887,468✔

3302

    case STRIGGER_PULL_OTABLE_INFO: {

265,100✔

3303

      SSTriggerOrigTableInfoRequest* pRequest = (SSTriggerOrigTableInfoRequest*)pReq;

265,100✔

3304

      int32_t size = taosArrayGetSize(pRequest->cols);

265,100✔

3305

      TAOS_CHECK_EXIT(tEncodeI32(&encoder, size));

265,100✔

3306

      for (int32_t i = 0; i < size; ++i) {

978,812✔

3307

        OTableInfo* oInfo = taosArrayGet(pRequest->cols, i);

713,712✔

3308

        if (oInfo == NULL) {

713,712✔

3313

        TAOS_CHECK_EXIT(tEncodeCStr(&encoder, oInfo->refTableName));

1,427,424✔

3314

        TAOS_CHECK_EXIT(tEncodeCStr(&encoder, oInfo->refColName));

1,427,424✔

3316

      break;

265,100✔

3318

    default: {

721✔

3319

      uError("unknown pull type %d", pReq->type);

721✔

3325

  tEndEncode(&encoder);

72,770,089✔

3327

_exit:

72,764,184✔

3328

  if (code != TSDB_CODE_SUCCESS) {

72,765,632✔

3331

    tlen = encoder.pos;

72,765,632✔

3333

  tEncoderClear(&encoder);

72,765,632✔

3334

  return tlen;

72,772,041✔

3337

static void destroyHash(void* data){

329,320✔

3338

  if (data){

329,320✔

3339

    SSHashObj* tmp = *(SSHashObj**)data;

329,320✔

3340

    tSimpleHashCleanup(tmp);

329,320✔

3342

329,320✔

3344

static int32_t decodeSetTableMapInfo(SDecoder* decoder, SSHashObj** ppInfo) {

265,100✔

3345

  int32_t  code = TSDB_CODE_SUCCESS;

265,100✔

3346

  int32_t  lino = 0;

265,100✔

3347

  int32_t size = 0;

265,100✔

3348

  TAOS_CHECK_EXIT(tDecodeI32(decoder, &size));

265,100✔

3349

  *ppInfo = tSimpleHashInit(size, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY));

265,100✔

3350

  if (*ppInfo == NULL) {

265,100✔

3353

  tSimpleHashSetFreeFp(*ppInfo, destroyHash);

265,100✔

3355

  for (int32_t i = 0; i < size; ++i) {

594,420✔

3356

    int64_t id[2] = {0};

329,320✔

3357

    TAOS_CHECK_EXIT(tDecodeI64(decoder, id));

329,320✔

3358

    TAOS_CHECK_EXIT(tDecodeI64(decoder, id+1));

658,640✔

3359

    int32_t len = 0;

329,320✔

3360

    TAOS_CHECK_EXIT(tDecodeI32(decoder, &len));

329,320✔

3361

    SSHashObj* tmp = tSimpleHashInit(len, taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT));

329,320✔

3362

    if (tmp == NULL) {

329,320✔

3365

    TAOS_CHECK_EXIT(tSimpleHashPut(*ppInfo, id, sizeof(id), &tmp, POINTER_BYTES));

329,320✔

3367

    for (int32_t j = 0; j < len; ++j) {

1,242,190✔

3368

      int16_t slotId = 0;

912,870✔

3369

      int16_t cid = 0;

912,870✔

3370

      TAOS_CHECK_EXIT(tDecodeI16(decoder, &slotId));

912,870✔

3371

      TAOS_CHECK_EXIT(tDecodeI16(decoder, &cid));

912,870✔

3372

      TAOS_CHECK_EXIT(tSimpleHashPut(tmp, &slotId, sizeof(slotId), &cid, sizeof(cid)));

912,870✔

3375

_exit:

265,100✔

3376

  if (code != TSDB_CODE_SUCCESS) {

265,100✔

3380

  return code;

265,100✔

3383

int32_t tDeserializeSTriggerPullRequest(void* buf, int32_t bufLen, SSTriggerPullRequestUnion* pReq) {

36,209,185✔

3384

  SDecoder decoder = {0};

36,209,185✔

3385

  int32_t  code = TSDB_CODE_SUCCESS;

36,209,415✔

3386

  int32_t  lino = 0;

36,209,415✔

3388

  tDecoderInit(&decoder, buf, bufLen);

36,209,415✔

3389

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

36,210,869✔

3391

  int32_t type = 0;

36,213,657✔

3392

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &type));

36,214,186✔

3393

  SSTriggerPullRequest* pBase = &(pReq->base);

36,214,186✔

3394

  pBase->type = type;

36,212,730✔

3395

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pBase->streamId));

72,424,043✔

3396

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pBase->readerTaskId));

72,425,627✔

3397

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pBase->sessionId));

72,427,743✔

3399

  switch (type) {

36,213,657✔

3400

    case STRIGGER_PULL_SET_TABLE: {

132,550✔

3401

      SSTriggerSetTableRequest* pRequest = &(pReq->setTableReq);

132,550✔

3402

      TAOS_CHECK_EXIT(decodeSetTableMapInfo(&decoder, &pRequest->uidInfoTrigger));

132,550✔

3403

      TAOS_CHECK_EXIT(decodeSetTableMapInfo(&decoder, &pRequest->uidInfoCalc));

132,550✔

3404

      break;

132,550✔

3406

    case STRIGGER_PULL_LAST_TS: {

285,037✔

3407

      break;

285,037✔

3409

    case STRIGGER_PULL_FIRST_TS: {

227,164✔

3410

      SSTriggerFirstTsRequest* pRequest = &(pReq->firstTsReq);

227,164✔

3411

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));

454,328✔

3412

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->startTime));

454,328✔

3413

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));

454,328✔

3414

      break;

227,164✔

3416

    case STRIGGER_PULL_TSDB_META: {

504,116✔

3417

      SSTriggerTsdbMetaRequest* pRequest = &(pReq->tsdbMetaReq);

504,116✔

3418

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->startTime));

1,008,232✔

3419

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->endTime));

1,008,232✔

3420

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));

1,008,232✔

3421

      TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pRequest->order));

1,008,232✔

3422

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));

1,008,232✔

3423

      break;

504,116✔

3428

    case STRIGGER_PULL_TSDB_TS_DATA: {

164,367✔

3429

      SSTriggerTsdbTsDataRequest* pRequest = &(pReq->tsdbTsDataReq);

164,367✔

3430

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->suid));

328,734✔

3431

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->uid));

328,734✔

3432

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->skey));

328,734✔

3433

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ekey));

328,734✔

3434

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));

328,734✔

3435

      break;

164,367✔

3437

    case STRIGGER_PULL_TSDB_TRIGGER_DATA: {

55,592✔

3438

      SSTriggerTsdbTriggerDataRequest* pRequest = &(pReq->tsdbTriggerDataReq);

55,592✔

3439

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->startTime));

111,184✔

3440

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));

111,184✔

3441

      TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pRequest->order));

111,184✔

3442

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));

111,184✔

3443

      break;

55,592✔

3445

    case STRIGGER_PULL_TSDB_TRIGGER_DATA_NEXT: {

55,592✔

3446

      break;

55,592✔

3448

    case STRIGGER_PULL_TSDB_CALC_DATA: {

6,300,385✔

3449

      SSTriggerTsdbCalcDataRequest* pRequest = &(pReq->tsdbCalcDataReq);

6,300,385✔

3450

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));

12,600,976✔

3451

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->skey));

12,601,182✔

3452

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ekey));

12,601,182✔

3453

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));

12,601,182✔

3454

      break;

6,300,591✔

3459

    case STRIGGER_PULL_TSDB_DATA: {

455,506✔

3460

      SSTriggerTsdbDataRequest* pRequest = &(pReq->tsdbDataReq);

455,506✔

3461

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->suid));

911,012✔

3462

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->uid));

911,012✔

3463

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->skey));

911,012✔

3464

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ekey));

911,012✔

3465

      TAOS_CHECK_EXIT(decodePlainArray(&decoder, &pRequest->cids, sizeof(col_id_t)));

455,506✔

3466

      TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pRequest->order));

911,012✔

3467

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));

911,012✔

3468

      break;

455,506✔

3473

    case STRIGGER_PULL_WAL_META_NEW: {

13,218,617✔

3474

      SSTriggerWalMetaNewRequest* pRequest = &(pReq->walMetaNewReq);

13,218,617✔

3475

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->lastVer));

26,442,990✔

3476

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ctime));

26,445,548✔

3477

      break;

13,223,002✔

3479

    case STRIGGER_PULL_WAL_DATA_NEW:

9,846,850✔

3481

      SSTriggerWalDataNewRequest* pRequest = &(pReq->walDataNewReq);

9,846,850✔

3482

      int32_t                     nVersion = 0;

9,846,850✔

3483

      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nVersion));

9,846,391✔

3484

      pRequest->versions = taosArrayInit_s(sizeof(int64_t), nVersion);

9,846,391✔

3485

      for (int32_t i = 0; i < nVersion; i++) {

18,230,897✔

3486

        int64_t* pVer = TARRAY_GET_ELEM(pRequest->versions, i);

8,384,047✔

3487

        TAOS_CHECK_EXIT(tDecodeI64(&decoder, pVer));

8,384,047✔

3489

      int32_t nRanges = 0;

9,846,850✔

3490

      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nRanges));

9,846,850✔

3491

      pRequest->ranges = tSimpleHashInit(nRanges, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT));

9,846,850✔

3492

      if (pRequest->ranges == NULL) {

9,846,622✔

3495

      for (int32_t i = 0; i < nRanges; i++) {

13,772,266✔

3496

        uint64_t gid = 0;

3,925,644✔

3497

        int64_t pRange[2] = {0};

3,925,644✔

3498

        TAOS_CHECK_EXIT(tDecodeU64(&decoder, &gid));

3,925,644✔

3499

        TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRange[0]));

3,925,644✔

3500

        TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRange[1]));

3,925,644✔

3501

        TAOS_CHECK_EXIT(tSimpleHashPut(pRequest->ranges, &gid, sizeof(gid), pRange, sizeof(pRange)));

3,925,644✔

3503

      break;

9,846,622✔

3505

    case STRIGGER_PULL_WAL_META_DATA_NEW: {

3,513,901✔

3506

      SSTriggerWalMetaDataNewRequest* pRequest = &(pReq->walMetaDataNewReq);

3,513,901✔

3507

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->lastVer));

7,031,298✔

3508

      break;

3,516,474✔

3510

    case STRIGGER_PULL_GROUP_COL_VALUE: {

298,446✔

3511

      SSTriggerGroupColValueRequest* pRequest = &(pReq->groupColValueReq);

298,446✔

3512

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));

596,892✔

3513

      break;

298,446✔

3515

    case STRIGGER_PULL_VTABLE_INFO: {

75,191✔

3516

      SSTriggerVirTableInfoRequest* pRequest = &(pReq->virTableInfoReq);

75,191✔

3517

      TAOS_CHECK_EXIT(decodePlainArray(&decoder, &pRequest->cids, sizeof(col_id_t)));

75,191✔

3518

      TAOS_CHECK_EXIT(decodePlainArray(&decoder, &pRequest->uids, sizeof(int64_t)));

75,191✔

3519

      TAOS_CHECK_EXIT(tDecodeBool(&decoder, &pRequest->fetchAllTable));

75,191✔

3520

      break;

75,191✔

3522

    case STRIGGER_PULL_VTABLE_PSEUDO_COL: {

942,972✔

3523

      SSTriggerVirTablePseudoColRequest* pRequest = &(pReq->virTablePseudoColReq);

942,972✔

3524

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->uid));

1,885,944✔

3525

      TAOS_CHECK_EXIT(decodePlainArray(&decoder, &pRequest->cids, sizeof(col_id_t)));

942,972✔

3526

      break;

942,972✔

3528

    case STRIGGER_PULL_OTABLE_INFO: {

132,550✔

3529

      SSTriggerOrigTableInfoRequest* pRequest = &(pReq->origTableInfoReq);

132,550✔

3530

      int32_t size = 0;

132,550✔

3531

      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &size));

132,550✔

3532

      pRequest->cols = taosArrayInit(size, sizeof(OTableInfo));

132,550✔

3533

      if (pRequest->cols == NULL) {

132,550✔

3538

      for (int32_t i = 0; i < size; ++i) {

489,406✔

3539

        OTableInfo* oInfo = taosArrayReserve(pRequest->cols, 1);

356,856✔

3540

        if (oInfo == NULL) {

356,856✔

3545

        TAOS_CHECK_RETURN(tDecodeCStrTo(&decoder, oInfo->refTableName));

356,856✔

3546

        TAOS_CHECK_RETURN(tDecodeCStrTo(&decoder, oInfo->refColName));

356,856✔

3548

      break;

132,550✔

3550

    default: {

4,821✔

3551

      uError("unknown pull type %d", type);

4,821✔

3557

  tEndDecode(&decoder);

36,215,772✔

3559

_exit:

36,209,577✔

3560

  tDecoderClear(&decoder);

36,211,709✔

3561

  return code;

36,207,027✔

3564

static int32_t tSerializeSTriggerCalcParam(SEncoder* pEncoder, SArray* pParams, bool ignoreNotificationInfo, bool full) {

37,093,565✔

3565

  int32_t size = full ? taosArrayGetSize(pParams) : 0;

37,093,565✔

3566

  int32_t code = 0;

37,095,734✔

3567

  int32_t lino = 0;

37,095,734✔

3568

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, size));

37,091,809✔

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,121,938,941✔

3582

      uint64_t len = (param->extraNotifyContent != NULL) ? strlen(param->extraNotifyContent) + 1 : 0;

560,970,008✔

3583

      TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, (uint8_t*)param->extraNotifyContent, len));

916,226,685✔

3586

_exit:

5,635,769✔

3587

  return code;

5,635,769✔

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);

255,629✔

3595

  if (pParam && pParam->resultNotifyContent != NULL) {

2,147,483,647✔

3598

2,147,483,647✔

3600

void tDestroySStreamGroupValue(void* ptr) {

25,733,528✔

3601

  SStreamGroupValue* pValue = ptr;

25,733,528✔

3602

  if ((pValue != NULL) && (IS_VAR_DATA_TYPE(pValue->data.type) || pValue->data.type == TSDB_DATA_TYPE_DECIMAL)) {

25,733,528✔

3603

    taosMemoryFreeClear(pValue->data.pData);

17,262,897✔

3604

    pValue->data.nData = 0;

17,260,834✔

3606

25,733,596✔

3608

static int32_t tDeserializeSTriggerCalcParam(SDecoder* pDecoder, SArray**ppParams, bool ignoreNotificationInfo) {

18,550,826✔

3609

  int32_t size = 0, code = 0, lino = 0;

18,550,826✔

3610

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &size));

18,551,331✔

3611

  *ppParams = taosArrayInit(size, sizeof(SSTriggerCalcParam));

18,551,331✔

3612

  if (*ppParams == NULL) {

18,551,643✔

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));

560,970,126✔

3626

      uint64_t len = 0;

280,485,063✔

3627

      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&param->extraNotifyContent, &len));

560,969,364✔

3631

_exit:

2,852,124✔

3632

  return code;

18,553,047✔

3635

static int32_t tSerializeStriggerGroupColVals(SEncoder* pEncoder, SArray* pGroupColVals, int32_t vgId) {

37,692,738✔

3636

  int32_t code = TSDB_CODE_SUCCESS;

37,692,738✔

3637

  int32_t lino = 0;

37,692,738✔

3639

  int32_t size = taosArrayGetSize(pGroupColVals);

37,692,738✔

3640

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, size));

37,693,775✔

3641

  for (int32_t i = 0; i < size; ++i) {

86,560,177✔

3642

    SStreamGroupValue* pValue = taosArrayGet(pGroupColVals, i);

48,869,423✔

3643

    if (pValue == NULL) {

48,868,908✔

3646

    TAOS_CHECK_EXIT(tEncodeBool(pEncoder, pValue->isNull));

48,868,908✔

3647

    if (pValue->isNull) {

48,867,541✔

3648

      continue;

15,390✔

3650

    TAOS_CHECK_EXIT(tEncodeBool(pEncoder, pValue->isTbname));

48,852,151✔

3651

    if (pValue->isTbname) {

48,850,856✔

3652

      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pValue->uid));

46,216,366✔

3653

      if (vgId != -1) { pValue->vgId = vgId; }

23,108,374✔

3654

      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pValue->vgId));

46,214,491✔

3656

    TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pValue->data.type));

97,699,900✔

3657

    if (IS_VAR_DATA_TYPE(pValue->data.type)) {

48,850,919✔

3658

      TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pValue->data.pData, pValue->data.nData));

65,765,718✔

3660

      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pValue->data.val));

31,935,829✔

3664

_exit:

37,690,754✔

3665

  return code;

37,690,754✔

3668

static int32_t tDeserializeStriggerGroupColVals(SDecoder* pDecoder, SArray** ppGroupColVals) {

18,849,188✔

3669

  int32_t code = TSDB_CODE_SUCCESS;

18,849,188✔

3670

  int32_t lino = 0;

18,849,188✔

3671

  int32_t size = 0;

18,849,188✔

3673

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &size));

18,850,934✔

3674

  taosArrayClearEx(*ppGroupColVals, tDestroySStreamGroupValue);

18,850,934✔

3675

  if (size > 0) {

18,849,728✔

3676

    if (*ppGroupColVals == NULL) {

12,634,763✔

3677

      *ppGroupColVals = taosArrayInit(size, sizeof(SStreamGroupValue));

12,634,763✔

3678

      if (*ppGroupColVals == NULL) {

12,634,533✔

3685

  for (int32_t i = 0; i < size; ++i) {

43,282,362✔

3686

    SStreamGroupValue* pValue = taosArrayReserve(*ppGroupColVals, 1);

24,432,880✔

3687

    if (pValue == NULL) {

24,432,870✔

3690

    TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &pValue->isNull));

24,432,870✔

3691

    if (pValue->isNull) {

24,432,958✔

3692

      continue;

7,695✔

3694

    TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &pValue->isTbname));

24,425,509✔

3695

    if (pValue->isTbname) {

24,425,536✔

3696

      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pValue->uid));

23,105,282✔

3697

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pValue->vgId));

23,105,282✔

3699

    TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pValue->data.type));

48,850,852✔

3700

    if (IS_VAR_DATA_TYPE(pValue->data.type)) {

40,865,688✔

3701

      uint64_t len = 0;

16,440,020✔

3702

      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pValue->data.pData, &len));

32,880,116✔

3703

      pValue->data.nData = len;

16,439,853✔

3705

      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pValue->data.val));

15,969,102✔

3708

_exit:

18,849,600✔

3709

  return code;

18,849,728✔

3712

int32_t tSerializeSStreamGroupInfo(void* buf, int32_t bufLen, const SStreamGroupInfo* gInfo, int32_t vgId) {

596,892✔

3713

  SEncoder encoder = {0};

596,892✔

3714

  int32_t  code = TSDB_CODE_SUCCESS;

596,892✔

3715

  int32_t  lino = 0;

596,892✔

3716

  int32_t  tlen = 0;

596,892✔

3718

  tEncoderInit(&encoder, buf, bufLen);

596,892✔

3719

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

596,892✔

3721

  TAOS_CHECK_EXIT(tSerializeStriggerGroupColVals(&encoder, gInfo->gInfo, vgId));

596,892✔

3723

  tEndEncode(&encoder);

596,892✔

3725

_exit:

596,892✔

3726

  if (code != TSDB_CODE_SUCCESS) {

596,892✔

3729

    tlen = encoder.pos;

596,892✔

3731

  tEncoderClear(&encoder);

596,892✔

3732

  return tlen;

596,892✔

3735

int32_t tDeserializeSStreamGroupInfo(void* buf, int32_t bufLen, SStreamGroupInfo* gInfo) {

297,887✔

3736

  SDecoder decoder = {0};

297,887✔

3737

  int32_t  code = TSDB_CODE_SUCCESS;

297,887✔

3738

  int32_t  lino = 0;

297,887✔

3739

  int32_t  size = 0;

297,887✔

3741

  tDecoderInit(&decoder, buf, bufLen);

297,887✔

3742

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

297,887✔

3744

  TAOS_CHECK_EXIT(tDeserializeStriggerGroupColVals(&decoder, &gInfo->gInfo));

297,887✔

3746

  tEndDecode(&decoder);

297,887✔

3748

_exit:

297,887✔

3749

  tDecoderClear(&decoder);

297,887✔

3750

  return code;

297,887✔

3753

int32_t tSerializeSTriggerCalcRequest(void* buf, int32_t bufLen, const SSTriggerCalcRequest* pReq) {

6,264,740✔

3754

  SEncoder encoder = {0};

6,264,740✔

3755

  int32_t  code = TSDB_CODE_SUCCESS;

6,264,740✔

3756

  int32_t  lino = 0;

6,264,740✔

3757

  int32_t  tlen = 0;

6,264,740✔

3759

  tEncoderInit(&encoder, buf, bufLen);

6,264,740✔

3760

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

6,264,734✔

3762

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->streamId));

12,529,718✔

3763

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->runnerTaskId));

12,529,488✔

3764

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->sessionId));

12,529,488✔

3765

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->triggerType));

12,529,712✔

3766

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->gid));

12,529,926✔

3768

  TAOS_CHECK_EXIT(tSerializeSTriggerCalcParam(&encoder, pReq->params, false, true));

6,264,962✔

3769

  TAOS_CHECK_EXIT(tSerializeStriggerGroupColVals(&encoder, pReq->groupColVals, -1));

6,264,060✔

3770

  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->createTable));

12,528,594✔

3771

  TAOS_CHECK_EXIT(tEncodeBool(&encoder, pReq->isWindowTrigger));

6,264,296✔

3772

  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->precision));

12,529,482✔

3774

  tEndEncode(&encoder);

6,264,964✔

3776

_exit:

6,264,962✔

3777

  if (code != TSDB_CODE_SUCCESS) {

6,264,740✔

3780

    tlen = encoder.pos;

6,264,740✔

3782

  tEncoderClear(&encoder);

6,264,740✔

3783

  return tlen;

6,264,962✔

3786

int32_t tDeserializeSTriggerCalcRequest(void* buf, int32_t bufLen, SSTriggerCalcRequest* pReq) {

3,130,840✔

3787

  SDecoder decoder = {0};

3,130,840✔

3788

  int32_t  code = TSDB_CODE_SUCCESS;

3,131,602✔

3789

  int32_t  lino = 0;

3,131,602✔

3791

  tDecoderInit(&decoder, buf, bufLen);

3,131,602✔

3792

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

3,130,840✔

3794

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->streamId));

6,261,998✔

3795

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->runnerTaskId));

6,262,538✔

3796

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->sessionId));

6,262,760✔

3797

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->triggerType));

6,263,204✔

3798

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->gid));

6,263,204✔

3800

  TAOS_CHECK_EXIT(tDeserializeSTriggerCalcParam(&decoder, &pReq->params, false));

3,131,602✔

3801

  TAOS_CHECK_EXIT(tDeserializeStriggerGroupColVals(&decoder, &pReq->groupColVals));

3,131,602✔

3802

  TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->createTable));

6,263,204✔

3803

  if (!tDecodeIsEnd(&decoder)) {

3,130,840✔

3804

    TAOS_CHECK_EXIT(tDecodeBool(&decoder, &pReq->isWindowTrigger));

3,130,840✔

3805

    TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->precision));

6,262,442✔

3808

  tEndDecode(&decoder);

3,131,602✔

3810

_exit:

3,130,840✔

3811

  tDecoderClear(&decoder);

3,131,602✔

3812

  return code;

3,130,618✔

3815

void tDestroySTriggerCalcRequest(SSTriggerCalcRequest* pReq) {

8,720,245✔

3816

  if (pReq != NULL) {

8,720,245✔

3817

    if (pReq->params != NULL) {

8,720,245✔

3818

      taosArrayDestroyEx(pReq->params, tDestroySSTriggerCalcParam);

5,927,784✔

3819

      pReq->params = NULL;

5,927,562✔

3821

    if (pReq->groupColVals != NULL) {

8,720,245✔

3822

      taosArrayDestroyEx(pReq->groupColVals, tDestroySStreamGroupValue);

3,219,298✔

3823

      pReq->groupColVals = NULL;

3,219,298✔

3825

    blockDataDestroy(pReq->pOutBlock);

8,720,245✔

3827

8,720,023✔

3888

int32_t tSerializeSTriggerCtrlRequest(void* buf, int32_t bufLen, const SSTriggerCtrlRequest* pReq) {

39,928,532✔

3889

  SEncoder encoder = {0};

39,928,532✔

3890

  int32_t  code = TSDB_CODE_SUCCESS;

39,928,532✔

3891

  int32_t  lino = 0;

39,928,532✔

3892

  int32_t  tlen = 0;

39,928,532✔

3894

  tEncoderInit(&encoder, buf, bufLen);

39,928,532✔

3895

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

39,928,532✔

3897

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->type));

79,856,849✔

3898

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->streamId));

79,856,634✔

3899

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->taskId));

79,856,849✔

3900

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->sessionId));

79,856,634✔

3902

  tEndEncode(&encoder);

39,928,102✔

3904

_exit:

39,928,532✔

3905

  if (code != TSDB_CODE_SUCCESS) {

39,928,532✔

3908

    tlen = encoder.pos;

39,928,532✔

3910

  tEncoderClear(&encoder);

39,928,532✔

3911

  return tlen;

39,928,532✔

3914

int32_t tDeserializeSTriggerCtrlRequest(void* buf, int32_t bufLen, SSTriggerCtrlRequest* pReq) {

59,867,670✔

3915

  SDecoder decoder = {0};

59,867,670✔

3916

  int32_t  code = TSDB_CODE_SUCCESS;

59,871,736✔

3917

  int32_t  lino = 0;

59,871,736✔

3919

  tDecoderInit(&decoder, buf, bufLen);

59,871,736✔

3920

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

59,866,887✔

3922

  int32_t type = 0;

59,874,939✔

3923

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &type));

59,877,554✔

3924

  pReq->type = type;

59,877,554✔

3925

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->streamId));

119,751,302✔

3926

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->taskId));

119,758,074✔

3927

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->sessionId));

119,763,707✔

3929

  tEndDecode(&decoder);

59,881,324✔

3931

_exit:

59,870,721✔

3932

  tDecoderClear(&decoder);

59,871,181✔

3933

  return code;

59,855,148✔

3936

int32_t tSerializeStRtFuncInfo(SEncoder* pEncoder, const SStreamRuntimeFuncInfo* pInfo, bool full) {

30,829,109✔

3937

  int32_t code = 0, lino = 0;

30,829,109✔

3938

  TAOS_CHECK_EXIT(tSerializeSTriggerCalcParam(pEncoder, pInfo->pStreamPesudoFuncVals, true, full));

30,829,109✔

3939

  TAOS_CHECK_EXIT(tSerializeStriggerGroupColVals(pEncoder, pInfo->pStreamPartColVals, -1));

30,829,999✔

3940

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->curWindow.skey));

61,658,679✔

3941

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->curWindow.ekey));

61,658,341✔

3942

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->groupId));

61,658,639✔

3943

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pInfo->curIdx));

61,655,437✔

3944

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->sessionId));

61,652,815✔

3945

  TAOS_CHECK_EXIT(tEncodeBool(pEncoder, pInfo->withExternalWindow));

30,826,484✔

3946

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pInfo->triggerType));

61,656,693✔

3947

  TAOS_CHECK_EXIT(tEncodeBool(pEncoder, pInfo->isWindowTrigger));

30,829,322✔

3948

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pInfo->precision));

61,652,728✔

3949

_exit:

30,825,457✔

3950

  return code;

30,825,457✔

3953

int32_t tDeserializeStRtFuncInfo(SDecoder* pDecoder, SStreamRuntimeFuncInfo* pInfo) {

15,420,944✔

3954

  int32_t code = 0, lino = 0;

15,420,944✔

3955

  int32_t size = 0;

15,420,944✔

3956

  TAOS_CHECK_EXIT(tDeserializeSTriggerCalcParam(pDecoder, &pInfo->pStreamPesudoFuncVals, true));

15,420,944✔

3957

  TAOS_CHECK_EXIT(tDeserializeStriggerGroupColVals(pDecoder, &pInfo->pStreamPartColVals));

15,421,445✔

3958

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->curWindow.skey));

30,842,151✔

3959

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->curWindow.ekey));

30,842,222✔

3960

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->groupId));

30,841,997✔

3961

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pInfo->curIdx));

30,841,812✔

3962

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->sessionId));

30,842,189✔

3963

  TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &pInfo->withExternalWindow));

15,421,128✔

3964

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pInfo->triggerType));

30,841,357✔

3965

  if (!tDecodeIsEnd(pDecoder)) {

15,421,014✔

3966

    TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &pInfo->isWindowTrigger));

15,420,829✔

3967

    TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pInfo->precision));

30,842,459✔

3969

_exit:

15,421,630✔

3970

  return code;

15,421,630✔

3973

void tDestroyStRtFuncInfo(SStreamRuntimeFuncInfo* pInfo){

24,333,286✔

3974

  if (pInfo == NULL) return;

24,333,286✔

3975

  if (pInfo->pStreamPesudoFuncVals != NULL) {

24,333,286✔

3976

    taosArrayDestroyEx(pInfo->pStreamPesudoFuncVals, tDestroySSTriggerCalcParam);

13,110,335✔

3977

    pInfo->pStreamPesudoFuncVals = NULL;

13,110,351✔

3979

  if (pInfo->pStreamPartColVals != NULL) {

24,334,302✔

3980

    taosArrayDestroyEx(pInfo->pStreamPartColVals, tDestroySStreamGroupValue);

9,602,896✔

3981

    pInfo->pStreamPartColVals = NULL;

9,601,869✔

3985

int32_t tSerializeSStreamMsgVTableInfo(void* buf, int32_t bufLen, const SStreamMsgVTableInfo* pRsp){

150,382✔

3986

  SEncoder encoder = {0};

150,382✔

3987

  int32_t  code = TSDB_CODE_SUCCESS;

150,382✔

3988

  int32_t  lino = 0;

150,382✔

3989

  int32_t  tlen = 0;

150,382✔

3991

  tEncoderInit(&encoder, buf, bufLen);

150,382✔

3992

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

150,382✔

3994

  int32_t size = taosArrayGetSize(pRsp->infos);

150,382✔

3995

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, size));

150,382✔

3996

  for (int32_t i = 0; i < size; ++i) {

520,074✔

3997

    VTableInfo* info = taosArrayGet(pRsp->infos, i);

369,692✔

3998

    if (info == NULL) {

369,692✔

4001

    TAOS_CHECK_EXIT(tEncodeI64(&encoder, info->gId));

739,384✔

4002

    TAOS_CHECK_EXIT(tEncodeI64(&encoder, info->uid));

739,384✔

4003

    TAOS_CHECK_EXIT(tEncodeSColRefWrapper(&encoder, &info->cols));

369,692✔

4006

  tEndEncode(&encoder);

150,382✔

4008

_exit:

150,382✔

4009

  if (code != TSDB_CODE_SUCCESS) {

150,382✔

4012

    tlen = encoder.pos;

150,382✔

4014

  tEncoderClear(&encoder);

150,382✔

4015

  return tlen;

150,382✔

4018

int32_t tDeserializeSStreamMsgVTableInfo(void* buf, int32_t bufLen, SStreamMsgVTableInfo *vTableInfo){

75,191✔

4019

  SDecoder decoder = {0};

75,191✔

4020

  int32_t  code = TSDB_CODE_SUCCESS;

75,191✔

4021

  int32_t  lino = 0;

75,191✔

4022

  int32_t  size = 0;

75,191✔

4024

  tDecoderInit(&decoder, buf, bufLen);

75,191✔

4025

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

75,191✔

4027

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &size));

75,191✔

4028

  vTableInfo->infos = taosArrayInit(size, sizeof(VTableInfo));

75,191✔

4029

  if (vTableInfo->infos == NULL) {

75,191✔

4032

  for (int32_t i = 0; i < size; ++i) {

260,037✔

4033

    VTableInfo* info = taosArrayReserve(vTableInfo->infos, 1);

184,846✔

4034

    if (info == NULL) {

184,846✔

4037

    TAOS_CHECK_EXIT(tDecodeI64(&decoder, &info->gId));

369,692✔

4038

    TAOS_CHECK_EXIT(tDecodeI64(&decoder, &info->uid));

369,692✔

4039

    TAOS_CHECK_EXIT(tDecodeSColRefWrapperEx(&decoder, &info->cols, false));

184,846✔

4042

  tEndDecode(&decoder);

75,191✔

4044

_exit:

75,191✔

4045

  tDecoderClear(&decoder);

75,191✔

4046

  return code;

75,191✔

4050

void tDestroyVTableInfo(void *ptr) {

369,692✔

4051

  if (NULL == ptr) {

369,692✔

4054

  VTableInfo* pTable = (VTableInfo*)ptr;

369,692✔

4055

  taosMemoryFree(pTable->cols.pColRef);

369,692✔

4058

void tDestroySStreamMsgVTableInfo(SStreamMsgVTableInfo *ptr) {

27,767,501✔

4059

  if (ptr == NULL) return;

27,767,501✔

4060

  taosArrayDestroyEx(ptr->infos, tDestroyVTableInfo);

27,767,501✔

4061

  ptr->infos = NULL;

27,767,501✔

4064

int32_t tSerializeSStreamTsResponse(void* buf, int32_t bufLen, const SStreamTsResponse* pRsp) {

1,023,125✔

4065

  SEncoder encoder = {0};

1,023,125✔

4066

  int32_t  code = TSDB_CODE_SUCCESS;

1,023,481✔

4067

  int32_t  lino = 0;

1,023,481✔

4068

  int32_t  tlen = 0;

1,023,481✔

4070

  tEncoderInit(&encoder, buf, bufLen);

1,023,481✔

4071

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

1,023,019✔

4073

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRsp->ver));

2,046,963✔

4074

  int32_t size = taosArrayGetSize(pRsp->tsInfo);

1,022,791✔

4075

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, size));

1,023,481✔

4076

  for (int32_t i = 0; i < size; ++i) {

2,350,369✔

4077

    STsInfo* tsInfo = taosArrayGet(pRsp->tsInfo, i);

1,327,302✔

4078

    TAOS_CHECK_EXIT(tEncodeI64(&encoder, tsInfo->gId));

2,652,974✔

4079

    TAOS_CHECK_EXIT(tEncodeI64(&encoder, tsInfo->ts));

2,654,171✔

4082

  tEndEncode(&encoder);

1,023,067✔

4084

_exit:

1,022,650✔

4085

  if (code != TSDB_CODE_SUCCESS) {

1,022,650✔

4088

    tlen = encoder.pos;

1,022,650✔

4090

  tEncoderClear(&encoder);

1,022,650✔

4091

  return tlen;

1,022,560✔

4094

int32_t tDeserializeSStreamTsResponse(void* buf, int32_t bufLen, void *pBlock) {

512,297✔

4095

  SDecoder decoder = {0};

512,297✔

4096

  int32_t  code = TSDB_CODE_SUCCESS;

512,297✔

4097

  int32_t  lino = 0;

512,297✔

4098

  SSDataBlock *pResBlock = pBlock;

512,297✔

4100

  tDecoderInit(&decoder, buf, bufLen);

512,297✔

4101

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

512,297✔

4103

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, (int64_t*)&pResBlock->info.id.groupId));

1,024,594✔

4104

  int32_t numOfCols = 2;

512,297✔

4105

  if (pResBlock->pDataBlock == NULL) {

512,297✔

4106

    pResBlock->pDataBlock = taosArrayInit_s(sizeof(SColumnInfoData), numOfCols);

512,297✔

4107

    if (pResBlock->pDataBlock == NULL) {

512,297✔

4110

    for (int32_t i = 0; i< numOfCols; ++i) {

1,536,891✔

4111

      SColumnInfoData *pColInfoData = taosArrayGet(pResBlock->pDataBlock, i);

1,024,594✔

4112

      if (pColInfoData == NULL) {

1,024,594✔

4115

      pColInfoData->info.type = TSDB_DATA_TYPE_BIGINT;

1,024,594✔

4116

      pColInfoData->info.bytes = sizeof(int64_t);

1,024,594✔

4119

  int32_t numOfRows = 0;

512,297✔

4120

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &numOfRows));

512,297✔

4121

  TAOS_CHECK_EXIT(blockDataEnsureCapacity(pResBlock, numOfRows));

512,297✔

4122

  for (int32_t i = 0; i < numOfRows; ++i) {

1,177,542✔

4123

    for (int32_t j = 0; j < numOfCols; ++j) {

1,995,735✔

4124

      SColumnInfoData *pColInfoData = taosArrayGet(pResBlock->pDataBlock, j);

1,330,490✔

4125

      if (pColInfoData == NULL) {

1,330,490✔

4128

      int64_t value = 0;

1,330,490✔

4129

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &value));

1,330,490✔

4130

      colDataSetInt64(pColInfoData, i, &value);

1,330,490✔

4134

  pResBlock->info.dataLoad = 1;

512,297✔

4135

  pResBlock->info.rows = numOfRows;

512,297✔

4137

  tEndDecode(&decoder);

512,058✔

4139

_exit:

512,297✔

4140

  tDecoderClear(&decoder);

512,297✔

4141

  return code;

512,297✔

4144

static int32_t encodeData(SEncoder* encoder, void* pBlock, SSHashObj* indexHash) {

2,789,014✔

4145

  int32_t code = TSDB_CODE_SUCCESS;

2,789,014✔

4146

  int32_t lino = 0;

2,789,014✔

4147

  int32_t len = 0;

2,789,014✔

4148

  if (encoder->data == NULL){

2,789,014✔

4149

    len = blockGetEncodeSize(pBlock);

1,394,622✔

4151

    len = blockEncode(pBlock, (char*)(encoder->data + encoder->pos), encoder->size - encoder->pos, blockDataGetNumOfCols(pBlock));

1,394,392✔

4152

    if (len < 0) {

1,394,392✔

4156

  encoder->pos += len;

2,789,014✔

4158

  if (indexHash == NULL) {

2,788,784✔

4159

    goto _exit;

1,325,352✔

4162

  uint32_t pos = encoder->pos;

1,463,432✔

4163

  encoder->pos += sizeof(uint32_t); // reserve space for tables

1,463,892✔

4164

  int32_t tables = 0;

1,463,432✔

4166

  void*   pe = NULL;

1,463,432✔

4167

  int32_t iter = 0;

1,463,432✔

4168

  while ((pe = tSimpleHashIterate(indexHash, pe, &iter)) != NULL) {

3,157,009✔

4169

    SStreamWalDataSlice* pInfo = (SStreamWalDataSlice*)pe;

1,694,268✔

4170

    if (pInfo->gId == -1){

1,694,268✔

4173

    int64_t uid = *(int64_t*)(tSimpleHashGetKey(pe, NULL));

1,694,268✔

4174

    TAOS_CHECK_EXIT(tEncodeI64(encoder, uid));

1,694,268✔

4175

    TAOS_CHECK_EXIT(tEncodeU64(encoder, pInfo->gId));

3,388,536✔

4176

    TAOS_CHECK_EXIT(tEncodeI32(encoder, pInfo->startRowIdx));

3,388,306✔

4177

    TAOS_CHECK_EXIT(tEncodeI32(encoder, pInfo->numRows));

3,387,615✔

4178

    tables++;

1,693,577✔

4180

  uint32_t tmpPos = encoder->pos;

1,463,432✔

4181

  encoder->pos = pos;

1,463,892✔

4182

  TAOS_CHECK_EXIT(tEncodeI32(encoder, tables));

1,463,662✔

4183

  encoder->pos = tmpPos;

1,463,662✔

4184

_exit:

2,789,244✔

4185

  return code;

2,788,768✔

4188

static int32_t encodeBlock(SEncoder* encoder, void* block, SSHashObj* indexHash) {

9,533,258✔

4189

  int32_t  code = TSDB_CODE_SUCCESS;

9,533,258✔

4190

  int32_t  lino = 0;

9,533,258✔

4191

  if (block != NULL && ((SSDataBlock*)block)->info.rows > 0) {

9,533,258✔

4192

    TAOS_CHECK_EXIT(tEncodeI8(encoder, 1));

2,789,014✔

4193

    TAOS_CHECK_EXIT(encodeData(encoder, block, indexHash));

2,789,014✔

4195

    TAOS_CHECK_EXIT(tEncodeI8(encoder, 0));

6,744,017✔

4198

_exit:

6,744,017✔

4199

  return code;

9,532,785✔

4202

int32_t tSerializeSStreamWalDataResponse(void* buf, int32_t bufLen, SSTriggerWalNewRsp* rsp) {

2,383,834✔

4203

  SEncoder encoder = {0};

2,383,834✔

4204

  int32_t  code = TSDB_CODE_SUCCESS;

2,383,834✔

4205

  int32_t  lino = 0;

2,383,834✔

4206

  int32_t  tlen = 0;

2,383,834✔

4208

  tEncoderInit(&encoder, buf, bufLen);

2,383,834✔

4209

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

2,383,834✔

4211

  TAOS_CHECK_EXIT(encodeBlock(&encoder, rsp->dataBlock, rsp->indexHash));

2,383,834✔

4212

  TAOS_CHECK_EXIT(encodeBlock(&encoder, rsp->metaBlock, NULL));

2,383,834✔

4213

  TAOS_CHECK_EXIT(encodeBlock(&encoder, rsp->deleteBlock, NULL));

2,383,143✔

4214

  TAOS_CHECK_EXIT(encodeBlock(&encoder, rsp->tableBlock, NULL));

2,383,373✔

4216

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, rsp->ver));

4,766,736✔

4217

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, rsp->verTime));

4,766,967✔

4218

  tEndEncode(&encoder);

2,383,604✔

4220

_exit:

2,383,834✔

4221

  if (code != TSDB_CODE_SUCCESS) {

2,383,834✔

4224

    tlen = encoder.pos;

2,383,834✔

4226

  tEncoderClear(&encoder);

2,383,834✔

4227

  return tlen;

2,383,144✔

4230

static int32_t decodeBlock(SDecoder* decoder, void* pBlock) {

3,576,543✔

4231

  int32_t  code = TSDB_CODE_SUCCESS;

3,576,543✔

4232

  int32_t  lino = 0;

3,576,543✔

4234

  int8_t hasData = false;

3,576,543✔

4235

  TAOS_CHECK_EXIT(tDecodeI8(decoder, &hasData));

3,576,543✔

4236

  if (hasData) {

3,576,543✔

4237

    TAOS_CHECK_EXIT(pBlock != NULL ? TSDB_CODE_SUCCESS : TSDB_CODE_INVALID_PARA);

662,808✔

4238

    const char* pEndPos = NULL;

662,808✔

4239

    TAOS_CHECK_EXIT(blockDecode(pBlock, (char*)decoder->data + decoder->pos, &pEndPos));

662,808✔

4240

    decoder->pos = (uint8_t*)pEndPos - decoder->data;

662,808✔

4241

  } else if (pBlock != NULL) {

2,913,735✔

4242

    blockDataEmpty(pBlock);

1,318,887✔

4245

_exit:

3,574,290✔

4246

  return code;

3,576,543✔

4249

int32_t tDeserializeSStreamWalDataResponse(void* buf, int32_t bufLen, SSTriggerWalNewRsp* pRsp, SArray* pSlices){

1,192,181✔

4250

  SDecoder     decoder = {0};

1,192,181✔

4251

  int32_t      code = TSDB_CODE_SUCCESS;

1,192,181✔

4252

  int32_t      lino = 0;

1,192,181✔

4253

  SSDataBlock* pBlock = NULL;

1,192,181✔

4255

  tDecoderInit(&decoder, buf, bufLen);

1,192,181✔

4256

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

1,192,181✔

4259

  int8_t hasData = false;

1,192,181✔

4260

  TAOS_CHECK_EXIT(tDecodeI8(&decoder, &hasData));

1,192,181✔

4261

  pBlock = pRsp->dataBlock;

1,192,181✔

4262

  if (hasData) {

1,192,181✔

4263

    TAOS_CHECK_EXIT(pBlock != NULL ? TSDB_CODE_SUCCESS : TSDB_CODE_INVALID_PARA);

732,078✔

4264

    const char* pEndPos = NULL;

732,078✔

4265

    TAOS_CHECK_EXIT(blockDecode(pBlock, (char*)decoder.data + decoder.pos, &pEndPos));

732,078✔

4266

    decoder.pos = (uint8_t*)pEndPos - decoder.data;

731,846✔

4268

    int32_t nSlices = 0;

731,846✔

4269

    TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nSlices));

731,846✔

4270

    TAOS_CHECK_EXIT(taosArrayEnsureCap(pSlices, nSlices));

731,846✔

4271

    taosArrayClear(pSlices);

732,078✔

4272

    int64_t  uid = 0;

732,078✔

4273

    uint64_t gid = 0;

732,078✔

4274

    int32_t  startIdx = 0;

732,078✔

4275

    int32_t  numRows = 0;

732,078✔

4276

    for (int32_t i = 0; i < nSlices; i++) {

1,579,459✔

4277

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &uid));

847,381✔

4278

      TAOS_CHECK_EXIT(tDecodeU64(&decoder, &gid));

847,381✔

4279

      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &startIdx));

847,381✔

4280

      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &numRows));

847,381✔

4281

      int32_t endIdx = startIdx + numRows;

847,381✔

4282

      int64_t value[3] = {gid, uid, (int64_t)startIdx << 32 | endIdx};

847,381✔

4283

      void*   px = taosArrayPush(pSlices, value);

847,150✔

4284

      if (px == NULL) {

847,150✔

4289

  } else if (pBlock != NULL) {

460,103✔

4290

    blockDataEmpty(pBlock);

4,065✔

4291

    taosArrayClear(pSlices);

4,065✔

4294

  TAOS_CHECK_EXIT(decodeBlock(&decoder, pRsp->metaBlock));

1,192,181✔

4295

  TAOS_CHECK_EXIT(decodeBlock(&decoder, pRsp->deleteBlock));

1,192,181✔

4296

  TAOS_CHECK_EXIT(decodeBlock(&decoder, pRsp->tableBlock));

1,192,181✔

4298

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->ver));

2,384,362✔

4299

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->verTime));

2,384,362✔

4301

  tEndDecode(&decoder);

1,192,181✔

4303

_exit:

1,192,181✔

4304

  if (code != TSDB_CODE_SUCCESS) {

1,192,181✔

4307

  tDecoderClear(&decoder);

1,192,181✔

4308

  return code;

1,192,181✔

taosdata / TDengine / #4999

Source File
Press 'n' to go to next uncovered line, 'b' for previous

taosdata / TDengine / #4999

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