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

27

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

120,092✔

28

  int32_t code = 0;

120,092✔

29

  int32_t lino = 0;

120,092✔

30

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

240,184✔

31

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

240,184✔

32

  switch (pReq->type) {

120,092✔

33

    case STREAM_MGMT_REQ_TRIGGER_ORIGTBL_READER: {

114,922✔

34

      if (pReq->cont.pReqs) {

114,922✔

35

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

114,922✔

36

        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, num));

114,922✔

37

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

450,938✔

38

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

336,016✔

39

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

672,032✔

40

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

672,032✔

45

      break;

114,922✔

47

    case STREAM_MGMT_REQ_RUNNER_ORIGTBL_READER: {

5,170✔

48

      if (pReq->cont.pReqs) {

5,170✔

49

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

5,170✔

50

        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, num));

5,170✔

51

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

10,340✔

52

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

5,170✔

53

          int32_t vgIdNum = taosArrayGetSize(pDeploy->vgIds);

5,170✔

54

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

10,340✔

55

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

10,340✔

56

          TAOS_CHECK_EXIT(tEncodeI32(pEncoder, vgIdNum));

5,170✔

57

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

10,340✔

58

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

10,340✔

64

      break;

5,170✔

71

_exit:

120,092✔

73

  return code;

120,092✔

76

void tFreeRunnerOReaderDeployReq(void* param) {

7,755✔

77

  SStreamOReaderDeployReq* pReq = (SStreamOReaderDeployReq*)param;

7,755✔

78

  if (pReq) {

7,755✔

79

    taosArrayDestroy(pReq->vgIds);

7,755✔

81

7,755✔

83

void tFreeSStreamMgmtReq(SStreamMgmtReq* pReq) {

240,184✔

84

  if (NULL == pReq) {

240,184✔

85

    return;

60,046✔

88

  switch (pReq->type) {

180,138✔

89

    case STREAM_MGMT_REQ_TRIGGER_ORIGTBL_READER:

172,383✔

90

      taosArrayDestroy(pReq->cont.pReqs);

172,383✔

91

      break;

172,383✔

92

    case STREAM_MGMT_REQ_RUNNER_ORIGTBL_READER:

7,755✔

93

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

7,755✔

94

      break;

7,755✔

101

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

60,046✔

102

  *ppDst = NULL;

60,046✔

104

  if (NULL == pSrc) {

60,046✔

108

  int32_t code = 0, lino = 0;

60,046✔

109

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

60,046✔

110

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

60,046✔

112

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

60,046✔

113

  if (pSrc->cont.pReqs) {

60,046✔

114

    switch (pSrc->type) {

60,046✔

115

      case STREAM_MGMT_REQ_TRIGGER_ORIGTBL_READER:

57,461✔

116

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

57,461✔

117

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

57,461✔

118

        break;

57,461✔

119

      case STREAM_MGMT_REQ_RUNNER_ORIGTBL_READER: {

2,585✔

120

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

2,585✔

121

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

2,585✔

122

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

2,585✔

123

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

5,170✔

124

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

2,585✔

125

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

2,585✔

126

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

2,585✔

127

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

2,585✔

128

          pNew->execId = pReq->execId;

2,585✔

129

          pNew->uid = pReq->uid;

2,585✔

131

        break;

2,585✔

140

  if (code) {

60,046✔

146

  return code;

60,046✔

150

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

60,046✔

151

  int32_t code = 0;

60,046✔

152

  int32_t lino = 0;

60,046✔

154

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

120,092✔

155

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

120,092✔

156

  switch (pReq->type) {

60,046✔

157

    case STREAM_MGMT_REQ_TRIGGER_ORIGTBL_READER: {

57,461✔

158

      int32_t num = 0;

57,461✔

159

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &num));

57,461✔

160

      if (num > 0) {

57,461✔

161

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

57,461✔

162

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

57,461✔

163

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

225,469✔

164

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

168,008✔

165

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

168,008✔

166

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

168,008✔

169

      break;

57,461✔

171

    case STREAM_MGMT_REQ_RUNNER_ORIGTBL_READER: {

2,585✔

172

      int32_t num = 0, vgIdNum = 0;

2,585✔

173

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &num));

2,585✔

174

      if (num > 0) {

2,585✔

175

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

2,585✔

176

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

2,585✔

177

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

5,170✔

178

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

2,585✔

179

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

5,170✔

180

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

5,170✔

181

          TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgIdNum));

2,585✔

182

          if (vgIdNum > 0) {

2,585✔

183

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

2,585✔

184

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

2,585✔

186

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

5,170✔

187

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

2,585✔

188

            TAOS_CHECK_EXIT(tDecodeI32(pDecoder, vgId));

2,585✔

192

      break;

2,585✔

199

_exit:

60,046✔

201

  return code;

60,046✔

204

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

70,159,256✔

205

  int32_t code = 0;

70,159,256✔

208

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

140,318,512✔

209

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

140,318,512✔

210

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

140,318,512✔

212

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

140,318,512✔

213

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

140,318,512✔

214

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

140,318,512✔

215

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

140,318,512✔

217

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

140,318,512✔

218

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

140,318,512✔

219

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

140,318,512✔

220

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

140,318,512✔

221

  if (pTask->pMgmtReq) {

70,159,256✔

222

    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, 1));

120,092✔

223

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

120,092✔

225

    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, 0));

70,039,164✔

228

_exit:

70,039,164✔

230

  return code;

70,159,256✔

234

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

33,853,087✔

235

  int32_t code = 0;

33,853,087✔

238

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

67,706,174✔

239

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

67,706,174✔

240

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

67,706,174✔

242

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

67,706,174✔

243

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

67,706,174✔

244

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

67,706,174✔

245

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

67,706,174✔

247

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

67,706,174✔

248

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

67,706,174✔

249

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

67,706,174✔

250

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

67,706,174✔

251

  int32_t req = 0;

33,853,087✔

252

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &req));

33,853,087✔

253

  if (req) {

33,853,087✔

254

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

60,046✔

255

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

60,046✔

256

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

60,046✔

259

_exit:

33,853,087✔

261

  return code;

33,853,087✔

293

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

4,361,942✔

294

  int32_t code = 0;

4,361,942✔

297

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

8,723,884✔

298

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

8,723,884✔

299

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

8,723,884✔

300

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

8,723,884✔

301

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

8,723,884✔

303

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

4,361,942✔

304

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, recalcNum));

4,361,942✔

305

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

4,361,942✔

310

_exit:

4,361,942✔

312

  return code;

4,361,942✔

315

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

2,058,260✔

316

  int32_t code = 0;

2,058,260✔

319

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

4,116,520✔

320

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

4,116,520✔

321

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

4,116,520✔

322

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

4,116,520✔

323

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

4,116,520✔

325

  int32_t recalcNum = 0;

2,058,260✔

326

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &recalcNum));

2,058,260✔

327

  if (recalcNum > 0) {

2,058,260✔

335

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

2,058,260✔

340

_exit:

2,058,260✔

342

  return code;

2,058,260✔

346

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

34,059,386✔

347

  int32_t code = 0;

34,059,386✔

350

  TAOS_CHECK_EXIT(tStartEncode(pEncoder));

34,059,386✔

351

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

68,118,772✔

352

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

68,118,772✔

353

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

68,118,772✔

354

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

68,118,772✔

356

  int32_t vgLeaderNum = taosArrayGetSize(pReq->pVgLeaders);

34,059,386✔

357

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, vgLeaderNum));

34,059,386✔

358

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

131,901,256✔

359

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

97,841,870✔

360

    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, *vgId));

195,683,740✔

363

  int32_t statusNum = taosArrayGetSize(pReq->pStreamStatus);

34,059,386✔

364

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, statusNum));

34,059,386✔

365

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

100,480,340✔

366

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

66,420,954✔

367

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

66,420,954✔

370

  int32_t reqNum = taosArrayGetSize(pReq->pStreamReq);

34,059,386✔

371

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, reqNum));

34,059,386✔

372

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

34,179,478✔

373

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

120,092✔

374

    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, *idx));

240,184✔

377

  int32_t triggerNum = taosArrayGetSize(pReq->pTriggerStatus);

34,059,386✔

378

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, triggerNum));

34,059,386✔

379

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

38,421,328✔

380

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

4,361,942✔

381

    TAOS_CHECK_EXIT(tEncodeSSTriggerRuntimeStatus(pEncoder, pTrigger));

4,361,942✔

384

  tEndEncode(pEncoder);

34,059,386✔

386

_exit:

34,059,386✔

387

  if (code) {

34,059,386✔

390

    return pEncoder->pos;

34,059,386✔

394

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

16,315,433✔

395

  int32_t code = 0;

16,315,433✔

398

  TAOS_CHECK_EXIT(tStartDecode(pDecoder));

16,315,433✔

399

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

32,630,866✔

400

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

32,630,866✔

401

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

32,630,866✔

402

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

32,630,866✔

404

  int32_t vgLearderNum = 0;

16,315,433✔

405

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgLearderNum));

16,315,433✔

406

  if (vgLearderNum > 0) {

16,315,433✔

407

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

12,907,856✔

408

    if (NULL == pReq->pVgLeaders) {

12,907,856✔

413

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

64,074,906✔

414

    int32_t vgId = 0;

47,759,473✔

415

    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgId));

47,759,473✔

416

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

95,518,946✔

423

  int32_t statusNum = 0;

16,315,433✔

424

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &statusNum));

16,315,433✔

425

  if (statusNum > 0) {

16,315,433✔

426

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

1,100,369✔

427

    if (NULL == pReq->pStreamStatus) {

1,100,369✔

432

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

48,298,928✔

433

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

31,983,495✔

434

    if (NULL == pTask) {

31,983,495✔

438

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

31,983,495✔

442

  int32_t reqNum = 0;

16,315,433✔

443

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &reqNum));

16,315,433✔

444

  if (reqNum > 0) {

16,315,433✔

445

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

17,845✔

446

    if (NULL == pReq->pStreamReq) {

17,845✔

451

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

16,375,479✔

452

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

60,046✔

453

    if (NULL == pIdx) {

60,046✔

457

    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, pIdx));

60,046✔

461

  int32_t triggerNum = 0;

16,315,433✔

462

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &triggerNum));

16,315,433✔

463

  if (triggerNum > 0) {

16,315,433✔

464

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

518,055✔

465

    if (NULL == pReq->pTriggerStatus) {

518,055✔

470

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

18,373,693✔

471

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

2,058,260✔

472

    if (NULL == pStatus) {

2,058,260✔

476

    TAOS_CHECK_EXIT(tDecodeSSTriggerRuntimeStatus(pDecoder, pStatus));

2,058,260✔

480

  tEndDecode(pDecoder);

16,315,433✔

482

_exit:

16,315,433✔

483

  return code;

16,315,433✔

486

void tFreeSSTriggerRuntimeStatus(void* param) {

4,239,231✔

487

  SSTriggerRuntimeStatus* pStatus = (SSTriggerRuntimeStatus*)param;

4,239,231✔

488

  if (NULL == pStatus) {

4,239,231✔

491

  taosArrayDestroy(pStatus->userRecalcs);

4,239,231✔

494

void tCleanupStreamHbMsg(SStreamHbMsg* pMsg, bool deepClean) {

98,756,038✔

495

  if (pMsg == NULL) {

98,756,038✔

499

  taosArrayDestroy(pMsg->pVgLeaders);

98,756,038✔

500

  if (deepClean) {

98,756,038✔

501

    int32_t reqNum = taosArrayGetSize(pMsg->pStreamReq);

98,756,038✔

502

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

98,876,130✔

503

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

120,092✔

504

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

120,092✔

505

      if (NULL == pTask) {

120,092✔

509

      tFreeSStreamMgmtReq(pTask->pMgmtReq);

120,092✔

510

      taosMemoryFree(pTask->pMgmtReq);

120,092✔

513

  taosArrayDestroy(pMsg->pStreamReq);

98,756,038✔

514

  taosArrayDestroy(pMsg->pStreamStatus);

98,756,038✔

515

  taosArrayDestroyEx(pMsg->pTriggerStatus, tFreeSSTriggerRuntimeStatus);

98,756,038✔

518

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

565,696✔

519

  int32_t code = 0;

565,696✔

522

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

1,131,392✔

523

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

1,131,392✔

524

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

1,131,392✔

525

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

1,131,392✔

526

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

1,131,392✔

527

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

1,131,392✔

528

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

1,131,392✔

529

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

1,131,392✔

530

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

1,131,392✔

532

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

1,131,392✔

533

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

1,131,392✔

535

_exit:

565,696✔

537

  return code;

565,696✔

540

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

541,180✔

541

  int32_t code = 0;

541,180✔

544

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

1,082,360✔

545

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

1,082,360✔

547

_exit:

541,180✔

549

  return code;

541,180✔

553

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

1,106,876✔

554

  int32_t code = 0;

1,106,876✔

557

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

2,213,752✔

558

  if (pMsg->triggerReader) {

1,106,876✔

559

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

565,696✔

561

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

541,180✔

564

_exit:

541,180✔

566

  return code;

1,106,876✔

569

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

1,679,818✔

570

  int32_t code = 0;

1,679,818✔

573

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

3,359,636✔

574

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

3,359,636✔

575

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

1,679,818✔

577

_exit:

1,679,818✔

579

  return code;

1,679,818✔

582

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

1,085,688✔

583

  int32_t code = 0;

1,085,688✔

586

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

1,085,688✔

587

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

2,171,376✔

589

_exit:

1,085,688✔

591

  return code;

1,085,688✔

595

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

367,766✔

596

  int32_t code = 0;

367,766✔

599

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

735,532✔

600

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

735,532✔

601

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

735,532✔

602

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

735,532✔

603

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

735,532✔

604

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

735,532✔

605

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

735,532✔

606

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

735,532✔

607

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

735,532✔

608

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

367,766✔

609

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

735,532✔

611

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

367,766✔

612

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, addrSize));

367,766✔

613

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

468,894✔

614

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

101,128✔

615

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

202,256✔

617

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

735,532✔

618

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

735,532✔

619

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

735,532✔

621

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

735,532✔

622

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

735,532✔

623

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

735,532✔

624

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

735,532✔

626

  switch (pMsg->triggerType) {

367,766✔

627

    case WINDOW_TYPE_SESSION: {

15,030✔

629

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

30,060✔

630

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

30,060✔

631

      break;

15,030✔

633

    case WINDOW_TYPE_STATE: {

129,088✔

635

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

258,176✔

636

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

258,176✔

637

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

258,176✔

638

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

258,176✔

639

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

258,176✔

640

      int32_t stateWindowZerothLen =

129,088✔

641

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

129,088✔

642

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

258,176✔

643

      int32_t stateWindowExprLen =

129,088✔

644

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

129,088✔

645

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

258,176✔

646

      break;

129,088✔

648

    case WINDOW_TYPE_INTERVAL: {

132,574✔

650

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

265,148✔

651

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

265,148✔

652

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

265,148✔

653

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

265,148✔

654

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

265,148✔

655

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

265,148✔

656

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

265,148✔

657

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

265,148✔

658

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

265,148✔

659

      break;

132,574✔

661

    case WINDOW_TYPE_EVENT: {

47,564✔

663

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

47,564✔

664

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

47,564✔

666

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

95,128✔

667

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

95,128✔

668

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

95,128✔

669

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

95,128✔

670

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

95,128✔

671

      break;

47,564✔

673

    case WINDOW_TYPE_COUNT: {

30,386✔

675

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

30,386✔

676

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

60,772✔

678

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

60,772✔

679

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

60,772✔

680

      break;

30,386✔

682

    case WINDOW_TYPE_PERIOD: {

13,124✔

684

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

26,248✔

685

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

26,248✔

686

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

26,248✔

687

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

26,248✔

688

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

26,248✔

689

      break;

13,124✔

696

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

735,532✔

697

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

735,532✔

698

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

735,532✔

699

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

735,532✔

700

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

735,532✔

701

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

735,532✔

702

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

367,766✔

703

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

735,532✔

704

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

367,766✔

705

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

735,532✔

706

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

367,766✔

707

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

735,532✔

709

  int32_t readerNum = taosArrayGetSize(pMsg->readerList);

367,766✔

710

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, readerNum));

367,766✔

711

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

823,480✔

712

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

455,714✔

713

    TAOS_CHECK_EXIT(tEncodeSStreamTaskAddr(pEncoder, pAddr));

455,714✔

716

  int32_t runnerNum = taosArrayGetSize(pMsg->runnerList);

367,766✔

717

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, runnerNum));

367,766✔

718

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

1,453,454✔

719

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

1,085,688✔

720

    TAOS_CHECK_EXIT(tEncodeSStreamRunnerTarget(pEncoder, pTarget));

1,085,688✔

723

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

735,532✔

724

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

735,532✔

725

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

735,532✔

727

_exit:

367,766✔

729

  return code;

367,766✔

733

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

6,213,816✔

734

  int32_t code = 0;

6,213,816✔

737

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

12,427,632✔

738

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

12,427,632✔

739

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

12,427,632✔

740

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

12,427,632✔

741

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

12,427,632✔

742

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

12,427,632✔

744

_exit:

6,213,816✔

746

  return code;

6,213,816✔

750

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

1,216,578✔

751

  int32_t code = 0;

1,216,578✔

754

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

2,433,156✔

755

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

2,433,156✔

756

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

2,433,156✔

757

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

2,433,156✔

758

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

2,433,156✔

759

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

2,433,156✔

760

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

2,433,156✔

761

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

2,433,156✔

763

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

1,216,578✔

764

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, addrSize));

1,216,578✔

765

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

1,502,352✔

766

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

285,774✔

767

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

571,548✔

769

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

2,433,156✔

771

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

1,216,578✔

772

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, outColNum));

1,216,578✔

773

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

6,322,440✔

774

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

5,105,862✔

775

    TAOS_CHECK_EXIT(tSerializeSFieldWithOptions(pEncoder, pCol));

5,105,862✔

778

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

1,216,578✔

779

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, outTagNum));

1,216,578✔

780

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

2,324,532✔

781

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

1,107,954✔

782

    TAOS_CHECK_EXIT(tSerializeSFieldWithOptions(pEncoder, pTag));

1,107,954✔

785

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

2,433,156✔

786

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

2,433,156✔

788

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

2,433,156✔

789

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

2,433,156✔

791

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

1,216,578✔

792

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, forceOutColsSize));

1,216,578✔

793

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

1,351,500✔

794

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

134,922✔

795

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

134,922✔

797

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

269,844✔

798

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

269,844✔

799

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

269,844✔

800

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

269,844✔

801

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

269,844✔

804

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

2,433,156✔

807

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

1,216,578✔

808

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, colCidsSize));

1,216,578✔

809

  if (colCidsSize > 0) {

1,216,578✔

810

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

79,374✔

811

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

59,988✔

812

      TAOS_CHECK_EXIT(tEncodeI16(pEncoder, *pCid));

119,976✔

816

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

1,216,578✔

817

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, tagCidsSize));

1,216,578✔

818

  if (tagCidsSize > 0) {

1,216,578✔

819

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

39,228✔

820

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

24,048✔

821

      TAOS_CHECK_EXIT(tEncodeI16(pEncoder, *pCid));

48,096✔

825

_exit:

1,216,578✔

827

  return code;

1,216,578✔

830

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

2,691,220✔

831

  int32_t code = 0;

2,691,220✔

834

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

2,691,220✔

835

  switch (pTask->task.type) {

2,691,220✔

836

    case STREAM_READER_TASK:

1,106,876✔

837

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

1,106,876✔

838

      break;

1,106,876✔

839

    case STREAM_TRIGGER_TASK:

367,766✔

840

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

367,766✔

841

      break;

367,766✔

842

    case STREAM_RUNNER_TASK:

1,216,578✔

843

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

1,216,578✔

844

      break;

1,216,578✔

850

_exit:

2,691,220✔

852

  return code;

2,691,220✔

856

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

490,206✔

857

  int32_t code = 0;

490,206✔

860

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

980,412✔

862

  int32_t readerNum = taosArrayGetSize(pStream->readerTasks);

490,206✔

863

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, readerNum));

490,206✔

864

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

1,597,082✔

865

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

1,106,876✔

866

    TAOS_CHECK_EXIT(tEncodeSStmTaskDeploy(pEncoder, pDeploy));

1,106,876✔

869

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

980,412✔

870

  if (pStream->triggerTask) {

490,206✔

871

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

367,766✔

874

  int32_t runnerNum = taosArrayGetSize(pStream->runnerTasks);

490,206✔

875

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, runnerNum));

490,206✔

876

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

1,706,784✔

877

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

1,216,578✔

878

    TAOS_CHECK_EXIT(tEncodeSStmTaskDeploy(pEncoder, pDeploy));

1,216,578✔

881

_exit:

490,206✔

883

  return code;

490,206✔

886

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

1,047,082✔

887

  int32_t code = 0;

1,047,082✔

888

  int32_t lino = 0;

1,047,082✔

890

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

2,094,164✔

892

_exit:

1,047,082✔

893

  return code;

1,047,082✔

896

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

523,661✔

897

  int32_t code = 0;

523,661✔

900

  int32_t type = 0;

523,661✔

901

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &type));

523,661✔

902

  pMsg->msgType = type;

523,661✔

904

_exit:

523,661✔

905

  return code;

523,661✔

908

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

478,108✔

909

  int32_t code = 0;

478,108✔

912

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

478,108✔

914

_exit:

478,108✔

916

  return code;

478,108✔

919

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

478,108✔

920

  int32_t code = 0;

478,108✔

923

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

478,108✔

924

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

478,108✔

926

_exit:

478,108✔

928

  return code;

478,108✔

931

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

441,538✔

932

  int32_t code = 0;

441,538✔

935

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

441,538✔

936

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

883,076✔

937

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

883,076✔

939

_exit:

441,538✔

941

  return code;

441,538✔

944

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

441,538✔

945

  int32_t code = 0;

441,538✔

948

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

441,538✔

949

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

441,538✔

951

_exit:

441,538✔

953

  return code;

441,538✔

957

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

7,344✔

958

  int32_t code = 0;

7,344✔

961

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

14,688✔

962

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

14,688✔

963

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

14,688✔

965

_exit:

7,344✔

967

  return code;

7,344✔

970

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

127,436✔

971

  int32_t code = 0;

127,436✔

974

  switch (msgType) {

127,436✔

975

    case STREAM_MSG_ORIGTBL_READER_INFO: {

114,922✔

976

      int32_t vgNum = taosArrayGetSize(pRsp->vgIds);

114,922✔

977

      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, vgNum));

114,922✔

979

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

450,938✔

980

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

336,016✔

981

        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, *vgId));

672,032✔

984

      int32_t readerNum = taosArrayGetSize(pRsp->readerList);

114,922✔

985

      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, readerNum));

114,922✔

987

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

223,782✔

988

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

108,860✔

989

        TAOS_CHECK_EXIT(tEncodeSStreamTaskAddr(pEncoder, addr));

108,860✔

991

      break;

114,922✔

1003

    case STREAM_MSG_USER_RECALC: {

7,344✔

1004

      int32_t recalcNum = taosArrayGetSize(pRsp->recalcList);

7,344✔

1005

      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, recalcNum));

7,344✔

1007

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

14,688✔

1008

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

7,344✔

1009

        TAOS_CHECK_EXIT(tEncodeSStreamRecalcReq(pEncoder, recalc));

7,344✔

1011

      break;

7,344✔

1013

    case STREAM_MSG_RUNNER_ORIGTBL_READER: {

5,170✔

1014

      int32_t rspNum = taosArrayGetSize(pRsp->execRspList);

5,170✔

1015

      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, rspNum));

5,170✔

1017

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

10,340✔

1018

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

5,170✔

1019

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

10,340✔

1020

        int32_t vgNum = taosArrayGetSize(pDeployRsp->vgList);

5,170✔

1021

        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, vgNum));

5,170✔

1022

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

10,340✔

1023

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

5,170✔

1026

      break;

5,170✔

1032

_exit:

127,436✔

1034

  return code;

127,436✔

1037

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

127,436✔

1038

  int32_t code = 0;

127,436✔

1041

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

127,436✔

1042

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

254,872✔

1043

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

254,872✔

1044

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

127,436✔

1045

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

127,436✔

1047

_exit:

127,436✔

1049

  return code;

127,436✔

1053

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

32,349,782✔

1054

  int32_t code = 0;

32,349,782✔

1057

  TAOS_CHECK_EXIT(tStartEncode(pEncoder));

32,349,782✔

1058

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

64,699,564✔

1059

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

32,349,782✔

1060

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, deployNum));

32,349,782✔

1061

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

32,839,988✔

1062

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

490,206✔

1063

    TAOS_CHECK_EXIT(tEncodeSStmStreamDeploy(pEncoder, pStream));

490,206✔

1066

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

32,349,782✔

1067

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, startNum));

32,349,782✔

1068

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

32,827,890✔

1069

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

478,108✔

1070

    TAOS_CHECK_EXIT(tEncodeSStreamTaskStart(pEncoder, pTask));

478,108✔

1073

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

64,699,564✔

1074

  if (!pRsp->undeploy.undeployAll) {

32,349,782✔

1075

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

32,349,782✔

1076

    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, undeployNum));

32,349,782✔

1077

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

32,791,320✔

1078

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

441,538✔

1079

      TAOS_CHECK_EXIT(tEncodeSStreamTaskUndeploy(pEncoder, pTask));

441,538✔

1083

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

32,349,782✔

1084

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, rspNum));

32,349,782✔

1085

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

32,477,218✔

1086

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

127,436✔

1087

    TAOS_CHECK_EXIT(tEncodeSStreamMgmtRsp(pEncoder, pMgmtRsp));

127,436✔

1090

_exit:

32,349,782✔

1092

  tEndEncode(pEncoder);

32,349,782✔

1094

  return code;

32,349,782✔

1097

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

282,881✔

1098

  int32_t code = 0;

282,881✔

1101

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

565,762✔

1102

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

565,762✔

1103

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

565,762✔

1104

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

565,762✔

1105

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

565,762✔

1106

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

565,762✔

1107

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

565,762✔

1108

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

565,762✔

1109

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

565,762✔

1110

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

565,762✔

1111

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

565,762✔

1113

_exit:

282,881✔

1115

  return code;

282,881✔

1119

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

270,623✔

1120

  int32_t code = 0;

270,623✔

1123

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

541,246✔

1124

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

541,246✔

1126

_exit:

270,623✔

1128

  return code;

270,623✔

1132

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

553,504✔

1133

  int32_t code = 0;

553,504✔

1136

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

1,107,008✔

1137

  if (pMsg->triggerReader) {

553,504✔

1138

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

282,881✔

1140

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

270,623✔

1143

_exit:

270,623✔

1145

  return code;

553,504✔

1149

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

840,336✔

1150

  int32_t code = 0;

840,336✔

1153

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

1,680,672✔

1154

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

1,680,672✔

1155

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

840,336✔

1157

_exit:

840,336✔

1159

  return code;

840,336✔

1163

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

543,003✔

1164

  int32_t code = 0;

543,003✔

1167

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

543,003✔

1168

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

1,086,006✔

1170

_exit:

543,003✔

1172

  return code;

543,003✔

1176

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

183,936✔

1177

  int32_t code = 0;

183,936✔

1180

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

367,872✔

1181

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

367,872✔

1182

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

367,872✔

1183

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

367,872✔

1184

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

367,872✔

1185

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

367,872✔

1186

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

367,872✔

1187

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

367,872✔

1188

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

367,872✔

1189

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

367,872✔

1191

  int32_t addrSize = 0;

183,936✔

1192

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &addrSize));

183,936✔

1193

  if (addrSize > 0) {

183,936✔

1194

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

50,564✔

1195

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

50,564✔

1197

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

234,500✔

1198

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

50,564✔

1199

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

50,564✔

1201

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

367,872✔

1202

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

367,872✔

1203

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

367,872✔

1205

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

367,872✔

1206

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

367,872✔

1207

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

367,872✔

1208

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

367,872✔

1210

  switch (pMsg->triggerType) {

183,936✔

1211

    case WINDOW_TYPE_SESSION:

7,515✔

1213

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

15,030✔

1214

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

15,030✔

1215

      break;

7,515✔

1216

    case WINDOW_TYPE_STATE:

64,544✔

1218

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

129,088✔

1219

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

129,088✔

1220

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

129,088✔

1221

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

129,088✔

1222

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

129,088✔

1223

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

129,088✔

1224

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

129,088✔

1225

      break;

64,544✔

1227

    case WINDOW_TYPE_INTERVAL:

66,340✔

1229

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

132,680✔

1230

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

132,680✔

1231

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

132,680✔

1232

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

132,680✔

1233

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

132,680✔

1234

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

132,680✔

1235

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

132,680✔

1236

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

132,680✔

1237

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

132,680✔

1238

      break;

66,340✔

1240

    case WINDOW_TYPE_EVENT:

23,782✔

1242

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

47,564✔

1243

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

47,564✔

1244

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

47,564✔

1245

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

47,564✔

1246

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

47,564✔

1247

      break;

23,782✔

1249

    case WINDOW_TYPE_COUNT:

15,193✔

1251

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

30,386✔

1253

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

30,386✔

1254

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

30,386✔

1255

      break;

15,193✔

1257

    case WINDOW_TYPE_PERIOD:

6,562✔

1259

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

13,124✔

1260

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

13,124✔

1261

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

13,124✔

1262

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

13,124✔

1263

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

13,124✔

1264

      break;

6,562✔

1270

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

367,872✔

1271

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

367,872✔

1272

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

367,872✔

1273

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

367,872✔

1274

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

367,872✔

1275

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

367,872✔

1276

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

367,872✔

1277

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

367,872✔

1278

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

367,872✔

1280

  int32_t readerNum = 0;

183,936✔

1281

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &readerNum));

183,936✔

1282

  if (readerNum > 0) {

183,936✔

1283

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

183,018✔

1284

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

183,018✔

1286

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

411,883✔

1287

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

227,947✔

1288

    TAOS_CHECK_EXIT(tDecodeSStreamTaskAddr(pDecoder, pAddr));

227,947✔

1291

  int32_t runnerNum = 0;

183,936✔

1292

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &runnerNum));

183,936✔

1293

  if (runnerNum > 0) {

183,936✔

1294

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

181,001✔

1295

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

181,001✔

1297

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

726,939✔

1298

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

543,003✔

1299

    TAOS_CHECK_EXIT(tDecodeSStreamRunnerTarget(pDecoder, pTarget));

543,003✔

1302

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

367,872✔

1303

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

367,872✔

1304

  if (!tDecodeIsEnd(pDecoder)) {

183,936✔

1305

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

367,872✔

1308

_exit:

183,936✔

1310

  return code;

183,936✔

1315

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

3,107,423✔

1316

  int32_t code = 0;

3,107,423✔

1319

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

3,107,423✔

1320

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

6,214,846✔

1321

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

6,214,846✔

1322

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

6,214,846✔

1323

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

6,214,846✔

1324

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

6,214,846✔

1326

_exit:

3,107,423✔

1328

  return code;

3,107,423✔

1331

void destroySStreamOutCols(void* p){

67,461✔

1332

  if (p == NULL) return;

67,461✔

1333

  SStreamOutCol* col = (SStreamOutCol*)p;

67,461✔

1334

  taosMemoryFreeClear(col->expr);

67,461✔

1337

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

608,491✔

1338

  int32_t code = 0;

608,491✔

1341

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

1,216,982✔

1342

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

1,216,982✔

1343

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

1,216,982✔

1344

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

1,216,982✔

1345

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

1,216,982✔

1346

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

1,216,982✔

1347

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

1,216,982✔

1348

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

1,216,982✔

1350

  int32_t addrSize = 0;

608,491✔

1351

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &addrSize));

608,491✔

1352

  if (addrSize > 0) {

608,491✔

1353

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

142,887✔

1354

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

142,887✔

1356

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

751,378✔

1357

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

142,887✔

1358

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

142,887✔

1360

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

1,216,982✔

1362

  int32_t outColNum = 0;

608,491✔

1363

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &outColNum));

608,491✔

1364

  if (outColNum > 0) {

608,491✔

1365

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

608,491✔

1366

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

608,491✔

1368

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

3,161,826✔

1369

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

2,553,335✔

1370

    TAOS_CHECK_EXIT(tDeserializeSFieldWithOptions(pDecoder, pCol));

2,553,335✔

1373

  int32_t outTagNum = 0;

608,491✔

1374

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &outTagNum));

608,491✔

1375

  if (outTagNum > 0) {

608,491✔

1376

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

269,337✔

1377

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

269,337✔

1379

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

1,162,579✔

1380

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

554,088✔

1381

    TAOS_CHECK_EXIT(tDeserializeSFieldWithOptions(pDecoder, pTag));

554,088✔

1384

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

1,216,982✔

1385

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

1,216,982✔

1387

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

1,216,982✔

1388

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

1,216,982✔

1390

  int32_t forceOutColsSize = 0;

608,491✔

1391

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &forceOutColsSize));

608,491✔

1392

  if (forceOutColsSize > 0) {

608,491✔

1393

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

12,066✔

1394

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

12,066✔

1396

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

675,952✔

1397

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

67,461✔

1399

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

134,922✔

1400

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

134,922✔

1401

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

134,922✔

1402

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

134,922✔

1403

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

134,922✔

1406

  if (!tDecodeIsEnd(pDecoder)) {

608,491✔

1407

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

1,216,982✔

1412

  if (!tDecodeIsEnd(pDecoder)) {

608,491✔

1413

    int32_t colCidsSize = 0;

608,491✔

1414

    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &colCidsSize));

608,491✔

1415

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

608,491✔

1416

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

9,693✔

1417

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

9,693✔

1418

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

39,687✔

1419

        int16_t cid = 0;

29,994✔

1420

        TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &cid));

29,994✔

1421

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

59,988✔

1428

  if (!tDecodeIsEnd(pDecoder)) {

608,491✔

1429

    int32_t tagCidsSize = 0;

608,491✔

1430

    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &tagCidsSize));

608,491✔

1431

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

608,491✔

1432

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

7,590✔

1433

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

7,590✔

1434

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

19,614✔

1435

        int16_t cid = 0;

12,024✔

1436

        TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &cid));

12,024✔

1437

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

24,048✔

1444

_exit:

606,781✔

1446

  return code;

608,491✔

1449

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

1,345,931✔

1450

  int32_t code = 0;

1,345,931✔

1453

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

1,345,931✔

1454

  switch (pTask->task.type) {

1,345,931✔

1455

    case STREAM_READER_TASK:

553,504✔

1456

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

553,504✔

1457

      break;

553,504✔

1458

    case STREAM_TRIGGER_TASK:

183,936✔

1459

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

183,936✔

1460

      break;

183,936✔

1461

    case STREAM_RUNNER_TASK:

608,491✔

1462

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

608,491✔

1463

      break;

608,491✔

1469

_exit:

1,345,931✔

1471

  return code;

1,345,931✔

1475

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

245,248✔

1476

  int32_t code = 0;

245,248✔

1479

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

490,496✔

1481

  int32_t readerNum = 0;

245,248✔

1482

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &readerNum));

245,248✔

1483

  if (readerNum > 0) {

245,248✔

1484

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

235,434✔

1485

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

235,434✔

1487

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

798,752✔

1488

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

553,504✔

1489

    TAOS_CHECK_EXIT(tDecodeSStmTaskDeploy(pDecoder, pTask));

553,504✔

1492

  int32_t triggerTask = 0;

245,248✔

1493

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &triggerTask));

245,248✔

1494

  if (triggerTask) {

245,248✔

1495

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

183,936✔

1496

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

183,936✔

1497

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

183,936✔

1500

  int32_t runnerNum = 0;

245,248✔

1501

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &runnerNum));

245,248✔

1502

  if (runnerNum > 0) {

245,248✔

1503

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

186,649✔

1504

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

186,649✔

1506

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

853,739✔

1507

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

608,491✔

1508

    TAOS_CHECK_EXIT(tDecodeSStmTaskDeploy(pDecoder, pTask));

608,491✔

1511

_exit:

245,248✔

1513

  return code;

245,248✔

1517

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

239,107✔

1518

  int32_t code = 0;

239,107✔

1521

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

239,107✔

1523

_exit:

239,107✔

1525

  return code;

239,107✔

1529

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

239,107✔

1530

  int32_t code = 0;

239,107✔

1533

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

239,107✔

1534

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

239,107✔

1536

_exit:

239,107✔

1538

  return code;

239,107✔

1542

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

220,836✔

1543

  int32_t code = 0;

220,836✔

1546

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

220,836✔

1547

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

441,672✔

1548

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

441,672✔

1550

_exit:

220,836✔

1552

  return code;

220,836✔

1556

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

220,836✔

1557

  int32_t code = 0;

220,836✔

1560

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

220,836✔

1561

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

220,836✔

1563

_exit:

220,836✔

1565

  return code;

220,836✔

1568

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

3,672✔

1569

  int32_t code = 0;

3,672✔

1572

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

7,344✔

1573

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

7,344✔

1574

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

7,344✔

1576

_exit:

3,672✔

1578

  return code;

3,672✔

1581

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

63,718✔

1582

  int32_t code = 0;

63,718✔

1585

  switch (msgType) {

63,718✔

1586

    case STREAM_MSG_ORIGTBL_READER_INFO: {

57,461✔

1587

      int32_t vgNum = 0;

57,461✔

1588

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgNum));

57,461✔

1589

      if (vgNum > 0) {

57,461✔

1590

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

57,461✔

1591

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

57,461✔

1593

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

225,469✔

1594

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

168,008✔

1595

        TAOS_CHECK_EXIT(tDecodeI32(pDecoder, vgId));

168,008✔

1598

      int32_t readerNum = 0;

57,461✔

1599

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &readerNum));

57,461✔

1600

      if (readerNum > 0) {

57,461✔

1601

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

47,231✔

1602

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

47,231✔

1604

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

111,891✔

1605

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

54,430✔

1606

        TAOS_CHECK_EXIT(tDecodeSStreamTaskAddr(pDecoder, addr));

54,430✔

1608

      break;

57,461✔

1623

    case STREAM_MSG_USER_RECALC: {

3,672✔

1624

      int32_t recalcNum = 0;

3,672✔

1625

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &recalcNum));

3,672✔

1626

      if (recalcNum > 0) {

3,672✔

1627

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

3,672✔

1628

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

3,672✔

1630

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

7,344✔

1631

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

3,672✔

1632

        TAOS_CHECK_EXIT(tDecodeSStreamRecalcReq(pDecoder, recalc));

3,672✔

1634

      break;

3,672✔

1636

    case STREAM_MSG_RUNNER_ORIGTBL_READER: {

2,585✔

1637

      int32_t rspNum = 0, vgNum = 0;

2,585✔

1638

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &rspNum));

2,585✔

1639

      if (rspNum > 0) {

2,585✔

1640

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

2,585✔

1641

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

2,585✔

1643

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

5,170✔

1644

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

2,585✔

1645

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

5,170✔

1646

        TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgNum));

2,585✔

1647

        if (vgNum > 0) {

2,585✔

1648

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

2,585✔

1649

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

2,585✔

1651

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

5,170✔

1652

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

2,585✔

1653

          TAOS_CHECK_EXIT(tDecodeSStreamTaskAddr(pDecoder, pAddr));

2,585✔

1656

      break;

2,585✔

1662

_exit:

63,718✔

1664

  return code;

63,718✔

1668

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

63,718✔

1669

  int32_t code = 0;

63,718✔

1672

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

63,718✔

1673

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

127,436✔

1674

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

127,436✔

1675

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

63,718✔

1676

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

63,718✔

1678

_exit:

63,718✔

1680

  return code;

63,718✔

1683

void tFreeSStreamOReaderDeployRsp(void* param) {

5,170✔

1684

  if (NULL == param) {

5,170✔

1688

  SStreamOReaderDeployRsp* pRsp = (SStreamOReaderDeployRsp*)param;

5,170✔

1689

  taosArrayDestroy(pRsp->vgList);

5,170✔

1692

void tFreeSStreamMgmtRsp(void* param) {

127,436✔

1693

  if (NULL == param) {

127,436✔

1697

  SStreamMgmtRsp* pRsp = (SStreamMgmtRsp*)param;

127,436✔

1699

  taosArrayDestroy(pRsp->cont.vgIds);

127,436✔

1700

  taosArrayDestroy(pRsp->cont.readerList);

127,436✔

1701

  taosArrayDestroy(pRsp->cont.runnerList);

127,436✔

1702

  taosArrayDestroy(pRsp->cont.recalcList);

127,436✔

1703

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

127,436✔

1706

void tFreeSStreamReaderDeployMsg(SStreamReaderDeployMsg* pReader) {

553,504✔

1707

  if (NULL == pReader) {

553,504✔

1711

  if (pReader->triggerReader) {

553,504✔

1712

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

282,881✔

1713

    taosMemoryFree(pMsg->triggerTblName);

282,881✔

1714

    taosMemoryFree(pMsg->partitionCols);

282,881✔

1715

    taosMemoryFree(pMsg->triggerCols);

282,881✔

1716

    taosMemoryFree(pMsg->triggerScanPlan);

282,881✔

1717

    taosMemoryFree(pMsg->calcCacheScanPlan);

282,881✔

1719

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

270,623✔

1720

    taosMemoryFree(pMsg->calcScanPlan);

270,623✔

1732

void tFreeSStreamTriggerDeployMsg(SStreamTriggerDeployMsg* pTrigger) {

183,936✔

1733

  if (NULL == pTrigger) {

183,936✔

1737

  taosArrayDestroyEx(pTrigger->pNotifyAddrUrls, tFreeStreamNotifyUrl);

183,936✔

1738

  switch (pTrigger->triggerType) {

183,936✔

1739

    case WINDOW_TYPE_STATE:

64,544✔

1740

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

64,544✔

1741

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

64,544✔

1742

      break;

64,544✔

1743

    case WINDOW_TYPE_EVENT:

23,782✔

1744

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

23,782✔

1745

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

23,782✔

1746

      break;

23,782✔

1747

    case WINDOW_TYPE_COUNT:

15,193✔

1748

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

15,193✔

1749

      break;

15,193✔

1750

    default:

80,417✔

1751

      break;

80,417✔

1754

  taosMemoryFree(pTrigger->partitionCols);

183,936✔

1755

  taosMemoryFree(pTrigger->triggerPrevFilter);

183,936✔

1756

  taosMemoryFree(pTrigger->triggerScanPlan);

183,936✔

1757

  taosMemoryFree(pTrigger->calcCacheScanPlan);

183,936✔

1759

  taosArrayDestroy(pTrigger->readerList);

183,936✔

1760

  taosArrayDestroy(pTrigger->runnerList);

183,936✔

1761

  taosMemoryFree(pTrigger->streamName);

183,936✔

1773

void tFreeSStreamRunnerDeployMsg(SStreamRunnerDeployMsg* pRunner) {

608,491✔

1774

  if (NULL == pRunner) {

608,491✔

1778

  taosMemoryFree(pRunner->streamName);

608,491✔

1779

  taosMemoryFree(pRunner->pPlan);

608,491✔

1780

  taosMemoryFree(pRunner->outDBFName);

608,491✔

1781

  taosMemoryFree(pRunner->outTblName);

608,491✔

1783

  taosArrayDestroyEx(pRunner->pNotifyAddrUrls, tFreeStreamNotifyUrl);

608,491✔

1784

  taosArrayDestroy(pRunner->outCols);

608,491✔

1785

  taosArrayDestroy(pRunner->outTags);

608,491✔

1787

  taosMemoryFree(pRunner->subTblNameExpr);

608,491✔

1788

  taosMemoryFree(pRunner->tagValueExpr);

608,491✔

1789

  taosArrayDestroyEx(pRunner->forceOutCols, tFreeSStreamOutCol);

608,491✔

1792

void tFreeSStmTaskDeploy(void* param) {

1,652,346✔

1793

  if (NULL == param) {

1,652,346✔

1794

    return;

306,415✔

1797

  SStmTaskDeploy* pTask = (SStmTaskDeploy*)param;

1,345,931✔

1798

  switch (pTask->task.type)  {

1,345,931✔

1799

    case STREAM_READER_TASK:

553,504✔

1800

      tFreeSStreamReaderDeployMsg(&pTask->msg.reader);

553,504✔

1801

      break;

553,504✔

1802

    case STREAM_TRIGGER_TASK:

183,936✔

1803

      tFreeSStreamTriggerDeployMsg(&pTask->msg.trigger);

183,936✔

1804

      break;

183,936✔

1805

    case STREAM_RUNNER_TASK:

608,491✔

1806

      tFreeSStreamRunnerDeployMsg(&pTask->msg.runner);

608,491✔

1807

      break;

608,491✔

1814

void tFreeSStmStreamDeploy(void* param) {

245,103✔

1815

  if (NULL == param) {

245,103✔

1819

  SStmStreamDeploy* pDeploy = (SStmStreamDeploy*)param;

245,103✔

1820

  int32_t readerNum = taosArrayGetSize(pDeploy->readerTasks);

245,103✔

1821

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

798,541✔

1822

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

553,438✔

1823

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

553,438✔

1824

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

262,733✔

1827

  taosArrayDestroy(pDeploy->readerTasks);

245,103✔

1829

  if (pDeploy->triggerTask) {

245,103✔

1830

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

183,883✔

1831

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

183,883✔

1832

    taosMemoryFree(pDeploy->triggerTask);

183,883✔

1835

  int32_t runnerNum = taosArrayGetSize(pDeploy->runnerTasks);

245,103✔

1836

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

853,392✔

1837

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

608,289✔

1838

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

608,289✔

1840

  taosArrayDestroy(pDeploy->runnerTasks);

245,103✔

1843

void tDeepFreeSStmStreamDeploy(void* param) {

490,351✔

1844

  if (NULL == param) {

490,351✔

1848

  SStmStreamDeploy* pDeploy = (SStmStreamDeploy*)param;

490,351✔

1849

  taosArrayDestroyEx(pDeploy->readerTasks, tFreeSStmTaskDeploy);

490,351✔

1850

  tFreeSStmTaskDeploy(pDeploy->triggerTask);

490,351✔

1851

  taosMemoryFree(pDeploy->triggerTask);

490,351✔

1852

  taosArrayDestroyEx(pDeploy->runnerTasks, tFreeSStmTaskDeploy);

490,351✔

1856

void tFreeSMStreamHbRspMsg(SMStreamHbRspMsg* pRsp) {

32,630,866✔

1857

  if (NULL == pRsp) {

32,630,866✔

1860

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

32,630,866✔

1861

  taosArrayDestroy(pRsp->start.taskList);

32,630,866✔

1862

  taosArrayDestroy(pRsp->undeploy.taskList);

32,630,866✔

1863

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

32,630,866✔

1866

void tDeepFreeSMStreamHbRspMsg(SMStreamHbRspMsg* pRsp) {

16,125,716✔

1867

  if (NULL == pRsp) {

16,125,716✔

1870

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

16,125,716✔

1871

  taosArrayDestroy(pRsp->start.taskList);

16,125,716✔

1872

  taosArrayDestroy(pRsp->undeploy.taskList);

16,125,716✔

1873

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

16,125,716✔

1878

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

16,125,716✔

1879

  int32_t code = 0;

16,125,716✔

1882

  TAOS_CHECK_EXIT(tStartDecode(pDecoder));

16,125,716✔

1883

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

32,251,432✔

1884

  int32_t deployNum = 0;

16,125,716✔

1885

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &deployNum));

16,125,716✔

1886

  if (deployNum > 0) {

16,125,716✔

1887

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

64,606✔

1888

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

64,606✔

1890

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

16,370,964✔

1891

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

245,248✔

1892

    TAOS_CHECK_EXIT(tDecodeSStmStreamDeploy(pDecoder, pStream));

245,248✔

1895

  int32_t startNum = 0;

16,125,716✔

1896

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &startNum));

16,125,716✔

1897

  if (startNum > 0) {

16,125,716✔

1898

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

102,984✔

1899

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

102,984✔

1901

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

16,364,823✔

1902

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

239,107✔

1903

    TAOS_CHECK_EXIT(tDecodeSStreamTaskStart(pDecoder, pTask));

239,107✔

1906

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

32,251,432✔

1907

  if (!pRsp->undeploy.undeployAll) {

16,125,716✔

1908

    int32_t undeployNum = 0;

16,125,716✔

1909

    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &undeployNum));

16,125,716✔

1910

    if (undeployNum > 0) {

16,125,716✔

1911

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

31,169✔

1912

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

31,169✔

1914

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

16,346,552✔

1915

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

220,836✔

1916

      TAOS_CHECK_EXIT(tDecodeSStreamTaskUndeploy(pDecoder, pTask));

220,836✔

1920

  int32_t rspNum = 0;

16,125,716✔

1921

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &rspNum));

16,125,716✔

1922

  if (rspNum > 0) {

16,125,716✔

1923

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

21,302✔

1924

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

21,302✔

1925

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

85,020✔

1926

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

63,718✔

1927

      TAOS_CHECK_EXIT(tDecodeSStreamMgmtRsp(pDecoder, pMgmtRsp));

63,718✔

1931

  tEndDecode(pDecoder);

16,125,716✔

1933

_exit:

16,125,716✔

1934

  return code;

16,125,716✔

1991

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

1,523,572✔

1992

  int32_t code = TSDB_CODE_SUCCESS;

1,523,572✔

1993

  int32_t lino = 0;

1,523,572✔

1995

  char*   json = NULL;

1,523,572✔

1996

  int32_t jsonLen = 0;

1,523,572✔

1997

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

1,523,572✔

1998

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

3,047,144✔

2000

_exit:

1,523,572✔

2001

  taosMemoryFreeClear(json);

1,523,572✔

2002

  if (code) {

1,523,572✔

2006

  return 0;

1,523,572✔

2009

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

769,782✔

2010

  SEncoder encoder = {0};

769,782✔

2011

  tEncoderInit(&encoder, buf, bufLen);

769,782✔

2012

  int32_t code = 0;

769,782✔

2015

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

769,782✔

2017

  TAOS_CHECK_EXIT(tSerializeSCMCreateStreamReqImpl(&encoder, pReq));

769,782✔

2019

  tEndEncode(&encoder);

769,782✔

2021

_exit:

769,782✔

2022

  if (code) {

769,782✔

2026

    int32_t tlen = encoder.pos;

769,782✔

2027

    tEncoderClear(&encoder);

769,782✔

2028

    return tlen;

769,782✔

2326

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

440,822✔

2327

  int32_t code = 0;

440,822✔

2330

  char* json = NULL;

440,822✔

2331

  SJson* pJson = NULL;

440,822✔

2332

  TAOS_CHECK_EXIT(tDecodeCStrAlloc(pDecoder, &json));

440,822✔

2333

  pJson = tjsonParse(json);

440,822✔

2334

  if (pJson == NULL) {

440,822✔

2337

  TAOS_CHECK_EXIT(jsonToSCMCreateStreamReq(pJson, pReq));

440,822✔

2339

_exit:

440,822✔

2340

  taosMemoryFreeClear(json);

440,822✔

2341

  if (NULL != pJson) {

440,822✔

2342

    tjsonDelete(pJson);

440,822✔

2345

  return code;

440,822✔

2349

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

217,461✔

2350

  SDecoder decoder = {0};

217,461✔

2351

  tDecoderInit(&decoder, buf, bufLen);

217,461✔

2352

  int32_t code = 0;

217,461✔

2355

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

217,461✔

2357

  code = tDeserializeSCMCreateStreamReqImpl(&decoder, pReq);

217,461✔

2358

  if (TSDB_CODE_MND_STREAM_INVALID_JSON == code) {

217,461✔

2367

  tEndDecode(&decoder);

217,461✔

2369

_exit:

217,461✔

2371

  tDecoderClear(&decoder);

217,461✔

2372

  return code;

217,461✔

2376

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

47,932✔

2377

  int32_t  code = 0;

47,932✔

2380

  SEncoder encoder = {0};

47,932✔

2381

  tEncoderInit(&encoder, buf, bufLen);

47,932✔

2383

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

47,932✔

2385

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

95,864✔

2386

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

102,416✔

2387

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

54,484✔

2388

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

108,968✔

2390

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

95,864✔

2392

  tEndEncode(&encoder);

47,932✔

2394

_exit:

47,932✔

2395

  if (code) {

47,932✔

2398

    tlen = encoder.pos;

47,932✔

2400

  tEncoderClear(&encoder);

47,932✔

2401

  return tlen;

47,932✔

2404

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

17,900✔

2405

  SDecoder decoder = {0};

17,900✔

2406

  int32_t  code = 0;

17,900✔

2408

  tDecoderInit(&decoder, buf, bufLen);

17,900✔

2410

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

17,900✔

2411

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

35,800✔

2412

  if (pReq->count > 0) {

17,900✔

2413

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

17,900✔

2414

    if (pReq->name == NULL) {

17,900✔

2418

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

39,064✔

2419

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

42,328✔

2422

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

35,800✔

2424

  tEndDecode(&decoder);

17,900✔

2426

_exit:

17,900✔

2427

  tDecoderClear(&decoder);

17,900✔

2428

  return code;

17,900✔

2431

void tFreeMDropStreamReq(SMDropStreamReq *pReq) {

41,866✔

2432

  if (NULL == pReq) {

41,866✔

2435

  if (pReq->name) {

41,866✔

2436

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

90,272✔

2437

      taosMemoryFreeClear(pReq->name[i]);

48,406✔

2439

    taosMemoryFreeClear(pReq->name);

41,866✔

2443

static FORCE_INLINE void tFreeStreamCalcScan(void* pScan) {

1,978,126✔

2444

  if (pScan == NULL) {

1,978,126✔

2447

  SStreamCalcScan *pCalcScan = (SStreamCalcScan *)pScan;

1,978,126✔

2448

  taosArrayDestroy(pCalcScan->vgList);

1,978,126✔

2449

  taosMemoryFreeClear(pCalcScan->scanPlan);

1,978,126✔

2452

void tFreeStreamOutCol(void* pCol) {

79,118✔

2453

  if (pCol == NULL) {

79,118✔

2456

  SStreamOutCol *pOutCol = (SStreamOutCol *)pCol;

79,118✔

2457

  taosMemoryFreeClear(pOutCol->expr);

79,118✔

2462

void tFreeSCMCreateStreamReq(SCMCreateStreamReq *pReq) {

1,294,909✔

2463

  if (NULL == pReq) {

1,294,909✔

2464

    return;

192,861✔

2466

  taosMemoryFreeClear(pReq->name);

1,102,048✔

2467

  taosMemoryFreeClear(pReq->sql);

1,102,048✔

2468

  taosMemoryFreeClear(pReq->streamDB);

1,102,048✔

2469

  taosMemoryFreeClear(pReq->triggerDB);

1,102,048✔

2470

  taosMemoryFreeClear(pReq->outDB);

1,102,048✔

2471

  taosMemoryFreeClear(pReq->triggerTblName);

1,102,048✔

2472

  taosMemoryFreeClear(pReq->outTblName);

1,102,048✔

2474

  taosArrayDestroyP(pReq->calcDB, NULL);

1,102,048✔

2475

  pReq->calcDB = NULL;

1,102,048✔

2476

  taosArrayDestroyP(pReq->pNotifyAddrUrls, NULL);

1,102,048✔

2477

  pReq->pNotifyAddrUrls = NULL;

1,102,048✔

2479

  taosMemoryFreeClear(pReq->triggerFilterCols);

1,102,048✔

2480

  taosMemoryFreeClear(pReq->triggerCols);

1,102,048✔

2481

  taosMemoryFreeClear(pReq->partitionCols);

1,102,048✔

2483

  taosArrayDestroy(pReq->outTags);

1,102,048✔

2484

  pReq->outTags = NULL;

1,102,048✔

2485

  taosArrayDestroy(pReq->outCols);

1,102,048✔

2486

  pReq->outCols = NULL;

1,102,048✔

2488

  switch (pReq->triggerType) {

1,102,048✔

2489

    case WINDOW_TYPE_STATE:

307,884✔

2490

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

307,884✔

2491

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

307,884✔

2492

      break;

307,884✔

2493

    case WINDOW_TYPE_EVENT:

119,753✔

2494

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

119,753✔

2495

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

119,753✔

2496

      break;

119,753✔

2497

    default:

674,411✔

2498

      break;

674,411✔

2501

  taosMemoryFreeClear(pReq->triggerScanPlan);

1,102,048✔

2502

  taosArrayDestroyEx(pReq->calcScanPlanList, tFreeStreamCalcScan);

1,102,048✔

2503

  pReq->calcScanPlanList = NULL;

1,102,048✔

2504

  taosMemoryFreeClear(pReq->triggerPrevFilter);

1,102,048✔

2506

  taosMemoryFreeClear(pReq->calcPlan);

1,102,048✔

2507

  taosMemoryFreeClear(pReq->subTblNameExpr);

1,102,048✔

2508

  taosMemoryFreeClear(pReq->tagValueExpr);

1,102,048✔

2509

  taosArrayDestroyEx(pReq->forceOutCols, tFreeStreamOutCol);

1,102,048✔

2510

  pReq->forceOutCols = NULL;

1,102,048✔

2511

  taosArrayDestroy(pReq->colCids);

1,102,048✔

2512

  pReq->colCids = NULL;

1,102,048✔

2513

  taosArrayDestroy(pReq->tagCids);

1,102,048✔

2514

  pReq->tagCids = NULL;

1,102,048✔

2517

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

177,538✔

2518

  int32_t code = 0, lino = 0;

177,538✔

2519

  if (NULL == pSrc) {

177,538✔

2523

  void* p = NULL;

177,538✔

2524

  int32_t num = 0;

177,538✔

2525

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

177,538✔

2526

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

177,538✔

2528

  SCMCreateStreamReq* pDst = *ppDst;

177,538✔

2530

  if (pSrc->outDB) {

177,538✔

2531

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

174,603✔

2532

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

174,603✔

2535

  if (pSrc->triggerTblName) {

177,538✔

2536

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

176,620✔

2537

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

176,620✔

2540

  if (pSrc->outTblName) {

177,538✔

2541

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

174,603✔

2542

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

174,603✔

2545

  if (pSrc->pNotifyAddrUrls) {

177,538✔

2546

    num = taosArrayGetSize(pSrc->pNotifyAddrUrls);

50,564✔

2547

    if (num > 0) {

50,564✔

2548

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

50,564✔

2549

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

50,564✔

2551

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

101,128✔

2552

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

50,564✔

2553

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

50,564✔

2554

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

101,128✔

2558

  if (pSrc->triggerFilterCols) {

177,538✔

2559

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

16,302✔

2560

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

16,302✔

2563

  if (pSrc->triggerCols) {

177,538✔

2564

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

170,976✔

2565

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

170,976✔

2568

  if (pSrc->partitionCols) {

177,538✔

2569

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

68,753✔

2570

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

68,753✔

2573

  if (pSrc->outCols) {

177,538✔

2574

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

174,603✔

2575

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

174,603✔

2578

  if (pSrc->outTags) {

177,538✔

2579

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

68,753✔

2580

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

68,753✔

2583

  pDst->triggerType = pSrc->triggerType;

177,538✔

2585

  switch (pSrc->triggerType) {

177,538✔

2586

    case WINDOW_TYPE_STATE:

64,064✔

2587

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

64,064✔

2588

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

64,064✔

2589

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

64,064✔

2590

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

64,064✔

2591

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

64,064✔

2592

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

64,064✔

2596

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

64,064✔

2597

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

64,064✔

2598

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

64,064✔

2600

      break;

64,064✔

2601

    case WINDOW_TYPE_EVENT:

23,033✔

2602

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

23,033✔

2603

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

23,033✔

2604

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

23,033✔

2607

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

23,033✔

2608

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

20,897✔

2609

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

20,897✔

2611

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

23,033✔

2612

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

23,033✔

2613

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

23,033✔

2614

      break;

23,033✔

2615

    case WINDOW_TYPE_COUNT:

15,193✔

2616

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

15,193✔

2617

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

15,193✔

2618

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

15,193✔

2622

      break;

15,193✔

2623

    default:

75,248✔

2624

      pDst->trigger = pSrc->trigger;

75,248✔

2625

      break;

75,248✔

2629

  if (pSrc->triggerScanPlan) {

177,538✔

2630

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

176,620✔

2631

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

176,620✔

2634

  if (pSrc->calcScanPlanList) {

177,538✔

2635

    num = taosArrayGetSize(pSrc->calcScanPlanList);

174,603✔

2636

    if (num > 0) {

174,603✔

2637

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

174,603✔

2638

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

174,603✔

2640

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

515,394✔

2641

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

340,791✔

2642

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

340,791✔

2644

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

340,791✔

2645

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

340,791✔

2647

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

340,791✔

2648

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

340,791✔

2650

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

681,582✔

2654

  if (pSrc->triggerPrevFilter) {

177,538✔

2655

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

6,730✔

2656

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

6,730✔

2659

  if (pSrc->calcPlan) {

177,538✔

2660

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

174,603✔

2661

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

174,603✔

2664

  if (pSrc->subTblNameExpr) {

177,538✔

2665

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

68,753✔

2666

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

68,753✔

2669

  if (pSrc->tagValueExpr) {

177,538✔

2670

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

68,753✔

2671

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

68,753✔

2674

  if (pSrc->forceOutCols) {

177,538✔

2675

    num = taosArrayGetSize(pSrc->forceOutCols);

3,302✔

2676

    if (num > 0) {

3,302✔

2677

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

3,302✔

2678

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

3,302✔

2680

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

22,189✔

2681

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

18,887✔

2682

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

18,887✔

2684

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

18,887✔

2685

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

18,887✔

2687

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

37,774✔

2691

  if (pSrc->colCids) {

177,538✔

2692

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

3,231✔

2693

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

3,231✔

2696

  if (pSrc->tagCids) {

177,538✔

2697

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

2,530✔

2698

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

2,530✔

2701

  pDst->triggerTblUid = pSrc->triggerTblUid;

177,538✔

2702

  pDst->triggerTblType = pSrc->triggerTblType;

177,538✔

2703

  pDst->triggerPrec = pSrc->triggerPrec;

177,538✔

2704

  pDst->deleteReCalc = pSrc->deleteReCalc;

177,538✔

2705

  pDst->deleteOutTbl = pSrc->deleteOutTbl;

177,538✔

2706

  pDst->flags = pSrc->flags;

177,538✔

2708

_exit:

177,538✔

2710

  if (code) {

177,538✔

2715

  return code;

177,538✔

2719

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

6,136✔

2720

  int32_t  code = 0;

6,136✔

2723

  SEncoder encoder = {0};

6,136✔

2724

  tEncoderInit(&encoder, buf, bufLen);

6,136✔

2725

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

6,136✔

2727

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

6,136✔

2728

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

12,272✔

2729

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

12,272✔

2730

  tEndEncode(&encoder);

6,136✔

2732

_exit:

6,136✔

2733

  if (code) {

6,136✔

2736

    tlen = encoder.pos;

6,136✔

2738

  tEncoderClear(&encoder);

6,136✔

2739

  return tlen;

6,136✔

2742

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

2,886✔

2743

  SDecoder decoder = {0};

2,886✔

2744

  int32_t  code = 0;

2,886✔

2747

  tDecoderInit(&decoder, buf, bufLen);

2,886✔

2748

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

2,886✔

2749

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

5,772✔

2750

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

5,772✔

2751

  tEndDecode(&decoder);

2,886✔

2753

_exit:

2,886✔

2754

  tDecoderClear(&decoder);

2,886✔

2755

  return code;

2,886✔

2758

void tFreeMPauseStreamReq(SMPauseStreamReq *pReq) {

3,068✔

2759

  taosMemoryFreeClear(pReq->name);

3,068✔

2760

3,068✔

2762

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

5,396✔

2763

  SEncoder encoder = {0};

5,396✔

2764

  int32_t  code = 0;

5,396✔

2767

  tEncoderInit(&encoder, buf, bufLen);

5,396✔

2768

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

5,396✔

2769

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

5,396✔

2770

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

10,792✔

2771

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

10,792✔

2772

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

10,792✔

2773

  tEndEncode(&encoder);

5,396✔

2775

_exit:

5,396✔

2776

  if (code) {

5,396✔

2779

    tlen = encoder.pos;

5,396✔

2781

  tEncoderClear(&encoder);

5,396✔

2782

  return tlen;

5,396✔

2785

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

2,516✔

2786

  SDecoder decoder = {0};

2,516✔

2787

  int32_t  code = 0;

2,516✔

2790

  tDecoderInit(&decoder, buf, bufLen);

2,516✔

2791

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

2,516✔

2792

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

5,032✔

2793

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

5,032✔

2794

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

5,032✔

2795

  tEndDecode(&decoder);

2,516✔

2797

_exit:

2,516✔

2798

  tDecoderClear(&decoder);

2,516✔

2799

  return code;

2,516✔

2802

void tFreeMResumeStreamReq(SMResumeStreamReq *pReq) {

2,698✔

2803

  taosMemoryFreeClear(pReq->name);

2,698✔

2804

2,698✔

2806

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

24,594✔

2807

  SEncoder encoder = {0};

24,594✔

2808

  int32_t  code = 0;

24,594✔

2811

  tEncoderInit(&encoder, buf, bufLen);

24,594✔

2812

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

24,594✔

2813

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

24,594✔

2814

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

49,188✔

2815

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

49,188✔

2816

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

49,188✔

2817

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

49,188✔

2818

  tEndEncode(&encoder);

24,594✔

2820

_exit:

24,594✔

2821

  if (code) {

24,594✔

2824

    tlen = encoder.pos;

24,594✔

2826

  tEncoderClear(&encoder);

24,594✔

2827

  return tlen;

24,594✔

2830

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

12,293✔

2831

  SDecoder decoder = {0};

12,293✔

2832

  int32_t  code = 0;

12,293✔

2835

  tDecoderInit(&decoder, buf, bufLen);

12,293✔

2836

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

12,293✔

2838

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

24,586✔

2839

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

24,586✔

2840

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

24,586✔

2841

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

24,586✔

2842

  tEndDecode(&decoder);

12,293✔

2844

_exit:

12,293✔

2845

  tDecoderClear(&decoder);

12,293✔

2846

  return code;

12,293✔

2849

void tFreeMRecalcStreamReq(SMRecalcStreamReq *pReq) {

24,590✔

2850

  taosMemoryFreeClear(pReq->name);

24,590✔

2851

24,590✔

2853

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

13,066✔

2854

  int32_t code = 0;

13,066✔

2857

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

26,132✔

2858

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

26,132✔

2859

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

26,132✔

2861

_exit:

13,066✔

2862

  return code;

13,066✔

2865

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

13,066✔

2866

  SEncoder encoder = {0};

13,066✔

2867

  int32_t  code = 0;

13,066✔

2870

  tEncoderInit(&encoder, buf, bufLen);

13,066✔

2872

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

13,066✔

2873

  TAOS_CHECK_EXIT(tEncodeStreamProgressReq(&encoder, pReq));

13,066✔

2875

  tEndEncode(&encoder);

13,066✔

2877

_exit:

13,066✔

2878

  if (code) {

13,066✔

2881

    tlen = encoder.pos;

13,066✔

2883

  tEncoderClear(&encoder);

13,066✔

2884

  return tlen;

13,066✔

2887

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

10,686✔

2888

  int32_t code = 0;

10,686✔

2891

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

21,372✔

2892

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

21,372✔

2893

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

21,372✔

2895

_exit:

10,686✔

2896

  return code;

10,686✔

2899

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

10,686✔

2900

  SDecoder decoder = {0};

10,686✔

2901

  int32_t  code = 0;

10,686✔

2904

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

10,686✔

2906

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

10,686✔

2907

  TAOS_CHECK_EXIT(tDecodeStreamProgressReq(&decoder, pReq));

10,686✔

2909

  tEndDecode(&decoder);

10,686✔

2911

_exit:

10,686✔

2912

  tDecoderClear(&decoder);

10,686✔

2913

  return code;

10,686✔

2916

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

12,878✔

2917

  int32_t code = 0;

12,878✔

2920

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

25,756✔

2921

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

25,756✔

2922

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

25,756✔

2923

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

25,756✔

2925

_exit:

12,878✔

2926

  return code;

12,878✔

2929

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

12,878✔

2930

  SEncoder encoder = {0};

12,878✔

2931

  int32_t  code = 0;

12,878✔

2934

  tEncoderInit(&encoder, buf, bufLen);

12,878✔

2936

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

12,878✔

2937

  TAOS_CHECK_EXIT(tEncodeStreamProgressRsp(&encoder, pRsp));

12,878✔

2939

  tEndEncode(&encoder);

12,878✔

2941

_exit:

12,878✔

2942

  if (code) {

12,878✔

2945

    tlen = encoder.pos;

12,878✔

2947

  tEncoderClear(&encoder);

12,878✔

2948

  return tlen;

12,878✔

2951

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

6,533✔

2952

  int32_t code = 0;

6,533✔

2955

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

13,066✔

2956

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

13,066✔

2957

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

13,066✔

2958

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

13,066✔

2960

_exit:

6,533✔

2961

  return code;

6,533✔

2964

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

6,533✔

2965

  SDecoder decoder = {0};

6,533✔

2966

  int32_t  code = 0;

6,533✔

2969

  tDecoderInit(&decoder, buf, bufLen);

6,533✔

2971

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

6,533✔

2972

  TAOS_CHECK_EXIT(tDecodeStreamProgressRsp(&decoder, pRsp));

6,533✔

2974

  tEndDecode(&decoder);

6,533✔

2976

_exit:

6,533✔

2977

  tDecoderClear(&decoder);

6,533✔

2978

  return code;

6,533✔

2981

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

239,470✔

2982

  SEncoder encoder = {0};

239,470✔

2983

  int32_t  code = TSDB_CODE_SUCCESS;

239,470✔

2984

  int32_t  lino = 0;

239,470✔

2985

  int32_t  tlen = 0;

239,470✔

2987

  tEncoderInit(&encoder, buf, bufLen);

239,470✔

2988

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

239,470✔

2990

  int32_t size = taosArrayGetSize(pRsp->cols);

239,470✔

2991

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, size));

239,470✔

2992

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

879,064✔

2993

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

640,267✔

2994

    if (oInfo == NULL) {

640,267✔

2999

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

1,280,534✔

3000

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

1,279,861✔

3001

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

1,279,188✔

3004

  tEndEncode(&encoder);

238,797✔

3006

_exit:

239,470✔

3007

  if (code != TSDB_CODE_SUCCESS) {

239,470✔

3010

    tlen = encoder.pos;

239,470✔

3012

  tEncoderClear(&encoder);

239,470✔

3013

  return tlen;

239,470✔

3016

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

119,735✔

3017

  SDecoder decoder = {0};

119,735✔

3018

  int32_t  code = TSDB_CODE_SUCCESS;

119,735✔

3019

  int32_t  lino = 0;

119,735✔

3021

  tDecoderInit(&decoder, buf, bufLen);

119,735✔

3022

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

119,735✔

3024

  int32_t size = 0;

119,735✔

3025

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

119,735✔

3026

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

119,735✔

3027

  if (pRsp->cols == NULL) {

119,735✔

3032

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

440,205✔

3033

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

320,470✔

3034

    if (oInfo == NULL) {

320,470✔

3039

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

640,940✔

3040

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

640,940✔

3041

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

640,940✔

3044

  tEndDecode(&decoder);

119,735✔

3046

_exit:

119,735✔

3047

  tDecoderClear(&decoder);

119,735✔

3048

  return code;

119,735✔

3051

void    tDestroySTriggerOrigTableInfoRsp(SSTriggerOrigTableInfoRsp* pRsp){

24,761,714✔

3052

  taosArrayDestroy(pRsp->cols);

24,761,714✔

3053

24,761,954✔

3055

void tDestroySTriggerPullRequest(SSTriggerPullRequestUnion* pReq) {

33,318,096✔

3056

  if (pReq == NULL) return;

33,318,096✔

3057

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

41,871,236✔

3058

    SSTriggerWalDataNewRequest* pRequest = (SSTriggerWalDataNewRequest*)pReq;

8,553,645✔

3059

    taosArrayDestroy(pRequest->versions);

8,553,645✔

3060

    tSimpleHashCleanup(pRequest->ranges);

8,553,376✔

3061

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

24,765,359✔

3062

    SSTriggerTsdbDataRequest* pRequest = (SSTriggerTsdbDataRequest*)pReq;

355,549✔

3063

    if (pRequest->cids != NULL) {

355,549✔

3064

      taosArrayDestroy(pRequest->cids);

355,549✔

3065

      pRequest->cids = NULL;

355,549✔

3067

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

24,409,100✔

3068

    SSTriggerVirTableInfoRequest* pRequest = (SSTriggerVirTableInfoRequest*)pReq;

68,540✔

3069

    if (pRequest->cids != NULL) {

68,540✔

3070

      taosArrayDestroy(pRequest->cids);

68,540✔

3071

      pRequest->cids = NULL;

68,540✔

3073

    if (pRequest->uids != NULL) {

68,540✔

3077

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

24,340,120✔

3078

    SSTriggerVirTablePseudoColRequest *pRequest = (SSTriggerVirTablePseudoColRequest*)pReq;

699,001✔

3079

    if (pRequest->cids != NULL) {

699,001✔

3080

      taosArrayDestroy(pRequest->cids);

699,001✔

3081

      pRequest->cids = NULL;

699,001✔

3083

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

23,640,421✔

3084

    SSTriggerOrigTableInfoRequest* pRequest = (SSTriggerOrigTableInfoRequest*)pReq;

119,735✔

3085

    if (pRequest->cols != NULL) {

119,735✔

3086

      taosArrayDestroy(pRequest->cols);

119,735✔

3087

      pRequest->cols = NULL;

119,735✔

3089

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

23,521,373✔

3090

    SSTriggerSetTableRequest* pRequest = (SSTriggerSetTableRequest*)pReq;

119,735✔

3091

    tSimpleHashCleanup(pRequest->uidInfoTrigger);

119,735✔

3092

    tSimpleHashCleanup(pRequest->uidInfoCalc);

119,735✔

3096

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

2,390,464✔

3097

  int32_t  code = TSDB_CODE_SUCCESS;

2,390,464✔

3098

  int32_t  lino = 0;

2,390,464✔

3099

  int32_t  nEle = taosArrayGetSize(pArr);

2,390,464✔

3100

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

2,390,464✔

3101

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

2,390,464✔

3102

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

4,780,928✔

3104

_exit:

2,390,464✔

3105

  return code;

2,390,464✔

3108

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

1,191,630✔

3109

  int32_t  code = TSDB_CODE_SUCCESS;

1,191,630✔

3110

  int32_t  lino = 0;

1,191,630✔

3111

  void*    buf = NULL;

1,191,630✔

3112

  uint64_t len = 0;

1,191,630✔

3113

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

1,191,630✔

3115

  if (len > 0) {

1,191,630✔

3116

    *ppArr = taosArrayInit(0, elemSize);

1,123,090✔

3117

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

1,123,090✔

3118

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

1,123,090✔

3119

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

1,123,090✔

3122

_exit:

1,191,630✔

3123

  if (buf != NULL) {

1,191,630✔

3124

    taosMemoryFree(buf);

1,123,090✔

3126

  return code;

1,191,630✔

3129

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

478,940✔

3130

  int32_t  code = TSDB_CODE_SUCCESS;

478,940✔

3131

  int32_t  lino = 0;

478,940✔

3132

  int32_t size = tSimpleHashGetSize(pInfo);

478,940✔

3133

  TAOS_CHECK_EXIT(tEncodeI32(encoder, size));

478,940✔

3134

  int32_t iter = 0;

478,940✔

3135

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

478,940✔

3136

  while (px != NULL) {

1,078,610✔

3137

    int64_t* uid = tSimpleHashGetKey(px, NULL);

599,670✔

3138

    TAOS_CHECK_EXIT(tEncodeI64(encoder, *uid));

1,199,340✔

3139

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

1,199,096✔

3140

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

599,426✔

3141

    int32_t len = tSimpleHashGetSize(info);

599,426✔

3142

    TAOS_CHECK_EXIT(tEncodeI32(encoder, len));

599,670✔

3143

    int32_t iter1 = 0;

599,670✔

3144

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

599,670✔

3145

    while (px1 != NULL) {

2,253,440✔

3146

      int16_t* slot = tSimpleHashGetKey(px1, NULL);

1,653,770✔

3147

      int16_t* cid = (int16_t*)px1;

1,653,770✔

3148

      TAOS_CHECK_EXIT(tEncodeI16(encoder, *slot));

3,307,784✔

3149

      TAOS_CHECK_EXIT(tEncodeI16(encoder, *cid));

3,308,028✔

3151

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

1,654,014✔

3154

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

599,670✔

3157

_exit:

478,696✔

3158

  return code;

478,940✔

3161

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

66,992,978✔

3162

  SEncoder encoder = {0};

66,992,978✔

3163

  int32_t  code = TSDB_CODE_SUCCESS;

66,993,462✔

3164

  int32_t  lino = 0;

66,993,462✔

3165

  int32_t  tlen = 0;

66,993,462✔

3167

  tEncoderInit(&encoder, buf, bufLen);

66,993,462✔

3168

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

66,994,532✔

3170

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

133,986,210✔

3171

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

133,982,108✔

3172

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

133,981,367✔

3173

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

133,985,454✔

3175

  switch (pReq->type) {

66,994,963✔

3176

    case STRIGGER_PULL_SET_TABLE: {

239,470✔

3177

      SSTriggerSetTableRequest* pRequest = (SSTriggerSetTableRequest*)pReq;

239,470✔

3178

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

239,470✔

3179

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

239,470✔

3180

      break;

239,470✔

3182

    case STRIGGER_PULL_LAST_TS: {

540,594✔

3183

      break;

540,594✔

3185

    case STRIGGER_PULL_FIRST_TS: {

439,012✔

3186

      SSTriggerFirstTsRequest* pRequest = (SSTriggerFirstTsRequest*)pReq;

439,012✔

3187

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

877,784✔

3188

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

877,543✔

3189

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

877,783✔

3190

      break;

439,012✔

3192

    case STRIGGER_PULL_TSDB_META: {

1,048,092✔

3193

      SSTriggerTsdbMetaRequest* pRequest = (SSTriggerTsdbMetaRequest*)pReq;

1,048,092✔

3194

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

2,096,184✔

3195

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

2,096,184✔

3196

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

2,096,184✔

3197

      TAOS_CHECK_EXIT(tEncodeI8(&encoder, pRequest->order));

2,096,184✔

3198

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));

2,096,184✔

3199

      break;

1,048,092✔

3204

    case STRIGGER_PULL_TSDB_TS_DATA: {

144,392✔

3205

      SSTriggerTsdbTsDataRequest* pRequest = (SSTriggerTsdbTsDataRequest*)pReq;

144,392✔

3206

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->suid));

288,784✔

3207

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->uid));

288,784✔

3208

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->skey));

288,784✔

3209

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ekey));

288,784✔

3210

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));

288,784✔

3211

      break;

144,392✔

3213

    case STRIGGER_PULL_TSDB_TRIGGER_DATA: {

117,094✔

3214

      SSTriggerTsdbTriggerDataRequest* pRequest = (SSTriggerTsdbTriggerDataRequest*)pReq;

117,094✔

3215

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->startTime));

234,188✔

3216

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->gid));

234,188✔

3217

      TAOS_CHECK_EXIT(tEncodeI8(&encoder, pRequest->order));

234,188✔

3218

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));

234,188✔

3219

      break;

117,094✔

3221

    case STRIGGER_PULL_TSDB_TRIGGER_DATA_NEXT: {

117,094✔

3222

      break;

117,094✔

3224

    case STRIGGER_PULL_TSDB_CALC_DATA: {

13,638,556✔

3225

      SSTriggerTsdbCalcDataRequest* pRequest = (SSTriggerTsdbCalcDataRequest*)pReq;

13,638,556✔

3226

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->gid));

27,277,112✔

3227

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->skey));

27,277,112✔

3228

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ekey));

27,277,112✔

3229

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));

27,277,112✔

3230

      break;

13,638,556✔

3235

    case STRIGGER_PULL_TSDB_DATA: {

713,790✔

3236

      SSTriggerTsdbDataRequest* pRequest = (SSTriggerTsdbDataRequest*)pReq;

713,790✔

3237

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->suid));

1,427,580✔

3238

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->uid));

1,427,580✔

3239

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->skey));

1,427,580✔

3240

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ekey));

1,427,580✔

3241

      TAOS_CHECK_EXIT(encodePlainArray(&encoder, pRequest->cids));

713,790✔

3242

      TAOS_CHECK_EXIT(tEncodeI8(&encoder, pRequest->order));

1,427,580✔

3243

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));

1,427,580✔

3244

      break;

713,790✔

3249

    case STRIGGER_PULL_WAL_META_NEW: {

23,568,122✔

3250

      SSTriggerWalMetaNewRequest* pRequest = (SSTriggerWalMetaNewRequest*)pReq;

23,568,122✔

3251

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->lastVer));

47,136,986✔

3252

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ctime));

47,137,287✔

3253

      break;

23,568,423✔

3255

    case STRIGGER_PULL_WAL_DATA_NEW:

17,105,323✔

3257

      SSTriggerWalDataNewRequest* pRequest = (SSTriggerWalDataNewRequest*)pReq;

17,105,323✔

3258

      int32_t                     nVersion = taosArrayGetSize(pRequest->versions);

17,105,323✔

3259

      TAOS_CHECK_EXIT(tEncodeI32(&encoder, nVersion));

17,107,204✔

3260

      for (int32_t i = 0; i < nVersion; i++) {

32,811,986✔

3261

        int64_t ver = *(int64_t*)TARRAY_GET_ELEM(pRequest->versions, i);

15,704,782✔

3262

        TAOS_CHECK_EXIT(tEncodeI64(&encoder, ver));

15,704,782✔

3264

      int32_t nRanges = tSimpleHashGetSize(pRequest->ranges);

17,107,204✔

3265

      TAOS_CHECK_EXIT(tEncodeI32(&encoder, nRanges));

17,107,924✔

3266

      int32_t iter = 0;

17,107,924✔

3267

      void*   px = tSimpleHashIterate(pRequest->ranges, NULL, &iter);

17,107,444✔

3268

      while (px != NULL) {

22,084,482✔

3269

        uint64_t* gid = tSimpleHashGetKey(px, NULL);

4,977,294✔

3270

        TAOS_CHECK_EXIT(tEncodeU64(&encoder, *gid));

9,954,588✔

3271

        int64_t* key = (int64_t*)px;

4,977,294✔

3272

        TAOS_CHECK_EXIT(tEncodeI64(&encoder, key[0]));

9,954,588✔

3273

        TAOS_CHECK_EXIT(tEncodeI64(&encoder, key[1]));

9,954,588✔

3275

        px = tSimpleHashIterate(pRequest->ranges, px, &iter);

4,977,294✔

3277

      break;

17,107,188✔

3279

    case STRIGGER_PULL_WAL_META_DATA_NEW: {

7,042,890✔

3280

      SSTriggerWalMetaDataNewRequest* pRequest = (SSTriggerWalMetaDataNewRequest*)pReq;

7,042,890✔

3281

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->lastVer));

14,086,421✔

3282

      break;

7,043,531✔

3284

    case STRIGGER_PULL_GROUP_COL_VALUE: {

498,892✔

3285

      SSTriggerGroupColValueRequest* pRequest = (SSTriggerGroupColValueRequest*)pReq;

498,892✔

3286

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->gid));

997,784✔

3287

      break;

498,892✔

3289

    case STRIGGER_PULL_VTABLE_INFO: {

137,990✔

3290

      SSTriggerVirTableInfoRequest* pRequest = (SSTriggerVirTableInfoRequest*)pReq;

137,990✔

3291

      TAOS_CHECK_EXIT(encodePlainArray(&encoder, pRequest->cids));

137,990✔

3292

      TAOS_CHECK_EXIT(encodePlainArray(&encoder, pRequest->uids));

137,990✔

3293

      TAOS_CHECK_EXIT(tEncodeBool(&encoder, pRequest->fetchAllTable));

137,990✔

3294

      break;

137,990✔

3296

    case STRIGGER_PULL_VTABLE_PSEUDO_COL: {

1,400,694✔

3297

      SSTriggerVirTablePseudoColRequest* pRequest = (SSTriggerVirTablePseudoColRequest*)pReq;

1,400,694✔

3298

      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->uid));

2,801,388✔

3299

      TAOS_CHECK_EXIT(encodePlainArray(&encoder, pRequest->cids));

1,400,694✔

3300

      break;

1,400,450✔

3302

    case STRIGGER_PULL_OTABLE_INFO: {

239,470✔

3303

      SSTriggerOrigTableInfoRequest* pRequest = (SSTriggerOrigTableInfoRequest*)pReq;

239,470✔

3304

      int32_t size = taosArrayGetSize(pRequest->cols);

239,470✔

3305

      TAOS_CHECK_EXIT(tEncodeI32(&encoder, size));

239,470✔

3306

      for (int32_t i = 0; i < size; ++i) {

879,737✔

3307

        OTableInfo* oInfo = taosArrayGet(pRequest->cols, i);

640,940✔

3308

        if (oInfo == NULL) {

640,940✔

3313

        TAOS_CHECK_EXIT(tEncodeCStr(&encoder, oInfo->refTableName));

1,281,207✔

3314

        TAOS_CHECK_EXIT(tEncodeCStr(&encoder, oInfo->refColName));

1,280,534✔

3316

      break;

238,797✔

3318

    default: {

20✔

3319

      uError("unknown pull type %d", pReq->type);

20✔

3325

  tEndEncode(&encoder);

66,993,125✔

3327

_exit:

66,988,574✔

3328

  if (code != TSDB_CODE_SUCCESS) {

66,989,062✔

3331

    tlen = encoder.pos;

66,989,062✔

3333

  tEncoderClear(&encoder);

66,989,062✔

3334

  return tlen;

66,992,249✔

3337

static void destroyHash(void* data){

299,835✔

3338

  if (data){

299,835✔

3339

    SSHashObj* tmp = *(SSHashObj**)data;

299,835✔

3340

    tSimpleHashCleanup(tmp);

299,835✔

3342

299,835✔

3344

static int32_t decodeSetTableMapInfo(SDecoder* decoder, SSHashObj** ppInfo) {

239,470✔

3345

  int32_t  code = TSDB_CODE_SUCCESS;

239,470✔

3346

  int32_t  lino = 0;

239,470✔

3347

  int32_t size = 0;

239,470✔

3348

  TAOS_CHECK_EXIT(tDecodeI32(decoder, &size));

239,470✔

3349

  *ppInfo = tSimpleHashInit(size, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY));

239,470✔

3350

  if (*ppInfo == NULL) {

239,470✔

3353

  tSimpleHashSetFreeFp(*ppInfo, destroyHash);

239,470✔

3355

  for (int32_t i = 0; i < size; ++i) {

539,305✔

3356

    int64_t id[2] = {0};

299,835✔

3357

    TAOS_CHECK_EXIT(tDecodeI64(decoder, id));

299,835✔

3358

    TAOS_CHECK_EXIT(tDecodeI64(decoder, id+1));

599,670✔

3359

    int32_t len = 0;

299,835✔

3360

    TAOS_CHECK_EXIT(tDecodeI32(decoder, &len));

299,835✔

3361

    SSHashObj* tmp = tSimpleHashInit(len, taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT));

299,835✔

3362

    if (tmp == NULL) {

299,835✔

3365

    TAOS_CHECK_EXIT(tSimpleHashPut(*ppInfo, id, sizeof(id), &tmp, POINTER_BYTES));

299,835✔

3367

    for (int32_t j = 0; j < len; ++j) {

1,126,842✔

3368

      int16_t slotId = 0;

827,007✔

3369

      int16_t cid = 0;

827,007✔

3370

      TAOS_CHECK_EXIT(tDecodeI16(decoder, &slotId));

827,007✔

3371

      TAOS_CHECK_EXIT(tDecodeI16(decoder, &cid));

827,007✔

3372

      TAOS_CHECK_EXIT(tSimpleHashPut(tmp, &slotId, sizeof(slotId), &cid, sizeof(cid)));

827,007✔

3375

_exit:

240,816✔

3376

  if (code != TSDB_CODE_SUCCESS) {

239,470✔

3380

  return code;

239,470✔

3383

int32_t tDeserializeSTriggerPullRequest(void* buf, int32_t bufLen, SSTriggerPullRequestUnion* pReq) {

33,318,319✔

3384

  SDecoder decoder = {0};

33,318,319✔

3385

  int32_t  code = TSDB_CODE_SUCCESS;

33,318,764✔

3386

  int32_t  lino = 0;

33,318,764✔

3388

  tDecoderInit(&decoder, buf, bufLen);

33,318,764✔

3389

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

33,319,861✔

3391

  int32_t type = 0;

33,320,780✔

3392

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &type));

33,323,028✔

3393

  SSTriggerPullRequest* pBase = &(pReq->base);

33,323,028✔

3394

  pBase->type = type;

33,323,028✔

3395

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pBase->streamId));

66,644,574✔

3396

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pBase->readerTaskId));

66,646,237✔

3397

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pBase->sessionId));

66,648,140✔

3399

  switch (type) {

33,323,458✔

3400

    case STRIGGER_PULL_SET_TABLE: {

119,735✔

3401

      SSTriggerSetTableRequest* pRequest = &(pReq->setTableReq);

119,735✔

3402

      TAOS_CHECK_EXIT(decodeSetTableMapInfo(&decoder, &pRequest->uidInfoTrigger));

119,735✔

3403

      TAOS_CHECK_EXIT(decodeSetTableMapInfo(&decoder, &pRequest->uidInfoCalc));

119,735✔

3404

      break;

119,735✔

3406

    case STRIGGER_PULL_LAST_TS: {

270,242✔

3407

      break;

270,242✔

3409

    case STRIGGER_PULL_FIRST_TS: {

216,280✔

3410

      SSTriggerFirstTsRequest* pRequest = &(pReq->firstTsReq);

216,280✔

3411

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));

432,560✔

3412

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->startTime));

432,560✔

3413

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));

432,320✔

3414

      break;

216,040✔

3416

    case STRIGGER_PULL_TSDB_META: {

523,688✔

3417

      SSTriggerTsdbMetaRequest* pRequest = &(pReq->tsdbMetaReq);

523,688✔

3418

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->startTime));

1,047,586✔

3419

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->endTime));

1,047,796✔

3420

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));

1,047,796✔

3421

      TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pRequest->order));

1,047,796✔

3422

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));

1,047,796✔

3423

      break;

523,898✔

3428

    case STRIGGER_PULL_TSDB_TS_DATA: {

72,196✔

3429

      SSTriggerTsdbTsDataRequest* pRequest = &(pReq->tsdbTsDataReq);

72,196✔

3430

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->suid));

144,392✔

3431

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->uid));

144,392✔

3432

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->skey));

144,392✔

3433

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ekey));

144,392✔

3434

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));

144,392✔

3435

      break;

72,196✔

3437

    case STRIGGER_PULL_TSDB_TRIGGER_DATA: {

58,547✔

3438

      SSTriggerTsdbTriggerDataRequest* pRequest = &(pReq->tsdbTriggerDataReq);

58,547✔

3439

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->startTime));

117,094✔

3440

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));

117,094✔

3441

      TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pRequest->order));

117,094✔

3442

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));

117,094✔

3443

      break;

58,547✔

3445

    case STRIGGER_PULL_TSDB_TRIGGER_DATA_NEXT: {

58,547✔

3446

      break;

58,547✔

3448

    case STRIGGER_PULL_TSDB_CALC_DATA: {

6,818,390✔

3449

      SSTriggerTsdbCalcDataRequest* pRequest = &(pReq->tsdbCalcDataReq);

6,818,390✔

3450

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));

13,636,780✔

3451

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->skey));

13,636,780✔

3452

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ekey));

13,636,780✔

3453

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));

13,636,780✔

3454

      break;

6,818,390✔

3459

    case STRIGGER_PULL_TSDB_DATA: {

355,549✔

3460

      SSTriggerTsdbDataRequest* pRequest = &(pReq->tsdbDataReq);

355,549✔

3461

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->suid));

711,098✔

3462

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->uid));

711,098✔

3463

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->skey));

711,098✔

3464

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ekey));

711,098✔

3465

      TAOS_CHECK_EXIT(decodePlainArray(&decoder, &pRequest->cids, sizeof(col_id_t)));

355,549✔

3466

      TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pRequest->order));

711,098✔

3467

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));

711,098✔

3468

      break;

355,549✔

3473

    case STRIGGER_PULL_WAL_META_NEW: {

11,688,603✔

3474

      SSTriggerWalMetaNewRequest* pRequest = &(pReq->walMetaNewReq);

11,688,603✔

3475

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->lastVer));

23,379,190✔

3476

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ctime));

23,380,742✔

3477

      break;

11,690,583✔

3479

    case STRIGGER_PULL_WAL_DATA_NEW:

8,553,183✔

3481

      SSTriggerWalDataNewRequest* pRequest = &(pReq->walDataNewReq);

8,553,183✔

3482

      int32_t                     nVersion = 0;

8,553,427✔

3483

      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nVersion));

8,554,100✔

3484

      pRequest->versions = taosArrayInit_s(sizeof(int64_t), nVersion);

8,554,100✔

3485

      for (int32_t i = 0; i < nVersion; i++) {

16,404,809✔

3486

        int64_t* pVer = TARRAY_GET_ELEM(pRequest->versions, i);

7,852,055✔

3487

        TAOS_CHECK_EXIT(tDecodeI64(&decoder, pVer));

7,851,803✔

3489

      int32_t nRanges = 0;

8,552,754✔

3490

      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nRanges));

8,552,754✔

3491

      pRequest->ranges = tSimpleHashInit(nRanges, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT));

8,552,754✔

3492

      if (pRequest->ranges == NULL) {

8,552,081✔

3495

      for (int32_t i = 0; i < nRanges; i++) {

11,040,939✔

3496

        uint64_t gid = 0;

2,488,425✔

3497

        int64_t pRange[2] = {0};

2,488,425✔

3498

        TAOS_CHECK_EXIT(tDecodeU64(&decoder, &gid));

2,488,425✔

3499

        TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRange[0]));

2,488,425✔

3500

        TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRange[1]));

2,488,425✔

3501

        TAOS_CHECK_EXIT(tSimpleHashPut(pRequest->ranges, &gid, sizeof(gid), pRange, sizeof(pRange)));

2,488,425✔

3503

      break;

8,552,514✔

3505

    case STRIGGER_PULL_WAL_META_DATA_NEW: {

3,449,012✔

3506

      SSTriggerWalMetaDataNewRequest* pRequest = &(pReq->walMetaDataNewReq);

3,449,012✔

3507

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->lastVer));

6,899,379✔

3508

      break;

3,450,241✔

3510

    case STRIGGER_PULL_GROUP_COL_VALUE: {

248,798✔

3511

      SSTriggerGroupColValueRequest* pRequest = &(pReq->groupColValueReq);

248,798✔

3512

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));

497,596✔

3513

      break;

248,798✔

3515

    case STRIGGER_PULL_VTABLE_INFO: {

68,540✔

3516

      SSTriggerVirTableInfoRequest* pRequest = &(pReq->virTableInfoReq);

68,540✔

3517

      TAOS_CHECK_EXIT(decodePlainArray(&decoder, &pRequest->cids, sizeof(col_id_t)));

68,540✔

3518

      TAOS_CHECK_EXIT(decodePlainArray(&decoder, &pRequest->uids, sizeof(int64_t)));

68,540✔

3519

      TAOS_CHECK_EXIT(tDecodeBool(&decoder, &pRequest->fetchAllTable));

68,540✔

3520

      break;

68,540✔

3522

    case STRIGGER_PULL_VTABLE_PSEUDO_COL: {

698,328✔

3523

      SSTriggerVirTablePseudoColRequest* pRequest = &(pReq->virTablePseudoColReq);

698,328✔

3524

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->uid));

1,398,002✔

3525

      TAOS_CHECK_EXIT(decodePlainArray(&decoder, &pRequest->cids, sizeof(col_id_t)));

699,001✔

3526

      break;

699,001✔

3528

    case STRIGGER_PULL_OTABLE_INFO: {

119,735✔

3529

      SSTriggerOrigTableInfoRequest* pRequest = &(pReq->origTableInfoReq);

119,735✔

3530

      int32_t size = 0;

119,735✔

3531

      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &size));

119,735✔

3532

      pRequest->cols = taosArrayInit(size, sizeof(OTableInfo));

119,735✔

3533

      if (pRequest->cols == NULL) {

119,735✔

3538

      for (int32_t i = 0; i < size; ++i) {

440,205✔

3539

        OTableInfo* oInfo = taosArrayReserve(pRequest->cols, 1);

320,470✔

3540

        if (oInfo == NULL) {

320,470✔

3545

        TAOS_CHECK_RETURN(tDecodeCStrTo(&decoder, oInfo->refTableName));

320,470✔

3546

        TAOS_CHECK_RETURN(tDecodeCStrTo(&decoder, oInfo->refColName));

320,470✔

3548

      break;

119,735✔

3550

    default: {

4,085✔

3551

      uError("unknown pull type %d", type);

4,085✔

3557

  tEndDecode(&decoder);

33,323,229✔

3559

_exit:

33,319,429✔

3560

  tDecoderClear(&decoder);

33,320,584✔

3561

  return code;

33,315,575✔

3564

static int32_t tSerializeSTriggerCalcParam(SEncoder* pEncoder, SArray* pParams, bool ignoreNotificationInfo, bool full) {

23,220,061✔

3565

  int32_t size = full ? taosArrayGetSize(pParams) : 0;

23,220,061✔

3566

  int32_t code = 0;

23,219,519✔

3567

  int32_t lino = 0;

23,219,519✔

3568

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, size));

23,220,164✔

3569

  for (int32_t i = 0; i < size; ++i) {

1,490,843,819✔

3570

    SSTriggerCalcParam* param = taosArrayGet(pParams, i);

1,467,663,247✔

3571

    if (param == NULL) {

1,467,459,617✔

3574

    int64_t plainFieldSize = offsetof(SSTriggerCalcParam, notifyType);

1,467,459,617✔

3575

    if (pEncoder->data) {

1,467,459,617✔

3576

      TAOS_MEMCPY(pEncoder->data + pEncoder->pos, param, plainFieldSize);

735,325,940✔

3578

    pEncoder->pos += plainFieldSize;

1,467,268,757✔

3580

    if (!ignoreNotificationInfo) {

1,467,821,124✔

3581

      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, param->notifyType));

146,031,826✔

3582

      uint64_t len = (param->extraNotifyContent != NULL) ? strlen(param->extraNotifyContent) + 1 : 0;

73,015,994✔

3583

      TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, (uint8_t*)param->extraNotifyContent, len));

145,833,481✔

3586

_exit:

23,180,572✔

3587

  return code;

23,180,572✔

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);

260,575✔

3595

  if (pParam && pParam->resultNotifyContent != NULL) {

2,147,483,647✔

3598

2,147,483,647✔

3600

void tDestroySStreamGroupValue(void* ptr) {

13,519,730✔

3601

  SStreamGroupValue* pValue = ptr;

13,519,730✔

3602

  if ((pValue != NULL) && (IS_VAR_DATA_TYPE(pValue->data.type) || pValue->data.type == TSDB_DATA_TYPE_DECIMAL)) {

13,519,730✔

3603

    taosMemoryFreeClear(pValue->data.pData);

11,109,994✔

3604

    pValue->data.nData = 0;

11,109,184✔

3606

13,519,730✔

3608

static int32_t tDeserializeSTriggerCalcParam(SDecoder* pDecoder, SArray**ppParams, bool ignoreNotificationInfo) {

11,612,405✔

3609

  int32_t size = 0, code = 0, lino = 0;

11,612,405✔

3610

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &size));

11,612,535✔

3611

  *ppParams = taosArrayInit(size, sizeof(SSTriggerCalcParam));

11,612,535✔

3612

  if (*ppParams == NULL) {

11,612,803✔

3615

  for (int32_t i = 0; i < size; ++i) {

727,913,105✔

3616

    SSTriggerCalcParam* param = taosArrayReserve(*ppParams, 1);

716,319,301✔

3617

    if (param == NULL) {

716,382,314✔

3620

    int64_t plainFieldSize = offsetof(SSTriggerCalcParam, notifyType);

716,382,314✔

3621

    TAOS_MEMCPY(param, pDecoder->data + pDecoder->pos, plainFieldSize);

716,382,314✔

3622

    pDecoder->pos += plainFieldSize;

716,479,482✔

3624

    if (!ignoreNotificationInfo) {

716,299,008✔

3625

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &param->notifyType));

58,982,079✔

3626

      uint64_t len = 0;

29,491,531✔

3627

      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&param->extraNotifyContent, &len));

58,983,297✔

3631

_exit:

11,593,598✔

3632

  return code;

11,612,771✔

3635

static int32_t tSerializeStriggerGroupColVals(SEncoder* pEncoder, SArray* pGroupColVals, int32_t vgId) {

23,717,917✔

3636

  int32_t code = TSDB_CODE_SUCCESS;

23,717,917✔

3637

  int32_t lino = 0;

23,717,917✔

3639

  int32_t size = taosArrayGetSize(pGroupColVals);

23,717,917✔

3640

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, size));

23,718,083✔

3641

  for (int32_t i = 0; i < size; ++i) {

48,487,903✔

3642

    SStreamGroupValue* pValue = taosArrayGet(pGroupColVals, i);

24,769,682✔

3643

    if (pValue == NULL) {

24,770,056✔

3646

    TAOS_CHECK_EXIT(tEncodeBool(pEncoder, pValue->isNull));

24,770,056✔

3647

    if (pValue->isNull) {

24,770,742✔

3648

      continue;

22,080✔

3650

    TAOS_CHECK_EXIT(tEncodeBool(pEncoder, pValue->isTbname));

24,748,418✔

3651

    if (pValue->isTbname) {

24,748,142✔

3652

      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pValue->uid));

20,629,410✔

3653

      if (vgId != -1) { pValue->vgId = vgId; }

10,314,236✔

3654

      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pValue->vgId));

20,629,655✔

3656

    TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pValue->data.type));

49,496,878✔

3657

    if (IS_VAR_DATA_TYPE(pValue->data.type)) {

24,748,460✔

3658

      TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pValue->data.pData, pValue->data.nData));

41,532,623✔

3660

      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pValue->data.val));

7,964,332✔

3664

_exit:

23,718,221✔

3665

  return code;

23,718,221✔

3668

static int32_t tDeserializeStriggerGroupColVals(SDecoder* pDecoder, SArray** ppGroupColVals) {

11,861,684✔

3669

  int32_t code = TSDB_CODE_SUCCESS;

11,861,684✔

3670

  int32_t lino = 0;

11,861,684✔

3671

  int32_t size = 0;

11,861,684✔

3673

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &size));

11,861,942✔

3674

  taosArrayClearEx(*ppGroupColVals, tDestroySStreamGroupValue);

11,861,942✔

3675

  if (size > 0) {

11,861,440✔

3676

    if (*ppGroupColVals == NULL) {

6,339,184✔

3677

      *ppGroupColVals = taosArrayInit(size, sizeof(SStreamGroupValue));

6,338,917✔

3678

      if (*ppGroupColVals == NULL) {

6,338,129✔

3685

  for (int32_t i = 0; i < size; ++i) {

24,244,422✔

3686

    SStreamGroupValue* pValue = taosArrayReserve(*ppGroupColVals, 1);

12,382,987✔

3687

    if (pValue == NULL) {

12,383,666✔

3690

    TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &pValue->isNull));

12,383,666✔

3691

    if (pValue->isNull) {

12,383,770✔

3692

      continue;

11,040✔

3694

    TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &pValue->isTbname));

12,372,358✔

3695

    if (pValue->isTbname) {

12,372,895✔

3696

      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pValue->uid));

10,313,182✔

3697

      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pValue->vgId));

10,313,182✔

3699

    TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pValue->data.type));

24,746,034✔

3700

    if (IS_VAR_DATA_TYPE(pValue->data.type)) {

22,754,274✔

3701

      uint64_t len = 0;

10,381,681✔

3702

      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pValue->data.pData, &len));

20,762,307✔

3703

      pValue->data.nData = len;

10,381,004✔

3705

      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pValue->data.val));

3,983,053✔

3708

_exit:

11,861,435✔

3709

  return code;

11,861,167✔

3712

int32_t tSerializeSStreamGroupInfo(void* buf, int32_t bufLen, const SStreamGroupInfo* gInfo, int32_t vgId) {

497,596✔

3713

  SEncoder encoder = {0};

497,596✔

3714

  int32_t  code = TSDB_CODE_SUCCESS;

497,596✔

3715

  int32_t  lino = 0;

497,596✔

3716

  int32_t  tlen = 0;

497,596✔

3718

  tEncoderInit(&encoder, buf, bufLen);

497,596✔

3719

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

497,596✔

3721

  TAOS_CHECK_EXIT(tSerializeStriggerGroupColVals(&encoder, gInfo->gInfo, vgId));

497,596✔

3723

  tEndEncode(&encoder);

497,355✔

3725

_exit:

497,355✔

3726

  if (code != TSDB_CODE_SUCCESS) {

497,355✔

3729

    tlen = encoder.pos;

497,355✔

3731

  tEncoderClear(&encoder);

497,355✔

3732

  return tlen;

497,355✔

3735

int32_t tDeserializeSStreamGroupInfo(void* buf, int32_t bufLen, SStreamGroupInfo* gInfo) {

249,011✔

3736

  SDecoder decoder = {0};

249,011✔

3737

  int32_t  code = TSDB_CODE_SUCCESS;

249,011✔

3738

  int32_t  lino = 0;

249,011✔

3739

  int32_t  size = 0;

249,011✔

3741

  tDecoderInit(&decoder, buf, bufLen);

249,011✔

3742

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

249,011✔

3744

  TAOS_CHECK_EXIT(tDeserializeStriggerGroupColVals(&decoder, &gInfo->gInfo));

249,011✔

3746

  tEndDecode(&decoder);

249,011✔

3748

_exit:

249,011✔

3749

  tDecoderClear(&decoder);

249,011✔

3750

  return code;

249,011✔

3753

int32_t tSerializeSTriggerCalcRequest(void* buf, int32_t bufLen, const SSTriggerCalcRequest* pReq) {

6,044,845✔

3754

  SEncoder encoder = {0};

6,044,845✔

3755

  int32_t  code = TSDB_CODE_SUCCESS;

6,044,845✔

3756

  int32_t  lino = 0;

6,044,845✔

3757

  int32_t  tlen = 0;

6,044,845✔

3759

  tEncoderInit(&encoder, buf, bufLen);

6,044,845✔

3760

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

6,045,080✔

3762

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->streamId));

12,089,690✔

3763

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->runnerTaskId));

12,089,215✔

3764

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->sessionId));

12,088,809✔

3765

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->triggerType));

12,088,869✔

3766

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->gid));

12,088,860✔

3768

  TAOS_CHECK_EXIT(tSerializeSTriggerCalcParam(&encoder, pReq->params, false, true));

6,044,430✔

3769

  TAOS_CHECK_EXIT(tSerializeStriggerGroupColVals(&encoder, pReq->groupColVals, -1));

6,045,080✔

3770

  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->createTable));

12,089,519✔

3771

  TAOS_CHECK_EXIT(tEncodeBool(&encoder, pReq->isWindowTrigger));

6,044,674✔

3772

  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->precision));

12,089,252✔

3774

  tEndEncode(&encoder);

6,044,172✔

3776

_exit:

6,044,674✔

3777

  if (code != TSDB_CODE_SUCCESS) {

6,044,674✔

3780

    tlen = encoder.pos;

6,044,674✔

3782

  tEncoderClear(&encoder);

6,044,674✔

3783

  return tlen;

6,044,175✔

3786

int32_t tDeserializeSTriggerCalcRequest(void* buf, int32_t bufLen, SSTriggerCalcRequest* pReq) {

3,021,461✔

3787

  SDecoder decoder = {0};

3,021,461✔

3788

  int32_t  code = TSDB_CODE_SUCCESS;

3,021,461✔

3789

  int32_t  lino = 0;

3,021,461✔

3791

  tDecoderInit(&decoder, buf, bufLen);

3,021,461✔

3792

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

3,021,461✔

3794

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->streamId));

6,042,922✔

3795

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->runnerTaskId));

6,042,922✔

3796

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->sessionId));

6,042,516✔

3797

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->triggerType));

6,042,516✔

3798

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->gid));

6,042,922✔

3800

  TAOS_CHECK_EXIT(tDeserializeSTriggerCalcParam(&decoder, &pReq->params, false));

3,021,461✔

3801

  TAOS_CHECK_EXIT(tDeserializeStriggerGroupColVals(&decoder, &pReq->groupColVals));

3,021,461✔

3802

  TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->createTable));

6,042,199✔

3803

  if (!tDecodeIsEnd(&decoder)) {

3,021,217✔

3804

    TAOS_CHECK_EXIT(tDecodeBool(&decoder, &pReq->isWindowTrigger));

3,020,982✔

3805

    TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->precision));

6,042,452✔

3808

  tEndDecode(&decoder);

3,021,461✔

3810

_exit:

3,021,461✔

3811

  tDecoderClear(&decoder);

3,021,461✔

3812

  return code;

3,021,217✔

3815

void tDestroySTriggerCalcRequest(SSTriggerCalcRequest* pReq) {

5,904,267✔

3816

  if (pReq != NULL) {

5,904,267✔

3817

    if (pReq->params != NULL) {

5,904,267✔

3818

      taosArrayDestroyEx(pReq->params, tDestroySSTriggerCalcParam);

3,293,257✔

3819

      pReq->params = NULL;

3,293,257✔

3821

    if (pReq->groupColVals != NULL) {

5,904,267✔

3822

      taosArrayDestroyEx(pReq->groupColVals, tDestroySStreamGroupValue);

634,019✔

3823

      pReq->groupColVals = NULL;

634,019✔

3825

    blockDataDestroy(pReq->pOutBlock);

5,904,267✔

3827

5,904,267✔

3888

int32_t tSerializeSTriggerCtrlRequest(void* buf, int32_t bufLen, const SSTriggerCtrlRequest* pReq) {

38,330,196✔

3889

  SEncoder encoder = {0};

38,330,196✔

3890

  int32_t  code = TSDB_CODE_SUCCESS;

38,330,196✔

3891

  int32_t  lino = 0;

38,330,196✔

3892

  int32_t  tlen = 0;

38,330,196✔

3894

  tEncoderInit(&encoder, buf, bufLen);

38,330,196✔

3895

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

38,330,196✔

3897

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->type));

76,660,392✔

3898

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->streamId));

76,660,148✔

3899

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->taskId));

76,660,148✔

3900

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->sessionId));

76,660,392✔

3902

  tEndEncode(&encoder);

38,330,196✔

3904

_exit:

38,329,708✔

3905

  if (code != TSDB_CODE_SUCCESS) {

38,329,952✔

3908

    tlen = encoder.pos;

38,329,952✔

3910

  tEncoderClear(&encoder);

38,329,952✔

3911

  return tlen;

38,330,196✔

3914

int32_t tDeserializeSTriggerCtrlRequest(void* buf, int32_t bufLen, SSTriggerCtrlRequest* pReq) {

57,453,515✔

3915

  SDecoder decoder = {0};

57,453,515✔

3916

  int32_t  code = TSDB_CODE_SUCCESS;

57,468,178✔

3917

  int32_t  lino = 0;

57,468,178✔

3919

  tDecoderInit(&decoder, buf, bufLen);

57,468,178✔

3920

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

57,463,393✔

3922

  int32_t type = 0;

57,474,562✔

3923

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &type));

57,476,878✔

3924

  pReq->type = type;

57,476,878✔

3925

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->streamId));

114,958,850✔

3926

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->taskId));

114,966,364✔

3927

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->sessionId));

114,965,859✔

3929

  tEndDecode(&decoder);

57,483,037✔

3931

_exit:

57,476,079✔

3932

  tDecoderClear(&decoder);

57,476,970✔

3933

  return code;

57,463,814✔

3936

int32_t tSerializeStRtFuncInfo(SEncoder* pEncoder, const SStreamRuntimeFuncInfo* pInfo, bool full) {

17,174,844✔

3937

  int32_t code = 0, lino = 0;

17,174,844✔

3938

  TAOS_CHECK_EXIT(tSerializeSTriggerCalcParam(pEncoder, pInfo->pStreamPesudoFuncVals, true, full));

17,174,844✔

3939

  TAOS_CHECK_EXIT(tSerializeStriggerGroupColVals(pEncoder, pInfo->pStreamPartColVals, -1));

17,176,190✔

3940

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->curWindow.skey));

34,351,564✔

3941

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->curWindow.ekey));

34,351,831✔

3942

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->groupId));

34,351,807✔

3943

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pInfo->curIdx));

34,351,088✔

3944

  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->sessionId));

34,350,330✔

3945

  TAOS_CHECK_EXIT(tEncodeBool(pEncoder, pInfo->withExternalWindow));

17,175,164✔

3946

  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pInfo->triggerType));

34,350,668✔

3947

  TAOS_CHECK_EXIT(tEncodeBool(pEncoder, pInfo->isWindowTrigger));

17,175,406✔

3948

  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pInfo->precision));

34,348,869✔

3949

_exit:

17,174,781✔

3950

  return code;

17,174,781✔

3953

int32_t tDeserializeStRtFuncInfo(SDecoder* pDecoder, SStreamRuntimeFuncInfo* pInfo) {

8,591,239✔

3954

  int32_t code = 0, lino = 0;

8,591,239✔

3955

  int32_t size = 0;

8,591,239✔

3956

  TAOS_CHECK_EXIT(tDeserializeSTriggerCalcParam(pDecoder, &pInfo->pStreamPesudoFuncVals, true));

8,591,239✔

3957

  TAOS_CHECK_EXIT(tDeserializeStriggerGroupColVals(pDecoder, &pInfo->pStreamPartColVals));

8,591,058✔

3958

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->curWindow.skey));

17,182,888✔

3959

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->curWindow.ekey));

17,183,428✔

3960

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->groupId));

17,183,428✔

3961

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pInfo->curIdx));

17,183,428✔

3962

  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->sessionId));

17,183,428✔

3963

  TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &pInfo->withExternalWindow));

8,591,714✔

3964

  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pInfo->triggerType));

17,183,428✔

3965

  if (!tDecodeIsEnd(pDecoder)) {

8,591,714✔

3966

    TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &pInfo->isWindowTrigger));

8,591,714✔

3967

    TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pInfo->precision));

17,183,428✔

3969

_exit:

8,591,714✔

3970

  return code;

8,591,714✔

3973

void tDestroyStRtFuncInfo(SStreamRuntimeFuncInfo* pInfo){

15,662,312✔

3974

  if (pInfo == NULL) return;

15,662,312✔

3975

  if (pInfo->pStreamPesudoFuncVals != NULL) {

15,662,312✔

3976

    taosArrayDestroyEx(pInfo->pStreamPesudoFuncVals, tDestroySSTriggerCalcParam);

8,774,881✔

3977

    pInfo->pStreamPesudoFuncVals = NULL;

8,774,881✔

3979

  if (pInfo->pStreamPartColVals != NULL) {

15,693,270✔

3980

    taosArrayDestroyEx(pInfo->pStreamPartColVals, tDestroySStreamGroupValue);

5,911,117✔

3981

    pInfo->pStreamPartColVals = NULL;

5,910,176✔

3985

int32_t tSerializeSStreamMsgVTableInfo(void* buf, int32_t bufLen, const SStreamMsgVTableInfo* pRsp){

137,080✔

3986

  SEncoder encoder = {0};

137,080✔

3987

  int32_t  code = TSDB_CODE_SUCCESS;

137,080✔

3988

  int32_t  lino = 0;

137,080✔

3989

  int32_t  tlen = 0;

137,080✔

3991

  tEncoderInit(&encoder, buf, bufLen);

137,080✔

3992

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

137,080✔

3994

  int32_t size = taosArrayGetSize(pRsp->infos);

137,080✔

3995

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, size));

137,080✔

3996

  for (int32_t i = 0; i < size; ++i) {

473,096✔

3997

    VTableInfo* info = taosArrayGet(pRsp->infos, i);

336,016✔

3998

    if (info == NULL) {

336,016✔

4001

    TAOS_CHECK_EXIT(tEncodeI64(&encoder, info->gId));

672,032✔

4002

    TAOS_CHECK_EXIT(tEncodeI64(&encoder, info->uid));

672,032✔

4003

    TAOS_CHECK_EXIT(tEncodeSColRefWrapper(&encoder, &info->cols));

336,016✔

4006

  tEndEncode(&encoder);

137,080✔

4008

_exit:

137,080✔

4009

  if (code != TSDB_CODE_SUCCESS) {

137,080✔

4012

    tlen = encoder.pos;

137,080✔

4014

  tEncoderClear(&encoder);

137,080✔

4015

  return tlen;

137,080✔

4018

int32_t tDeserializeSStreamMsgVTableInfo(void* buf, int32_t bufLen, SStreamMsgVTableInfo *vTableInfo){

68,540✔

4019

  SDecoder decoder = {0};

68,540✔

4020

  int32_t  code = TSDB_CODE_SUCCESS;

68,540✔

4021

  int32_t  lino = 0;

68,540✔

4022

  int32_t  size = 0;

68,540✔

4024

  tDecoderInit(&decoder, buf, bufLen);

68,540✔

4025

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

68,540✔

4027

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &size));

68,540✔

4028

  vTableInfo->infos = taosArrayInit(size, sizeof(VTableInfo));

68,540✔

4029

  if (vTableInfo->infos == NULL) {

68,540✔

4032

  for (int32_t i = 0; i < size; ++i) {

236,548✔

4033

    VTableInfo* info = taosArrayReserve(vTableInfo->infos, 1);

168,008✔

4034

    if (info == NULL) {

168,008✔

4037

    TAOS_CHECK_EXIT(tDecodeI64(&decoder, &info->gId));

336,016✔

4038

    TAOS_CHECK_EXIT(tDecodeI64(&decoder, &info->uid));

336,016✔

4039

    TAOS_CHECK_EXIT(tDecodeSColRefWrapperEx(&decoder, &info->cols, false));

168,008✔

4042

  tEndDecode(&decoder);

68,540✔

4044

_exit:

68,540✔

4045

  tDecoderClear(&decoder);

68,540✔

4046

  return code;

68,540✔

4050

void tDestroyVTableInfo(void *ptr) {

336,016✔

4051

  if (NULL == ptr) {

336,016✔

4054

  VTableInfo* pTable = (VTableInfo*)ptr;

336,016✔

4055

  taosMemoryFree(pTable->cols.pColRef);

336,016✔

4058

void tDestroySStreamMsgVTableInfo(SStreamMsgVTableInfo *ptr) {

24,710,644✔

4059

  if (ptr == NULL) return;

24,710,644✔

4060

  taosArrayDestroyEx(ptr->infos, tDestroyVTableInfo);

24,710,644✔

4061

  ptr->infos = NULL;

24,711,616✔

4064

int32_t tSerializeSStreamTsResponse(void* buf, int32_t bufLen, const SStreamTsResponse* pRsp) {

971,592✔

4065

  SEncoder encoder = {0};

971,592✔

4066

  int32_t  code = TSDB_CODE_SUCCESS;

972,312✔

4067

  int32_t  lino = 0;

972,312✔

4068

  int32_t  tlen = 0;

972,312✔

4070

  tEncoderInit(&encoder, buf, bufLen);

972,312✔

4071

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

971,346✔

4073

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRsp->ver));

1,944,150✔

4074

  int32_t size = taosArrayGetSize(pRsp->tsInfo);

971,831✔

4075

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, size));

971,835✔

4076

  for (int32_t i = 0; i < size; ++i) {

2,022,851✔

4077

    STsInfo* tsInfo = taosArrayGet(pRsp->tsInfo, i);

1,051,990✔

4078

    TAOS_CHECK_EXIT(tEncodeI64(&encoder, tsInfo->gId));

2,104,708✔

4079

    TAOS_CHECK_EXIT(tEncodeI64(&encoder, tsInfo->ts));

2,103,490✔

4082

  tEndEncode(&encoder);

970,861✔

4084

_exit:

972,328✔

4085

  if (code != TSDB_CODE_SUCCESS) {

972,328✔

4088

    tlen = encoder.pos;

972,328✔

4090

  tEncoderClear(&encoder);

972,328✔

4091

  return tlen;

972,075✔

4094

int32_t tDeserializeSStreamTsResponse(void* buf, int32_t bufLen, void *pBlock) {

486,706✔

4095

  SDecoder decoder = {0};

486,706✔

4096

  int32_t  code = TSDB_CODE_SUCCESS;

486,706✔

4097

  int32_t  lino = 0;

486,706✔

4098

  SSDataBlock *pResBlock = pBlock;

486,706✔

4100

  tDecoderInit(&decoder, buf, bufLen);

486,706✔

4101

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

486,706✔

4103

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, (int64_t*)&pResBlock->info.id.groupId));

973,412✔

4104

  int32_t numOfCols = 2;

486,706✔

4105

  if (pResBlock->pDataBlock == NULL) {

486,706✔

4106

    pResBlock->pDataBlock = taosArrayInit_s(sizeof(SColumnInfoData), numOfCols);

486,706✔

4107

    if (pResBlock->pDataBlock == NULL) {

486,706✔

4110

    for (int32_t i = 0; i< numOfCols; ++i) {

1,460,118✔

4111

      SColumnInfoData *pColInfoData = taosArrayGet(pResBlock->pDataBlock, i);

973,412✔

4112

      if (pColInfoData == NULL) {

973,412✔

4115

      pColInfoData->info.type = TSDB_DATA_TYPE_BIGINT;

973,412✔

4116

      pColInfoData->info.bytes = sizeof(int64_t);

973,412✔

4119

  int32_t numOfRows = 0;

486,706✔

4120

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &numOfRows));

486,706✔

4121

  TAOS_CHECK_EXIT(blockDataEnsureCapacity(pResBlock, numOfRows));

486,706✔

4122

  for (int32_t i = 0; i < numOfRows; ++i) {

1,013,505✔

4123

    for (int32_t j = 0; j < numOfCols; ++j) {

1,580,397✔

4124

      SColumnInfoData *pColInfoData = taosArrayGet(pResBlock->pDataBlock, j);

1,053,598✔

4125

      if (pColInfoData == NULL) {

1,053,598✔

4128

      int64_t value = 0;

1,053,598✔

4129

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &value));

1,053,598✔

4130

      colDataSetInt64(pColInfoData, i, &value);

1,053,598✔

4134

  pResBlock->info.dataLoad = 1;

486,706✔

4135

  pResBlock->info.rows = numOfRows;

486,706✔

4137

  tEndDecode(&decoder);

486,706✔

4139

_exit:

486,706✔

4140

  tDecoderClear(&decoder);

486,706✔

4141

  return code;

486,706✔

4144

static int32_t encodeData(SEncoder* encoder, void* pBlock, SSHashObj* indexHash) {

1,909,316✔

4145

  int32_t code = TSDB_CODE_SUCCESS;

1,909,316✔

4146

  int32_t lino = 0;

1,909,316✔

4147

  int32_t len = 0;

1,909,316✔

4148

  if (encoder->data == NULL){

1,909,316✔

4149

    len = blockGetEncodeSize(pBlock);

954,625✔

4151

    len = blockEncode(pBlock, (char*)(encoder->data + encoder->pos), encoder->size - encoder->pos, blockDataGetNumOfCols(pBlock));

954,691✔

4152

    if (len < 0) {

954,658✔

4156

  encoder->pos += len;

1,909,283✔

4158

  if (indexHash == NULL) {

1,909,283✔

4159

    goto _exit;

837,186✔

4162

  uint32_t pos = encoder->pos;

1,072,097✔

4163

  encoder->pos += sizeof(uint32_t); // reserve space for tables

1,072,097✔

4164

  int32_t tables = 0;

1,072,097✔

4166

  void*   pe = NULL;

1,072,097✔

4167

  int32_t iter = 0;

1,072,097✔

4168

  while ((pe = tSimpleHashIterate(indexHash, pe, &iter)) != NULL) {

2,392,584✔

4169

    SStreamWalDataSlice* pInfo = (SStreamWalDataSlice*)pe;

1,320,487✔

4170

    if (pInfo->gId == -1){

1,320,487✔

4173

    int64_t uid = *(int64_t*)(tSimpleHashGetKey(pe, NULL));

1,320,487✔

4174

    TAOS_CHECK_EXIT(tEncodeI64(encoder, uid));

1,320,242✔

4175

    TAOS_CHECK_EXIT(tEncodeU64(encoder, pInfo->gId));

2,640,729✔

4176

    TAOS_CHECK_EXIT(tEncodeI32(encoder, pInfo->startRowIdx));

2,640,974✔

4177

    TAOS_CHECK_EXIT(tEncodeI32(encoder, pInfo->numRows));

2,640,974✔

4178

    tables++;

1,320,487✔

4180

  uint32_t tmpPos = encoder->pos;

1,072,130✔

4181

  encoder->pos = pos;

1,072,130✔

4182

  TAOS_CHECK_EXIT(tEncodeI32(encoder, tables));

1,072,130✔

4183

  encoder->pos = tmpPos;

1,072,130✔

4184

_exit:

1,909,075✔

4185

  return code;

1,909,075✔

4188

static int32_t encodeBlock(SEncoder* encoder, void* block, SSHashObj* indexHash) {

6,617,821✔

4189

  int32_t  code = TSDB_CODE_SUCCESS;

6,617,821✔

4190

  int32_t  lino = 0;

6,617,821✔

4191

  if (block != NULL && ((SSDataBlock*)block)->info.rows > 0) {

6,617,821✔

4192

    TAOS_CHECK_EXIT(tEncodeI8(encoder, 1));

1,909,316✔

4193

    TAOS_CHECK_EXIT(encodeData(encoder, block, indexHash));

1,909,316✔

4195

    TAOS_CHECK_EXIT(tEncodeI8(encoder, 0));

4,709,234✔

4198

_exit:

4,709,234✔

4199

  return code;

6,618,550✔

4202

int32_t tSerializeSStreamWalDataResponse(void* buf, int32_t bufLen, SSTriggerWalNewRsp* rsp) {

1,654,758✔

4203

  SEncoder encoder = {0};

1,654,758✔

4204

  int32_t  code = TSDB_CODE_SUCCESS;

1,654,758✔

4205

  int32_t  lino = 0;

1,654,758✔

4206

  int32_t  tlen = 0;

1,654,758✔

4208

  tEncoderInit(&encoder, buf, bufLen);

1,654,758✔

4209

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

1,654,758✔

4211

  TAOS_CHECK_EXIT(encodeBlock(&encoder, rsp->dataBlock, rsp->indexHash));

1,654,758✔

4212

  TAOS_CHECK_EXIT(encodeBlock(&encoder, rsp->metaBlock, NULL));

1,654,758✔

4213

  TAOS_CHECK_EXIT(encodeBlock(&encoder, rsp->deleteBlock, NULL));

1,654,758✔

4214

  TAOS_CHECK_EXIT(encodeBlock(&encoder, rsp->tableBlock, NULL));

1,654,758✔

4216

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, rsp->ver));

3,309,516✔

4217

  TAOS_CHECK_EXIT(tEncodeI64(&encoder, rsp->verTime));

3,309,516✔

4218

  tEndEncode(&encoder);

1,654,758✔

4220

_exit:

1,654,517✔

4221

  if (code != TSDB_CODE_SUCCESS) {

1,654,517✔

4224

    tlen = encoder.pos;

1,654,517✔

4226

  tEncoderClear(&encoder);

1,654,517✔

4227

  return tlen;

1,654,517✔

4230

static int32_t decodeBlock(SDecoder* decoder, void* pBlock) {

2,482,781✔

4231

  int32_t  code = TSDB_CODE_SUCCESS;

2,482,781✔

4232

  int32_t  lino = 0;

2,482,781✔

4234

  int8_t hasData = false;

2,482,781✔

4235

  TAOS_CHECK_EXIT(tDecodeI8(decoder, &hasData));

2,482,781✔

4236

  if (hasData) {

2,482,781✔

4237

    TAOS_CHECK_EXIT(pBlock != NULL ? TSDB_CODE_SUCCESS : TSDB_CODE_INVALID_PARA);

418,741✔

4238

    const char* pEndPos = NULL;

418,741✔

4239

    TAOS_CHECK_EXIT(blockDecode(pBlock, (char*)decoder->data + decoder->pos, &pEndPos));

418,741✔

4240

    decoder->pos = (uint8_t*)pEndPos - decoder->data;

418,741✔

4241

  } else if (pBlock != NULL) {

2,064,040✔

4242

    blockDataEmpty(pBlock);

834,767✔

4245

_exit:

2,480,018✔

4246

  return code;

2,483,025✔

4249

int32_t tDeserializeSStreamWalDataResponse(void* buf, int32_t bufLen, SSTriggerWalNewRsp* pRsp, SArray* pSlices){

827,675✔

4250

  SDecoder     decoder = {0};

827,675✔

4251

  int32_t      code = TSDB_CODE_SUCCESS;

827,675✔

4252

  int32_t      lino = 0;

827,675✔

4253

  SSDataBlock* pBlock = NULL;

827,675✔

4255

  tDecoderInit(&decoder, buf, bufLen);

827,675✔

4256

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

827,675✔

4259

  int8_t hasData = false;

827,675✔

4260

  TAOS_CHECK_EXIT(tDecodeI8(&decoder, &hasData));

827,675✔

4261

  pBlock = pRsp->dataBlock;

827,675✔

4262

  if (hasData) {

827,675✔

4263

    TAOS_CHECK_EXIT(pBlock != NULL ? TSDB_CODE_SUCCESS : TSDB_CODE_INVALID_PARA);

536,213✔

4264

    const char* pEndPos = NULL;

536,213✔

4265

    TAOS_CHECK_EXIT(blockDecode(pBlock, (char*)decoder.data + decoder.pos, &pEndPos));

536,213✔

4266

    decoder.pos = (uint8_t*)pEndPos - decoder.data;

536,213✔

4268

    int32_t nSlices = 0;

536,213✔

4269

    TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nSlices));

536,213✔

4270

    TAOS_CHECK_EXIT(taosArrayEnsureCap(pSlices, nSlices));

536,213✔

4271

    taosArrayClear(pSlices);

536,213✔

4272

    int64_t  uid = 0;

536,213✔

4273

    uint64_t gid = 0;

536,213✔

4274

    int32_t  startIdx = 0;

536,213✔

4275

    int32_t  numRows = 0;

536,213✔

4276

    for (int32_t i = 0; i < nSlices; i++) {

1,196,621✔

4277

      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &uid));

660,408✔

4278

      TAOS_CHECK_EXIT(tDecodeU64(&decoder, &gid));

660,408✔

4279

      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &startIdx));

660,408✔

4280

      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &numRows));

660,408✔

4281

      int32_t endIdx = startIdx + numRows;

660,408✔

4282

      int64_t value[3] = {gid, uid, (int64_t)startIdx << 32 | endIdx};

660,408✔

4283

      void*   px = taosArrayPush(pSlices, value);

660,408✔

4284

      if (px == NULL) {

660,408✔

4289

  } else if (pBlock != NULL) {

291,462✔

4290

    blockDataEmpty(pBlock);

3,321✔

4291

    taosArrayClear(pSlices);

3,321✔

4294

  TAOS_CHECK_EXIT(decodeBlock(&decoder, pRsp->metaBlock));

827,675✔

4295

  TAOS_CHECK_EXIT(decodeBlock(&decoder, pRsp->deleteBlock));

827,675✔

4296

  TAOS_CHECK_EXIT(decodeBlock(&decoder, pRsp->tableBlock));

827,675✔

4298

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->ver));

1,655,350✔

4299

  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->verTime));

1,655,350✔

4301

  tEndDecode(&decoder);

827,675✔

4303

_exit:

827,675✔

4304

  if (code != TSDB_CODE_SUCCESS) {

827,675✔

4307

  tDecoderClear(&decoder);

827,675✔

4308

  return code;

827,675✔

taosdata / TDengine / #4997

Source File
Press 'n' to go to next uncovered line, 'b' for previous

taosdata / TDengine / #4997

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