taosdata/TDengine | Build 5006 | source/libs/nodes/src/nodesMsgFuncs.c | Coveralls

77

static int32_t initTlvEncoder(STlvEncoder* pEncoder) {

511,261,697✔

78

  pEncoder->allocSize = NODES_MSG_DEFAULT_LEN;

511,261,697✔

79

  pEncoder->offset = 0;

511,354,680✔

80

  pEncoder->tlvCount = 0;

511,341,166✔

81

  pEncoder->pBuf = taosMemoryMalloc(pEncoder->allocSize);

511,308,904✔

82

  return NULL == pEncoder->pBuf ? terrno : TSDB_CODE_SUCCESS;

510,481,257✔

85

static void clearTlvEncoder(STlvEncoder* pEncoder) { taosMemoryFree(pEncoder->pBuf); }

510,846,011✔

87

static void endTlvEncode(STlvEncoder* pEncoder, char** pMsg, int32_t* pLen) {

510,955,149✔

88

  *pMsg = pEncoder->pBuf;

510,955,149✔

89

  pEncoder->pBuf = NULL;

511,126,087✔

90

  *pLen = pEncoder->offset;

511,118,651✔

91

510,914,142✔

93

static int32_t tlvEncodeImpl(STlvEncoder* pEncoder, int16_t type, const void* pValue, int32_t len) {

2,147,483,647✔

94

  int32_t tlvLen = sizeof(STlv) + len;

2,147,483,647✔

95

  if (pEncoder->offset + tlvLen > pEncoder->allocSize) {

2,147,483,647✔

96

    pEncoder->allocSize = TMAX(pEncoder->allocSize * 2, pEncoder->allocSize + tlvLen);

230,246,377✔

97

    void* pNewBuf = taosMemoryRealloc(pEncoder->pBuf, pEncoder->allocSize);

230,318,082✔

98

    if (NULL == pNewBuf) {

230,172,816✔

101

    pEncoder->pBuf = pNewBuf;

230,172,816✔

103

  STlv* pTlv = (STlv*)(pEncoder->pBuf + pEncoder->offset);

2,147,483,647✔

104

  pTlv->type = htons(type);

2,147,483,647✔

105

  pTlv->len = htonl(len);

2,147,483,647✔

106

  memcpy(pTlv->value, pValue, len);

2,147,483,647✔

107

  pEncoder->offset += tlvLen;

2,147,483,647✔

108

  ++(pEncoder->tlvCount);

2,147,483,647✔

109

  return TSDB_CODE_SUCCESS;

2,147,483,647✔

112

static int32_t tlvEncodeValueImpl(STlvEncoder* pEncoder, const void* pValue, int32_t len) {

2,147,483,647✔

113

  if (pEncoder->offset + len > pEncoder->allocSize) {

2,147,483,647✔

114

    void* pNewBuf = taosMemoryRealloc(pEncoder->pBuf, pEncoder->allocSize * 2);

231,253,807✔

115

    if (NULL == pNewBuf) {

231,156,667✔

118

    pEncoder->pBuf = pNewBuf;

231,156,667✔

119

    pEncoder->allocSize = pEncoder->allocSize * 2;

231,098,389✔

121

  memcpy(pEncoder->pBuf + pEncoder->offset, pValue, len);

2,147,483,647✔

122

  pEncoder->offset += len;

2,147,483,647✔

123

  return TSDB_CODE_SUCCESS;

2,147,483,647✔

126

static int32_t tlvEncodeI8(STlvEncoder* pEncoder, int16_t type, int8_t value) {

2,147,483,647✔

127

  return tlvEncodeImpl(pEncoder, type, &value, sizeof(value));

2,147,483,647✔

130

static int32_t tlvEncodeValueI8(STlvEncoder* pEncoder, int8_t value) {

2,147,483,647✔

131

  return tlvEncodeValueImpl(pEncoder, &value, sizeof(value));

2,147,483,647✔

139

static int32_t tlvEncodeValueI16(STlvEncoder* pEncoder, int16_t value) {

2,147,483,647✔

140

  value = htons(value);

2,147,483,647✔

141

  return tlvEncodeValueImpl(pEncoder, &value, sizeof(value));

2,147,483,647✔

144

static int32_t tlvEncodeI32(STlvEncoder* pEncoder, int16_t type, int32_t value) {

2,147,483,647✔

145

  value = htonl(value);

2,147,483,647✔

146

  return tlvEncodeImpl(pEncoder, type, &value, sizeof(value));

2,147,483,647✔

149

static int32_t tlvEncodeValueI32(STlvEncoder* pEncoder, int32_t value) {

2,147,483,647✔

150

  value = htonl(value);

2,147,483,647✔

151

  return tlvEncodeValueImpl(pEncoder, &value, sizeof(value));

2,147,483,647✔

154

static int32_t tlvEncodeI64(STlvEncoder* pEncoder, int16_t type, int64_t value) {

494,452,266✔

155

  value = htonll(value);

494,452,266✔

156

  return tlvEncodeImpl(pEncoder, type, &value, sizeof(value));

494,452,266✔

159

static int32_t tlvEncodeValueI64(STlvEncoder* pEncoder, int64_t value) {

2,147,483,647✔

160

  value = htonll(value);

2,147,483,647✔

161

  return tlvEncodeValueImpl(pEncoder, &value, sizeof(value));

2,147,483,647✔

164

static int32_t tlvEncodeU8(STlvEncoder* pEncoder, int16_t type, uint8_t value) {

2,147,483,647✔

165

  return tlvEncodeImpl(pEncoder, type, &value, sizeof(value));

2,147,483,647✔

168

static int32_t tlvEncodeValueU8(STlvEncoder* pEncoder, uint8_t value) {

2,147,483,647✔

169

  return tlvEncodeValueImpl(pEncoder, &value, sizeof(value));

2,147,483,647✔

172

static int32_t tlvEncodeU16(STlvEncoder* pEncoder, int16_t type, uint16_t value) {

67,261,602✔

173

  value = htons(value);

67,261,602✔

174

  return tlvEncodeImpl(pEncoder, type, &value, sizeof(value));

67,261,602✔

177

static int32_t tlvEncodeValueU16(STlvEncoder* pEncoder, uint16_t value) {

680,369,513✔

178

  value = htons(value);

680,369,513✔

179

  return tlvEncodeValueImpl(pEncoder, &value, sizeof(value));

680,369,513✔

182

static int32_t tlvEncodeU64(STlvEncoder* pEncoder, int16_t type, uint64_t value) {

865,558,982✔

183

  value = htonll(value);

865,558,982✔

184

  return tlvEncodeImpl(pEncoder, type, &value, sizeof(value));

865,558,982✔

187

static int32_t tlvEncodeValueU64(STlvEncoder* pEncoder, uint64_t value) {

2,147,483,647✔

188

  value = htonll(value);

2,147,483,647✔

189

  return tlvEncodeValueImpl(pEncoder, &value, sizeof(value));

2,147,483,647✔

192

static int32_t tlvEncodeDouble(STlvEncoder* pEncoder, int16_t type, double value) {

25,875,565✔

193

  int64_t temp = *(int64_t*)&value;

25,875,565✔

194

  temp = htonll(temp);

25,886,502✔

195

  return tlvEncodeImpl(pEncoder, type, &temp, sizeof(temp));

25,886,502✔

198

static int32_t tlvEncodeValueDouble(STlvEncoder* pEncoder, double value) {

376,425,758✔

199

  int64_t temp = *(int64_t*)&value;

376,425,758✔

200

  temp = htonll(temp);

376,623,645✔

201

  return tlvEncodeValueImpl(pEncoder, &temp, sizeof(temp));

376,623,645✔

204

static int32_t tlvEncodeEnum(STlvEncoder* pEncoder, int16_t type, int32_t value) {

2,147,483,647✔

205

  value = htonl(value);

2,147,483,647✔

206

  return tlvEncodeImpl(pEncoder, type, &value, sizeof(value));

2,147,483,647✔

209

static int32_t tlvEncodeValueEnum(STlvEncoder* pEncoder, int32_t value) {

2,147,483,647✔

210

  value = htonl(value);

2,147,483,647✔

211

  return tlvEncodeValueImpl(pEncoder, &value, sizeof(value));

2,147,483,647✔

214

static int32_t tlvEncodeBool(STlvEncoder* pEncoder, int16_t type, int8_t value) {

2,147,483,647✔

215

  return tlvEncodeImpl(pEncoder, type, &value, sizeof(value));

2,147,483,647✔

218

static int32_t tlvEncodeValueBool(STlvEncoder* pEncoder, int8_t value) {

2,147,483,647✔

219

  return tlvEncodeValueImpl(pEncoder, &value, sizeof(value));

2,147,483,647✔

222

static int32_t tlvEncodeCStr(STlvEncoder* pEncoder, int16_t type, const char* pValue) {

2,147,483,647✔

223

  if (NULL == pValue) {

2,147,483,647✔

224

    return TSDB_CODE_SUCCESS;

245,217,649✔

226

  return tlvEncodeImpl(pEncoder, type, pValue, strlen(pValue));

1,911,007,958✔

229

static int32_t tlvEncodeValueCStr(STlvEncoder* pEncoder, const char* pValue) {

2,147,483,647✔

230

  int16_t len = strlen(pValue);

2,147,483,647✔

231

  int32_t code = tlvEncodeValueI16(pEncoder, len);

2,147,483,647✔

232

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

233

    code = tlvEncodeValueImpl(pEncoder, pValue, len);

2,147,483,647✔

235

  return code;

2,147,483,647✔

238

static int32_t tlvEncodeBinary(STlvEncoder* pEncoder, int16_t type, const void* pValue, int32_t len) {

214,817,596✔

239

  return tlvEncodeImpl(pEncoder, type, pValue, len);

214,817,596✔

242

static int32_t tlvEncodeObj(STlvEncoder* pEncoder, int16_t type, FToMsg func, const void* pObj) {

2,147,483,647✔

243

  if (NULL == pObj) {

2,147,483,647✔

244

    return TSDB_CODE_SUCCESS;

2,147,483,647✔

247

  if (pEncoder->offset + sizeof(STlv) > pEncoder->allocSize) {

2,147,483,647✔

248

    pEncoder->allocSize = TMAX(pEncoder->allocSize * 2, pEncoder->allocSize + sizeof(STlv));

125,317,935✔

249

    void* pNewBuf = taosMemoryRealloc(pEncoder->pBuf, pEncoder->allocSize);

125,322,348✔

250

    if (NULL == pNewBuf) {

125,233,793✔

253

    pEncoder->pBuf = pNewBuf;

125,233,793✔

256

  int32_t start = pEncoder->offset;

2,147,483,647✔

257

  pEncoder->offset += sizeof(STlv);

2,147,483,647✔

258

  int32_t code = func(pObj, pEncoder);

2,147,483,647✔

259

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

260

    STlv* pTlv = (STlv*)(pEncoder->pBuf + start);

2,147,483,647✔

261

    pTlv->type = htons(type);

2,147,483,647✔

262

    pTlv->len = htonl(pEncoder->offset - start - sizeof(STlv));

2,147,483,647✔

264

  ++(pEncoder->tlvCount);

2,147,483,647✔

265

  return code;

2,147,483,647✔

268

static int32_t tlvEncodeObjArray(STlvEncoder* pEncoder, int16_t type, FToMsg func, const void* pArray, int32_t itemSize,

35,596,920✔

270

  int32_t code = TSDB_CODE_SUCCESS;

35,596,920✔

271

  if (num > 0) {

35,596,920✔

272

    int32_t start = pEncoder->offset;

35,610,797✔

273

    pEncoder->offset += sizeof(STlv);

35,624,431✔

274

    for (size_t i = 0; TSDB_CODE_SUCCESS == code && i < num; ++i) {

71,584,113✔

275

      code = tlvEncodeObj(pEncoder, TLV_TYPE_ARRAY_ELEM, func, (const char*)pArray + i * itemSize);

35,971,525✔

277

    if (TSDB_CODE_SUCCESS == code) {

35,612,588✔

278

      STlv* pTlv = (STlv*)(pEncoder->pBuf + start);

35,622,693✔

279

      pTlv->type = htons(type);

35,622,669✔

280

      pTlv->len = htonl(pEncoder->offset - start - sizeof(STlv));

35,590,884✔

283

  return code;

35,582,280✔

286

static int32_t tlvEncodeValueArray(STlvEncoder* pEncoder, FToMsg func, const void* pArray, int32_t itemSize,

752,970,204✔

288

  int32_t code = tlvEncodeValueI32(pEncoder, num);

752,970,204✔

289

  for (size_t i = 0; TSDB_CODE_SUCCESS == code && i < num; ++i) {

1,433,024,809✔

290

    code = func((const char*)pArray + i * itemSize, pEncoder);

680,129,573✔

292

  return code;

752,895,236✔

295

static int32_t tlvGetNextTlv(STlvDecoder* pDecoder, STlv** pTlv) {

2,147,483,647✔

296

  if (pDecoder->offset == pDecoder->bufSize) {

2,147,483,647✔

297

    *pTlv = NULL;

2,147,483,647✔

298

    return TSDB_CODE_SUCCESS;

2,147,483,647✔

301

  *pTlv = (STlv*)(pDecoder->pBuf + pDecoder->offset);

2,147,483,647✔

302

  (*pTlv)->type = ntohs((*pTlv)->type);

2,147,483,647✔

303

  (*pTlv)->len = ntohl((*pTlv)->len);

2,147,483,647✔

304

  if ((*pTlv)->len + pDecoder->offset > pDecoder->bufSize) {

2,147,483,647✔

307

  pDecoder->offset += sizeof(STlv) + (*pTlv)->len;

2,147,483,647✔

308

  return TSDB_CODE_SUCCESS;

2,147,483,647✔

311

static bool tlvDecodeEnd(STlvDecoder* pDecoder) { return pDecoder->offset == pDecoder->bufSize; }

2,147,483,647✔

313

static int32_t tlvDecodeImpl(STlv* pTlv, void* pValue, int32_t len) {

2,147,483,647✔

314

  if (pTlv->len != len) {

2,147,483,647✔

317

  memcpy(pValue, pTlv->value, len);

2,147,483,647✔

318

  return TSDB_CODE_SUCCESS;

2,147,483,647✔

321

static int32_t tlvDecodeValueImpl(STlvDecoder* pDecoder, void* pValue, int32_t len) {

2,147,483,647✔

323

  if (pDecoder->bufSize == pDecoder->offset) {

2,147,483,647✔

324

    memset(pValue, 0, len);

2,147,483,647✔

325

    return TSDB_CODE_SUCCESS;

2,147,483,647✔

327

  if (len > pDecoder->bufSize - pDecoder->offset) {

2,147,483,647✔

330

  memcpy(pValue, pDecoder->pBuf + pDecoder->offset, len);

2,147,483,647✔

331

  pDecoder->offset += len;

2,147,483,647✔

332

  return TSDB_CODE_SUCCESS;

2,147,483,647✔

335

static int32_t tlvDecodeI8(STlv* pTlv, int8_t* pValue) { return tlvDecodeImpl(pTlv, pValue, sizeof(*pValue)); }

2,147,483,647✔

337

static int32_t tlvDecodeValueI8(STlvDecoder* pDecoder, int8_t* pValue) {

2,147,483,647✔

338

  return tlvDecodeValueImpl(pDecoder, pValue, sizeof(*pValue));

2,147,483,647✔

349

static int32_t tlvDecodeValueI16(STlvDecoder* pDecoder, int16_t* pValue) {

2,147,483,647✔

350

  int32_t code = tlvDecodeValueImpl(pDecoder, pValue, sizeof(*pValue));

2,147,483,647✔

351

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

352

    *pValue = ntohs(*pValue);

2,147,483,647✔

354

  return code;

2,147,483,647✔

357

static int32_t tlvDecodeI32(STlv* pTlv, int32_t* pValue) {

2,147,483,647✔

358

  int32_t code = tlvDecodeImpl(pTlv, pValue, sizeof(*pValue));

2,147,483,647✔

359

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

360

    *pValue = ntohl(*pValue);

2,147,483,647✔

362

  return code;

2,147,483,647✔

365

static int32_t tlvDecodeValueI32(STlvDecoder* pDecoder, int32_t* pValue) {

2,147,483,647✔

366

  int32_t code = tlvDecodeValueImpl(pDecoder, pValue, sizeof(*pValue));

2,147,483,647✔

367

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

368

    *pValue = ntohl(*pValue);

2,147,483,647✔

370

  return code;

2,147,483,647✔

373

static int32_t tlvDecodeI64(STlv* pTlv, int64_t* pValue) {

403,453,463✔

374

  int32_t code = tlvDecodeImpl(pTlv, pValue, sizeof(*pValue));

403,453,463✔

375

  if (TSDB_CODE_SUCCESS == code) {

403,464,031✔

376

    *pValue = ntohll(*pValue);

403,464,960✔

378

  return code;

403,448,695✔

381

static int32_t tlvDecodeValueI64(STlvDecoder* pDecoder, int64_t* pValue) {

2,147,483,647✔

382

  int32_t code = tlvDecodeValueImpl(pDecoder, pValue, sizeof(*pValue));

2,147,483,647✔

383

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

385

    *pValue = ntohll(*pValue);

2,147,483,647✔

391

  return code;

2,147,483,647✔

394

static int32_t tlvDecodeU8(STlv* pTlv, uint8_t* pValue) { return tlvDecodeImpl(pTlv, pValue, sizeof(*pValue)); }

2,147,483,647✔

396

static int32_t tlvDecodeValueU8(STlvDecoder* pDecoder, uint8_t* pValue) {

2,147,483,647✔

397

  return tlvDecodeValueImpl(pDecoder, pValue, sizeof(*pValue));

2,147,483,647✔

400

static int32_t tlvDecodeU16(STlv* pTlv, uint16_t* pValue) {

35,228,878✔

401

  int32_t code = tlvDecodeImpl(pTlv, pValue, sizeof(*pValue));

35,228,878✔

402

  if (TSDB_CODE_SUCCESS == code) {

35,228,352✔

403

    *pValue = ntohs(*pValue);

35,228,352✔

405

  return code;

35,228,276✔

408

static int32_t tlvDecodeValueU16(STlvDecoder* pDecoder, uint16_t* pValue) {

483,263,190✔

409

  int32_t code = tlvDecodeValueImpl(pDecoder, pValue, sizeof(*pValue));

483,263,190✔

410

  if (TSDB_CODE_SUCCESS == code) {

483,297,358✔

411

    *pValue = ntohs(*pValue);

483,296,959✔

413

  return code;

483,259,709✔

416

static int32_t tlvDecodeU64(STlv* pTlv, uint64_t* pValue) {

607,755,237✔

417

  int32_t code = tlvDecodeImpl(pTlv, pValue, sizeof(*pValue));

607,755,237✔

418

  if (TSDB_CODE_SUCCESS == code) {

607,771,520✔

419

    *pValue = ntohll(*pValue);

607,773,691✔

421

  return code;

607,745,051✔

424

static int32_t tlvDecodeValueU64(STlvDecoder* pDecoder, uint64_t* pValue) {

2,147,483,647✔

425

  int32_t code = tlvDecodeValueImpl(pDecoder, pValue, sizeof(*pValue));

2,147,483,647✔

426

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

427

    *pValue = ntohll(*pValue);

2,147,483,647✔

429

  return code;

2,147,483,647✔

432

static int32_t tlvDecodeDouble(STlv* pTlv, double* pValue) {

25,785,522✔

433

  volatile int64_t temp = 0;

25,785,522✔

434

  int32_t code = tlvDecodeI64(pTlv, (int64_t*)&temp);

25,787,638✔

435

  if (TSDB_CODE_SUCCESS == code) {

25,781,208✔

436

    *pValue = *(double*)&temp;

25,781,208✔

438

  return code;

25,783,309✔

441

static int32_t tlvDecodeValueDouble(STlvDecoder* pDecoder, double* pValue) {

271,162,646✔

442

  volatile int64_t temp = 0;

271,162,646✔

443

  int32_t code = tlvDecodeValueI64(pDecoder, (int64_t*)&temp);

271,176,433✔

444

  if (TSDB_CODE_SUCCESS == code) {

271,178,372✔

445

    *pValue = *(double*)&temp;

271,177,226✔

447

  return code;

271,160,842✔

450

static int32_t convertIntegerType(int32_t value, void* pValue, int16_t len) {

2,147,483,647✔

451

  switch (len) {

2,147,483,647✔

452

    case 1:

2,147,483,647✔

453

      *(int8_t*)pValue = value;

2,147,483,647✔

454

      break;

2,147,483,647✔

458

    case 4:

2,147,483,647✔

459

      *(int32_t*)pValue = value;

2,147,483,647✔

460

      break;

2,147,483,647✔

461

    default:

5✔

462

      return TSDB_CODE_FAILED;

5✔

464

  return TSDB_CODE_SUCCESS;

2,147,483,647✔

467

static int32_t tlvDecodeBool(STlv* pTlv, bool* pValue) {

2,147,483,647✔

468

  int8_t  value = 0;

2,147,483,647✔

469

  int32_t code = tlvDecodeI8(pTlv, &value);

2,147,483,647✔

470

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

471

    code = convertIntegerType(value, pValue, sizeof(bool));

2,147,483,647✔

473

  return code;

2,147,483,647✔

476

static int32_t tlvDecodeValueBool(STlvDecoder* pDecoder, bool* pValue) {

2,147,483,647✔

477

  int8_t  value = 0;

2,147,483,647✔

478

  int32_t code = tlvDecodeValueI8(pDecoder, &value);

2,147,483,647✔

479

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

480

    code = convertIntegerType(value, pValue, sizeof(bool));

2,147,483,647✔

482

  return code;

2,147,483,647✔

485

static int32_t tlvDecodeEnum(STlv* pTlv, void* pValue, int16_t len) {

2,147,483,647✔

486

  int32_t value = 0;

2,147,483,647✔

487

  int32_t code = tlvDecodeI32(pTlv, &value);

2,147,483,647✔

488

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

489

    code = convertIntegerType(value, pValue, len);

2,147,483,647✔

491

  return code;

2,147,483,647✔

494

static int32_t tlvDecodeValueEnum(STlvDecoder* pDecoder, void* pValue, int16_t len) {

2,147,483,647✔

495

  int32_t value = 0;

2,147,483,647✔

496

  int32_t code = tlvDecodeValueI32(pDecoder, &value);

2,147,483,647✔

497

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

498

    code = convertIntegerType(value, pValue, len);

2,147,483,647✔

500

  return code;

2,147,483,647✔

503

static int32_t tlvDecodeCStr(STlv* pTlv, char* pValue, int32_t size) {

1,203,874,255✔

504

  if (pTlv->len > size - 1) {

1,203,874,255✔

507

  memcpy(pValue, pTlv->value, pTlv->len);

1,203,912,458✔

508

  return TSDB_CODE_SUCCESS;

1,203,884,829✔

511

static int32_t tlvDecodeValueCStr(STlvDecoder* pDecoder, char* pValue) {

2,147,483,647✔

512

  int16_t len = 0;

2,147,483,647✔

513

  int32_t code = tlvDecodeValueI16(pDecoder, &len);

2,147,483,647✔

514

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

515

    code = tlvDecodeValueImpl(pDecoder, pValue, len);

2,147,483,647✔

517

  return code;

2,147,483,647✔

520

static int32_t tlvDecodeCStrP(STlv* pTlv, char** pValue) {

243,614,468✔

521

  *pValue = taosStrndup(pTlv->value, pTlv->len);

243,614,468✔

522

  return NULL == *pValue ? terrno : TSDB_CODE_SUCCESS;

243,602,663✔

525

static int32_t tlvDecodeDynBinary(STlv* pTlv, void** pValue) {

1,449✔

526

  *pValue = taosMemoryMalloc(pTlv->len);

1,449✔

527

  if (NULL == *pValue) {

1,449✔

530

  memcpy(*pValue, pTlv->value, pTlv->len);

1,449✔

531

  return TSDB_CODE_SUCCESS;

1,449✔

534

static int32_t tlvDecodeBinary(STlv* pTlv, void* pValue) {

167,092,642✔

535

  memcpy(pValue, pTlv->value, pTlv->len);

167,092,642✔

536

  return TSDB_CODE_SUCCESS;

167,093,458✔

539

static int32_t tlvDecodeObjFromTlv(STlv* pTlv, FToObject func, void* pObj) {

2,147,483,647✔

540

  STlvDecoder decoder = {.bufSize = pTlv->len, .offset = 0, .pBuf = pTlv->value};

2,147,483,647✔

541

  return func(&decoder, pObj);

2,147,483,647✔

553

static int32_t tlvDecodeObjArray(STlvDecoder* pDecoder, FToObject func, void* pArray, int32_t itemSize) {

18,675,305✔

554

  int32_t code = TSDB_CODE_SUCCESS;

18,675,305✔

555

  int32_t i = 0;

18,675,305✔

556

  STlv*   pTlv = NULL;

18,675,305✔

557

  tlvForEach(pDecoder, pTlv, code) { code = tlvDecodeObjFromTlv(pTlv, func, (char*)pArray + itemSize * i++); }

37,679,021✔

558

  return code;

18,674,703✔

561

static int32_t tlvDecodeValueArray(STlvDecoder* pDecoder, FToObject func, void* pArray, int32_t itemSize,

538,473,927✔

563

  int32_t code = tlvDecodeValueI32(pDecoder, pNum);

538,473,927✔

564

  for (size_t i = 0; TSDB_CODE_SUCCESS == code && i < *pNum; ++i) {

1,021,784,282✔

565

    code = func(pDecoder, (char*)pArray + i * itemSize);

483,292,294✔

567

  return code;

538,493,474✔

570

static int32_t tlvDecodeObjArrayFromTlv(STlv* pTlv, FToObject func, void* pArray, int32_t itemSize) {

18,675,305✔

571

  STlvDecoder decoder = {.bufSize = pTlv->len, .offset = 0, .pBuf = pTlv->value};

18,675,305✔

572

  return tlvDecodeObjArray(&decoder, func, pArray, itemSize);

18,675,305✔

575

static int32_t tlvDecodeDynObjFromTlv(STlv* pTlv, FMakeObject makeFunc, FToObject toFunc, void** pObj) {

2,147,483,647✔

576

  int32_t code = makeFunc(pTlv->type, (SNode**)pObj);

2,147,483,647✔

577

  if (NULL == *pObj) {

2,147,483,647✔

580

  return tlvDecodeObjFromTlv(pTlv, toFunc, *pObj);

2,147,483,647✔

583

static int32_t tlvDecodeDynObj(STlvDecoder* pDecoder, FMakeObject makeFunc, FToObject toFunc, void** pObj) {

2,147,483,647✔

584

  STlv*   pTlv = NULL;

2,147,483,647✔

585

  int32_t code = tlvGetNextTlv(pDecoder, &pTlv);

2,147,483,647✔

586

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

587

    code = tlvDecodeDynObjFromTlv(pTlv, makeFunc, toFunc, pObj);

2,147,483,647✔

589

  return code;

2,147,483,647✔

594

static int32_t dataTypeInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,147,483,647✔

595

  const SDataType* pNode = (const SDataType*)pObj;

2,147,483,647✔

597

  int32_t code = tlvEncodeValueI8(pEncoder, pNode->type);

2,147,483,647✔

598

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

599

    code = tlvEncodeValueU8(pEncoder, pNode->precision);

2,147,483,647✔

601

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

602

    code = tlvEncodeValueU8(pEncoder, pNode->scale);

2,147,483,647✔

604

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

605

    code = tlvEncodeValueI32(pEncoder, pNode->bytes);

2,147,483,647✔

608

  return code;

2,147,483,647✔

611

static int32_t dataTypeToMsg(const void* pObj, STlvEncoder* pEncoder) {

1,666,093,066✔

612

  const SDataType* pNode = (const SDataType*)pObj;

1,666,093,066✔

614

  int32_t code = tlvEncodeI8(pEncoder, DATA_TYPE_CODE_TYPE, pNode->type);

1,666,093,066✔

615

  if (TSDB_CODE_SUCCESS == code) {

1,666,648,065✔

616

    code = tlvEncodeU8(pEncoder, DATA_TYPE_CODE_PRECISION, pNode->precision);

1,666,677,492✔

618

  if (TSDB_CODE_SUCCESS == code) {

1,667,242,424✔

619

    code = tlvEncodeU8(pEncoder, DATA_TYPE_CODE_SCALE, pNode->scale);

1,667,251,446✔

621

  if (TSDB_CODE_SUCCESS == code) {

1,667,302,441✔

622

    code = tlvEncodeI32(pEncoder, DATA_TYPE_CODE_BYTES, pNode->bytes);

1,667,313,847✔

625

  return code;

1,667,290,080✔

628

static int32_t msgToDataTypeInline(STlvDecoder* pDecoder, void* pObj) {

2,147,483,647✔

629

  SDataType* pNode = (SDataType*)pObj;

2,147,483,647✔

631

  int32_t code = tlvDecodeValueI8(pDecoder, &pNode->type);

2,147,483,647✔

632

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

633

    code = tlvDecodeValueU8(pDecoder, &pNode->precision);

2,147,483,647✔

635

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

636

    code = tlvDecodeValueU8(pDecoder, &pNode->scale);

2,147,483,647✔

638

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

639

    code = tlvDecodeValueI32(pDecoder, &pNode->bytes);

2,147,483,647✔

642

  return code;

2,147,483,647✔

645

static int32_t msgToDataType(STlvDecoder* pDecoder, void* pObj) {

1,322,291,637✔

646

  SDataType* pNode = (SDataType*)pObj;

1,322,291,637✔

648

  int32_t code = TSDB_CODE_SUCCESS;

1,322,291,637✔

649

  STlv*   pTlv = NULL;

1,322,291,637✔

650

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

651

    switch (pTlv->type) {

2,147,483,647✔

652

      case DATA_TYPE_CODE_TYPE:

1,322,321,791✔

653

        code = tlvDecodeI8(pTlv, &pNode->type);

1,322,321,791✔

654

        break;

1,322,286,077✔

655

      case DATA_TYPE_CODE_PRECISION:

1,322,333,072✔

656

        code = tlvDecodeU8(pTlv, &pNode->precision);

1,322,333,072✔

657

        break;

1,322,327,928✔

658

      case DATA_TYPE_CODE_SCALE:

1,322,343,993✔

659

        code = tlvDecodeU8(pTlv, &pNode->scale);

1,322,343,993✔

660

        break;

1,322,337,470✔

661

      case DATA_TYPE_CODE_BYTES:

1,322,190,436✔

662

        code = tlvDecodeI32(pTlv, &pNode->bytes);

1,322,190,436✔

663

        break;

1,322,318,273✔

669

  return code;

1,322,059,232✔

674

static int32_t exprNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

1,666,195,473✔

675

  const SExprNode* pNode = (const SExprNode*)pObj;

1,666,195,473✔

676

  int32_t          code = tlvEncodeObj(pEncoder, EXPR_CODE_RES_TYPE, dataTypeToMsg, &pNode->resType);

1,666,195,473✔

677

  if (TSDB_CODE_SUCCESS == code) {

1,667,185,960✔

678

    code = tlvEncodeBool(pEncoder, EXPR_CODE_HAS_NULL, pNode->hasNull);

1,667,212,317✔

680

  if (TSDB_CODE_SUCCESS == code) {

1,667,294,037✔

681

    code = tlvEncodeI32(pEncoder, EXPR_CODE_BIND_TUPLE_FUNC_IDX, pNode->relatedTo);

1,667,299,571✔

683

  if (TSDB_CODE_SUCCESS == code) {

1,667,315,408✔

684

    code = tlvEncodeI32(pEncoder, EXPR_CODE_TUPLE_FUNC_IDX, pNode->bindExprID);

1,667,322,412✔

686

  return code;

1,667,332,394✔

689

static int32_t msgToExprNode(STlvDecoder* pDecoder, void* pObj) {

1,322,282,262✔

690

  SExprNode* pNode = (SExprNode*)pObj;

1,322,282,262✔

692

  int32_t code = TSDB_CODE_SUCCESS;

1,322,282,262✔

693

  STlv*   pTlv = NULL;

1,322,282,262✔

694

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

695

    switch (pTlv->type) {

2,147,483,647✔

696

      case EXPR_CODE_RES_TYPE:

1,322,342,312✔

697

        code = tlvDecodeObjFromTlv(pTlv, msgToDataType, &pNode->resType);

1,322,342,312✔

698

        break;

1,322,307,332✔

699

      case EXPR_CODE_BIND_TUPLE_FUNC_IDX:

1,322,335,515✔

700

        code = tlvDecodeI32(pTlv, &pNode->relatedTo);

1,322,335,515✔

701

        break;

1,322,318,985✔

702

      case EXPR_CODE_TUPLE_FUNC_IDX:

1,322,328,539✔

703

        code = tlvDecodeI32(pTlv, &pNode->bindExprID);

1,322,328,539✔

704

        break;

1,322,323,081✔

705

      case EXPR_CODE_HAS_NULL:

1,322,210,231✔

706

        code = tlvDecodeBool(pTlv, &pNode->hasNull);

1,322,210,231✔

707

        break;

1,322,318,073✔

713

  return code;

1,322,797,533✔

718

static int32_t columnNodeInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,147,483,647✔

719

  const SColumnNode* pNode = (const SColumnNode*)pObj;

2,147,483,647✔

721

  int32_t code = dataTypeInlineToMsg(&pNode->node.resType, pEncoder);

2,147,483,647✔

722

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

723

    code = tlvEncodeValueI32(pEncoder, pNode->node.relatedTo);

2,147,483,647✔

725

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

726

    code = tlvEncodeValueI32(pEncoder, pNode->node.bindExprID);

2,147,483,647✔

728

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

729

    code = tlvEncodeValueU64(pEncoder, pNode->tableId);

2,147,483,647✔

731

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

732

    code = tlvEncodeValueI8(pEncoder, pNode->tableType);

2,147,483,647✔

734

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

735

    code = tlvEncodeValueI16(pEncoder, pNode->colId);

2,147,483,647✔

737

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

738

    code = tlvEncodeValueEnum(pEncoder, pNode->colType);

2,147,483,647✔

740

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

741

    code = tlvEncodeValueCStr(pEncoder, pNode->dbName);

2,147,483,647✔

743

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

744

    code = tlvEncodeValueCStr(pEncoder, pNode->tableName);

2,147,483,647✔

746

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

747

    code = tlvEncodeValueCStr(pEncoder, pNode->tableAlias);

2,147,483,647✔

749

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

750

    code = tlvEncodeValueCStr(pEncoder, pNode->colName);

2,147,483,647✔

752

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

753

    code = tlvEncodeValueI64(pEncoder, pNode->dataBlockId);

2,147,483,647✔

755

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

756

    code = tlvEncodeValueI16(pEncoder, pNode->slotId);

2,147,483,647✔

758

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

759

    code = tlvEncodeValueBool(pEncoder, pNode->tableHasPk);

2,147,483,647✔

761

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

762

    code = tlvEncodeValueBool(pEncoder, pNode->isPk);

2,147,483,647✔

764

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

765

    code = tlvEncodeValueI16(pEncoder, pNode->numOfPKs);

2,147,483,647✔

767

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

768

    code = tlvEncodeValueBool(pEncoder, pNode->isPrimTs);

2,147,483,647✔

770

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

771

    code = tlvEncodeValueBool(pEncoder, pNode->hasDep);

2,147,483,647✔

773

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

774

    code = tlvEncodeValueBool(pEncoder, pNode->hasRef);

2,147,483,647✔

776

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

777

    code = tlvEncodeValueCStr(pEncoder, pNode->refDbName);

2,147,483,647✔

779

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

780

    code = tlvEncodeValueCStr(pEncoder, pNode->refTableName);

2,147,483,647✔

782

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

783

    code = tlvEncodeValueCStr(pEncoder, pNode->refColName);

2,147,483,647✔

785

  return code;

2,147,483,647✔

788

static int32_t columnNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,147,483,647✔

789

  return tlvEncodeObj(pEncoder, COLUMN_CODE_INLINE_ATTRS, columnNodeInlineToMsg, pObj);

2,147,483,647✔

792

static int32_t msgToColumnNodeInline(STlvDecoder* pDecoder, void* pObj) {

2,147,483,647✔

793

  SColumnNode* pNode = (SColumnNode*)pObj;

2,147,483,647✔

795

  int32_t code = msgToDataTypeInline(pDecoder, &pNode->node.resType);

2,147,483,647✔

796

    if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

797

    code = tlvDecodeValueI32(pDecoder, &pNode->node.relatedTo);

2,147,483,647✔

799

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

800

    code = tlvDecodeValueI32(pDecoder, &pNode->node.bindExprID);

2,147,483,647✔

802

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

803

    code = tlvDecodeValueU64(pDecoder, &pNode->tableId);

2,147,483,647✔

805

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

806

    code = tlvDecodeValueI8(pDecoder, &pNode->tableType);

2,147,483,647✔

808

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

809

    code = tlvDecodeValueI16(pDecoder, &pNode->colId);

2,147,483,647✔

811

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

812

    code = tlvDecodeValueEnum(pDecoder, &pNode->colType, sizeof(pNode->colType));

2,147,483,647✔

814

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

815

    code = tlvDecodeValueCStr(pDecoder, pNode->dbName);

2,147,483,647✔

817

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

818

    code = tlvDecodeValueCStr(pDecoder, pNode->tableName);

2,147,483,647✔

820

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

821

    code = tlvDecodeValueCStr(pDecoder, pNode->tableAlias);

2,147,483,647✔

823

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

824

    code = tlvDecodeValueCStr(pDecoder, pNode->colName);

2,147,483,647✔

826

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

827

    code = tlvDecodeValueI64(pDecoder, &pNode->dataBlockId);

2,147,483,647✔

829

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

830

    code = tlvDecodeValueI16(pDecoder, &pNode->slotId);

2,147,483,647✔

832

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

833

    code = tlvDecodeValueBool(pDecoder, &pNode->tableHasPk);

2,147,483,647✔

835

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

836

    code = tlvDecodeValueBool(pDecoder, &pNode->isPk);

2,147,483,647✔

838

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

839

    code = tlvDecodeValueI16(pDecoder, &pNode->numOfPKs);

2,147,483,647✔

841

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

842

    code = tlvDecodeValueBool(pDecoder, &pNode->isPrimTs);

2,147,483,647✔

844

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

845

    code = tlvDecodeValueBool(pDecoder, &pNode->hasDep);

2,147,483,647✔

847

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

848

    code = tlvDecodeValueBool(pDecoder, &pNode->hasRef);

2,147,483,647✔

850

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

851

    code = tlvDecodeValueCStr(pDecoder, pNode->refDbName);

2,147,483,647✔

853

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

854

    code = tlvDecodeValueCStr(pDecoder, pNode->refTableName);

2,147,483,647✔

856

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

857

    code = tlvDecodeValueCStr(pDecoder, pNode->refColName);

2,147,483,647✔

859

  return code;

2,147,483,647✔

862

static int32_t msgToColumnNode(STlvDecoder* pDecoder, void* pObj) {

2,147,483,647✔

863

  SColumnNode* pNode = (SColumnNode*)pObj;

2,147,483,647✔

865

  int32_t code = TSDB_CODE_SUCCESS;

2,147,483,647✔

866

  STlv*   pTlv = NULL;

2,147,483,647✔

867

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

868

    switch (pTlv->type) {

2,147,483,647✔

869

      case COLUMN_CODE_INLINE_ATTRS:

2,147,483,647✔

870

        code = tlvDecodeObjFromTlv(pTlv, msgToColumnNodeInline, pNode);

2,147,483,647✔

871

        break;

2,147,483,647✔

877

  return code;

2,147,483,647✔

890

static int32_t datumToMsg(const void* pObj, STlvEncoder* pEncoder) {

463,402,827✔

891

  const SValueNode* pNode = (const SValueNode*)pObj;

463,402,827✔

893

  int32_t code = TSDB_CODE_SUCCESS;

463,402,827✔

894

  switch (pNode->node.resType.type) {

463,402,827✔

897

    case TSDB_DATA_TYPE_BOOL:

17,767,474✔

898

      code = tlvEncodeBool(pEncoder, VALUE_CODE_DATUM, pNode->datum.b);

17,767,474✔

899

      break;

17,781,420✔

900

    case TSDB_DATA_TYPE_TINYINT:

346,996,226✔

905

      code = tlvEncodeI64(pEncoder, VALUE_CODE_DATUM, pNode->datum.i);

346,996,226✔

906

      break;

347,437,699✔

907

    case TSDB_DATA_TYPE_UTINYINT:

16,318✔

911

      code = tlvEncodeU64(pEncoder, VALUE_CODE_DATUM, pNode->datum.u);

16,318✔

912

      break;

16,318✔

913

    case TSDB_DATA_TYPE_FLOAT:

25,817,827✔

915

      code = tlvEncodeDouble(pEncoder, VALUE_CODE_DATUM, pNode->datum.d);

25,817,827✔

916

      break;

25,882,507✔

917

    case TSDB_DATA_TYPE_VARCHAR:

72,127,429✔

921

      code = tlvEncodeBinary(pEncoder, VALUE_CODE_DATUM, pNode->datum.p, varDataTLen(pNode->datum.p));

72,127,429✔

922

      break;

72,322,422✔

923

    case TSDB_DATA_TYPE_JSON:

1,452✔

924

      code = tlvEncodeBinary(pEncoder, VALUE_CODE_DATUM, pNode->datum.p, getJsonValueLen(pNode->datum.p));

1,452✔

925

      break;

1,452✔

926

    case TSDB_DATA_TYPE_DECIMAL:

2,461✔

927

      code = tlvEncodeBinary(pEncoder, VALUE_CODE_DATUM, pNode->datum.p, pNode->node.resType.bytes);

2,461✔

928

      break;

2,461✔

929

    case TSDB_DATA_TYPE_DECIMAL64:

194✔

930

      code = tlvEncodeI64(pEncoder, VALUE_CODE_DATUM, pNode->datum.i);

194✔

931

      break;

194✔

936

    default:

4,575✔

937

      break;

4,575✔

940

  return code;

463,422,459✔

943

static int32_t valueNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

555,073,610✔

944

  const SValueNode* pNode = (const SValueNode*)pObj;

555,073,610✔

946

  int32_t code = tlvEncodeObj(pEncoder, VALUE_CODE_EXPR_BASE, exprNodeToMsg, pNode);

555,073,610✔

947

  if (TSDB_CODE_SUCCESS == code) {

555,373,619✔

948

    code = tlvEncodeCStr(pEncoder, VALUE_CODE_LITERAL, pNode->literal);

555,377,103✔

950

  if (TSDB_CODE_SUCCESS == code) {

555,344,368✔

951

    code = tlvEncodeI32(pEncoder, VALUE_CODE_FLAG, pNode->flag);

555,323,452✔

953

  if (TSDB_CODE_SUCCESS == code) {

555,294,726✔

954

    code = tlvEncodeBool(pEncoder, VALUE_CODE_TRANSLATE, pNode->translate);

555,274,689✔

956

  if (TSDB_CODE_SUCCESS == code) {

555,396,638✔

957

    code = tlvEncodeBool(pEncoder, VALUE_CODE_NOT_RESERVED, pNode->notReserved);

555,377,432✔

959

  if (TSDB_CODE_SUCCESS == code) {

555,194,351✔

960

    code = tlvEncodeBool(pEncoder, VALUE_CODE_IS_NULL, pNode->isNull);

555,175,714✔

962

  if (TSDB_CODE_SUCCESS == code && !pNode->isNull && !IS_VAL_UNSET(pNode->flag)) {

555,397,387✔

963

    code = datumToMsg(pNode, pEncoder);

463,466,632✔

966

  return code;

555,159,530✔

969

static int32_t msgToDatum(STlv* pTlv, void* pObj) {

387,702,710✔

970

  SValueNode* pNode = (SValueNode*)pObj;

387,702,710✔

972

  int32_t code = TSDB_CODE_SUCCESS;

387,702,710✔

973

  switch (pNode->node.resType.type) {

387,702,710✔

976

    case TSDB_DATA_TYPE_BOOL:

17,713,029✔

977

      code = tlvDecodeBool(pTlv, &pNode->datum.b);

17,713,029✔

978

      *(bool*)&pNode->typeData = pNode->datum.b;

17,715,375✔

979

      break;

17,714,693✔

980

    case TSDB_DATA_TYPE_TINYINT:

151,564,216✔

981

      code = tlvDecodeI64(pTlv, &pNode->datum.i);

151,564,216✔

982

      *(int8_t*)&pNode->typeData = pNode->datum.i;

151,576,109✔

983

      break;

151,581,090✔

984

    case TSDB_DATA_TYPE_SMALLINT:

8,525,152✔

985

      code = tlvDecodeI64(pTlv, &pNode->datum.i);

8,525,152✔

986

      *(int16_t*)&pNode->typeData = pNode->datum.i;

8,527,252✔

987

      break;

8,529,820✔

988

    case TSDB_DATA_TYPE_INT:

15,164,516✔

989

      code = tlvDecodeI64(pTlv, &pNode->datum.i);

15,164,516✔

990

      *(int32_t*)&pNode->typeData = pNode->datum.i;

15,164,118✔

991

      break;

15,166,168✔

992

    case TSDB_DATA_TYPE_BIGINT:

102,828,759✔

993

      code = tlvDecodeI64(pTlv, &pNode->datum.i);

102,828,759✔

994

      *(int64_t*)&pNode->typeData = pNode->datum.i;

102,830,644✔

995

      break;

102,846,041✔

996

    case TSDB_DATA_TYPE_TIMESTAMP:

9,436,786✔

997

      code = tlvDecodeI64(pTlv, &pNode->datum.i);

9,436,786✔

998

      *(int64_t*)&pNode->typeData = pNode->datum.i;

9,436,786✔

999

      break;

9,436,786✔

1000

    case TSDB_DATA_TYPE_UTINYINT:

6,322✔

1001

      code = tlvDecodeU64(pTlv, &pNode->datum.u);

6,322✔

1002

      *(uint8_t*)&pNode->typeData = pNode->datum.u;

6,322✔

1003

      break;

6,322✔

1004

    case TSDB_DATA_TYPE_USMALLINT:

1,284✔

1005

      code = tlvDecodeU64(pTlv, &pNode->datum.u);

1,284✔

1006

      *(uint16_t*)&pNode->typeData = pNode->datum.u;

1,284✔

1007

      break;

1,284✔

1008

    case TSDB_DATA_TYPE_UINT:

2,282✔

1009

      code = tlvDecodeU64(pTlv, &pNode->datum.u);

2,282✔

1010

      *(uint32_t*)&pNode->typeData = pNode->datum.u;

2,282✔

1011

      break;

2,282✔

1012

    case TSDB_DATA_TYPE_UBIGINT:

6,414✔

1013

      code = tlvDecodeU64(pTlv, &pNode->datum.u);

6,414✔

1014

      *(uint64_t*)&pNode->typeData = pNode->datum.u;

6,414✔

1015

      break;

6,414✔

1016

    case TSDB_DATA_TYPE_FLOAT:

1,353,718✔

1017

      code = tlvDecodeDouble(pTlv, &pNode->datum.d);

1,353,718✔

1018

      *(float*)&pNode->typeData = pNode->datum.d;

1,353,718✔

1019

      break;

1,353,718✔

1020

    case TSDB_DATA_TYPE_DOUBLE:

24,430,568✔

1021

      code = tlvDecodeDouble(pTlv, &pNode->datum.d);

24,430,568✔

1022

      *(double*)&pNode->typeData = pNode->datum.d;

24,424,318✔

1023

      break;

24,431,565✔

1024

    case TSDB_DATA_TYPE_NCHAR:

56,625,699✔

1028

      if (pTlv->len > pNode->node.resType.bytes + VARSTR_HEADER_SIZE) {

56,625,699✔

1032

      pNode->datum.p = taosMemoryCalloc(1, pNode->node.resType.bytes + 1);

56,616,357✔

1033

      if (NULL == pNode->datum.p) {

56,625,475✔

1037

      code = tlvDecodeBinary(pTlv, pNode->datum.p);

56,615,524✔

1038

      if (TSDB_CODE_SUCCESS == code) {

56,623,049✔

1039

        varDataSetLen(pNode->datum.p, pTlv->len - VARSTR_HEADER_SIZE);

56,623,575✔

1041

      break;

56,615,423✔

1043

    case TSDB_DATA_TYPE_JSON: {

1,449✔

1044

      if (pTlv->len <= 0 || pTlv->len > TSDB_MAX_JSON_TAG_LEN) {

1,449✔

1048

      code = tlvDecodeDynBinary(pTlv, (void**)&pNode->datum.p);

1,449✔

1049

      break;

1,449✔

1051

    case TSDB_DATA_TYPE_DECIMAL:

2,259✔

1052

      pNode->datum.p = taosMemoryCalloc(1, pNode->node.resType.bytes);

2,259✔

1053

      if (!pNode->datum.p) {

2,259✔

1057

      code = tlvDecodeBinary(pTlv, pNode->datum.p);

2,259✔

1058

      break;

2,259✔

1083

  return code;

387,693,667✔

1086

static int32_t msgToValueNode(STlvDecoder* pDecoder, void* pObj) {

417,494,645✔

1087

  SValueNode* pNode = (SValueNode*)pObj;

417,494,645✔

1089

  int32_t code = TSDB_CODE_SUCCESS;

417,494,645✔

1090

  STlv*   pTlv = NULL;

417,494,645✔

1091

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

1092

    switch (pTlv->type) {

2,147,483,647✔

1093

      case VALUE_CODE_EXPR_BASE:

417,478,075✔

1094

        code = tlvDecodeObjFromTlv(pTlv, msgToExprNode, &pNode->node);

417,478,075✔

1095

        break;

417,507,345✔

1096

      case VALUE_CODE_LITERAL:

243,631,457✔

1097

        code = tlvDecodeCStrP(pTlv, &pNode->literal);

243,631,457✔

1098

        break;

243,578,558✔

1099

      case VALUE_CODE_FLAG:

417,503,312✔

1100

        code = tlvDecodeI32(pTlv, &pNode->flag);

417,503,312✔

1101

        break;

417,481,454✔

1102

      case VALUE_CODE_TRANSLATE:

417,509,028✔

1103

        code = tlvDecodeBool(pTlv, &pNode->translate);

417,509,028✔

1104

        break;

417,505,448✔

1105

      case VALUE_CODE_NOT_RESERVED:

417,513,398✔

1106

        code = tlvDecodeBool(pTlv, &pNode->notReserved);

417,513,398✔

1107

        break;

417,512,700✔

1108

      case VALUE_CODE_IS_NULL:

417,486,022✔

1109

        code = tlvDecodeBool(pTlv, &pNode->isNull);

417,486,022✔

1110

        break;

417,509,139✔

1111

      case VALUE_CODE_DATUM:

387,731,928✔

1112

        code = msgToDatum(pTlv, pNode);

387,731,928✔

1113

        break;

387,691,020✔

1119

  return code;

417,622,547✔

1128

static int32_t remoteValueNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

61,493,659✔

1129

  const SRemoteValueNode* pNode = (const SRemoteValueNode*)pObj;

61,493,659✔

1131

  int32_t code = tlvEncodeObj(pEncoder, REMOTE_VALUE_CODE_VAL, valueNodeToMsg, pNode);

61,493,659✔

1137

  if (TSDB_CODE_SUCCESS == code) {

61,522,667✔

1138

    code = tlvEncodeI32(pEncoder, REMOTE_VALUE_CODE_SUBQ_IDX, pNode->subQIdx);

61,524,517✔

1141

  return code;

61,526,119✔

1145

static int32_t msgToRemoteValueNode(STlvDecoder* pDecoder, void* pObj) {

5,247,805✔

1146

  SRemoteValueNode* pNode = (SRemoteValueNode*)pObj;

5,247,805✔

1148

  int32_t code = TSDB_CODE_SUCCESS;

5,247,805✔

1149

  STlv*   pTlv = NULL;

5,247,805✔

1150

  tlvForEach(pDecoder, pTlv, code) {

15,744,523✔

1151

    switch (pTlv->type) {

10,496,718✔

1152

      case REMOTE_VALUE_CODE_VAL:

5,247,805✔

1153

        code = tlvDecodeObjFromTlv(pTlv, msgToValueNode, &pNode->val);

5,247,805✔

1154

        break;

5,248,359✔

1160

      case REMOTE_VALUE_CODE_SUBQ_IDX:

5,248,370✔

1161

        code = tlvDecodeI32(pTlv, &pNode->subQIdx);

5,248,370✔

1162

        break;

5,248,359✔

1168

  return code;

5,247,805✔

1177

static int32_t remoteValueListNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

18,288,976✔

1178

  const SRemoteValueListNode* pNode = (const SRemoteValueListNode*)pObj;

18,288,976✔

1180

  int32_t code = tlvEncodeObj(pEncoder, REMOTE_VALUELIST_CODE_EXPR, exprNodeToMsg, pNode);

18,288,976✔

1181

  if (TSDB_CODE_SUCCESS == code) {

18,297,001✔

1182

    code = tlvEncodeI32(pEncoder, REMOTE_VALUELIST_CODE_FLAG, pNode->flag);

18,297,001✔

1184

  if (TSDB_CODE_SUCCESS == code) {

18,295,486✔

1185

    code = tlvEncodeI32(pEncoder, REMOTE_VALUELIST_CODE_SUBQ_IDX, pNode->subQIdx);

18,292,752✔

1188

  return code;

18,296,568✔

1192

static int32_t msgToRemoteValueListNode(STlvDecoder* pDecoder, void* pObj) {

11,964,692✔

1193

  SRemoteValueListNode* pNode = (SRemoteValueListNode*)pObj;

11,964,692✔

1195

  int32_t code = TSDB_CODE_SUCCESS;

11,964,692✔

1196

  STlv*   pTlv = NULL;

11,964,692✔

1197

  tlvForEach(pDecoder, pTlv, code) {

47,858,768✔

1198

    switch (pTlv->type) {

35,894,076✔

1199

      case REMOTE_VALUELIST_CODE_EXPR:

11,964,692✔

1200

        code = tlvDecodeObjFromTlv(pTlv, msgToExprNode, &pNode->node);

11,964,692✔

1201

        break;

11,964,692✔

1202

      case REMOTE_VALUELIST_CODE_FLAG:

11,964,692✔

1203

        code = tlvDecodeI32(pTlv, &pNode->flag);

11,964,692✔

1204

        break;

11,964,692✔

1205

      case REMOTE_VALUELIST_CODE_SUBQ_IDX:

11,964,692✔

1206

        code = tlvDecodeI32(pTlv, &pNode->subQIdx);

11,964,692✔

1207

        break;

11,964,692✔

1213

  return code;

11,964,692✔

1225

static int32_t remoteRowNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

23,249,661✔

1226

  const SRemoteRowNode* pNode = (const SRemoteRowNode*)pObj;

23,249,661✔

1228

  int32_t code = tlvEncodeObj(pEncoder, REMOTE_ROW_CODE_VAL, valueNodeToMsg, pNode);

23,249,661✔

1229

  if (TSDB_CODE_SUCCESS == code) {

23,251,137✔

1230

    code = tlvEncodeBool(pEncoder, REMOTE_ROW_CODE_IS_MIN, pNode->isMinVal);

23,251,137✔

1232

  if (TSDB_CODE_SUCCESS == code) {

23,250,965✔

1233

    code = tlvEncodeBool(pEncoder, REMOTE_ROW_CODE_VAL_SET, pNode->valSet);

23,250,451✔

1235

  if (TSDB_CODE_SUCCESS == code) {

23,251,397✔

1236

    code = tlvEncodeBool(pEncoder, REMOTE_ROW_CODE_HAS_VALUE, pNode->hasValue);

23,250,881✔

1238

  if (TSDB_CODE_SUCCESS == code) {

23,250,969✔

1239

    code = tlvEncodeBool(pEncoder, REMOTE_ROW_CODE_HAS_NULL, pNode->hasNull);

23,250,453✔

1241

  if (TSDB_CODE_SUCCESS == code) {

23,251,821✔

1242

    code = tlvEncodeI32(pEncoder, REMOTE_ROW_CODE_SUBQ_IDX, pNode->subQIdx);

23,251,305✔

1245

  return code;

23,251,049✔

1249

static int32_t msgToRemoteRowNode(STlvDecoder* pDecoder, void* pObj) {

21,728,295✔

1250

  SRemoteRowNode* pNode = (SRemoteRowNode*)pObj;

21,728,295✔

1252

  int32_t code = TSDB_CODE_SUCCESS;

21,728,295✔

1253

  STlv*   pTlv = NULL;

21,728,295✔

1254

  tlvForEach(pDecoder, pTlv, code) {

152,097,522✔

1255

    switch (pTlv->type) {

130,369,227✔

1256

      case REMOTE_ROW_CODE_VAL:

21,727,752✔

1257

        code = tlvDecodeObjFromTlv(pTlv, msgToValueNode, &pNode->val);

21,727,752✔

1258

        break;

21,728,295✔

1259

      case REMOTE_ROW_CODE_IS_MIN:

21,728,295✔

1260

        code = tlvDecodeBool(pTlv, &pNode->isMinVal);

21,728,295✔

1261

        break;

21,728,295✔

1262

      case REMOTE_ROW_CODE_VAL_SET:

21,728,295✔

1263

        code = tlvDecodeBool(pTlv, &pNode->valSet);

21,728,295✔

1264

        break;

21,727,752✔

1265

      case REMOTE_ROW_CODE_HAS_VALUE:

21,728,295✔

1266

        code = tlvDecodeBool(pTlv, &pNode->hasValue);

21,728,295✔

1267

        break;

21,728,295✔

1268

      case REMOTE_ROW_CODE_HAS_NULL:

21,728,295✔

1269

        code = tlvDecodeBool(pTlv, &pNode->hasNull);

21,728,295✔

1270

        break;

21,728,295✔

1271

      case REMOTE_ROW_CODE_SUBQ_IDX:

21,727,752✔

1272

        code = tlvDecodeI32(pTlv, &pNode->subQIdx);

21,727,752✔

1273

        break;

21,728,295✔

1279

  return code;

21,728,295✔

1282

static int32_t remoteZeroRowsNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

1,309,578✔

1283

  return remoteValueNodeToMsg(pObj, pEncoder);

1,309,578✔

1287

static int32_t msgToRemoteZeroRowsNode(STlvDecoder* pDecoder, void* pObj) {

380,395✔

1288

  return msgToRemoteValueNode(pDecoder, pObj);

380,395✔

1294

static int32_t operatorNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

321,181,203✔

1295

  const SOperatorNode* pNode = (const SOperatorNode*)pObj;

321,181,203✔

1297

  int32_t code = tlvEncodeObj(pEncoder, OPERATOR_CODE_EXPR_BASE, exprNodeToMsg, pNode);

321,181,203✔

1298

  if (TSDB_CODE_SUCCESS == code) {

321,368,615✔

1299

    code = tlvEncodeEnum(pEncoder, OPERATOR_CODE_OP_TYPE, pNode->opType);

321,367,549✔

1301

  if (TSDB_CODE_SUCCESS == code) {

321,352,501✔

1302

    code = tlvEncodeI32(pEncoder, OPERATOR_CODE_FLAG, pNode->flag);

321,352,617✔

1304

  if (TSDB_CODE_SUCCESS == code) {

321,364,382✔

1305

    code = tlvEncodeObj(pEncoder, OPERATOR_CODE_LEFT, nodeToMsg, pNode->pLeft);

321,364,728✔

1307

  if (TSDB_CODE_SUCCESS == code) {

321,305,825✔

1308

    code = tlvEncodeObj(pEncoder, OPERATOR_CODE_RIGHT, nodeToMsg, pNode->pRight);

321,300,149✔

1311

  return code;

321,290,752✔

1314

static int32_t msgToOperatorNode(STlvDecoder* pDecoder, void* pObj) {

262,040,921✔

1315

  SOperatorNode* pNode = (SOperatorNode*)pObj;

262,040,921✔

1317

  int32_t code = TSDB_CODE_SUCCESS;

262,040,921✔

1318

  STlv*   pTlv = NULL;

262,040,921✔

1319

  tlvForEach(pDecoder, pTlv, code) {

1,535,928,026✔

1320

    switch (pTlv->type) {

1,273,916,068✔

1321

      case OPERATOR_CODE_EXPR_BASE:

262,039,364✔

1322

        code = tlvDecodeObjFromTlv(pTlv, msgToExprNode, &pNode->node);

262,039,364✔

1323

        break;

262,039,402✔

1324

      case OPERATOR_CODE_OP_TYPE:

262,050,497✔

1325

        code = tlvDecodeEnum(pTlv, &pNode->opType, sizeof(pNode->opType));

262,050,497✔

1326

        break;

262,046,451✔

1327

      case OPERATOR_CODE_FLAG:

262,041,566✔

1328

        code = tlvDecodeI32(pTlv, &pNode->flag);

262,041,566✔

1329

        break;

262,040,275✔

1330

      case OPERATOR_CODE_LEFT:

262,048,367✔

1331

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pLeft);

262,048,367✔

1332

        break;

262,041,959✔

1333

      case OPERATOR_CODE_RIGHT:

225,737,535✔

1334

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pRight);

225,737,535✔

1335

        break;

225,715,099✔

1341

  return code;

262,114,753✔

1346

static int32_t logicConditionNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

48,466,790✔

1347

  const SLogicConditionNode* pNode = (const SLogicConditionNode*)pObj;

48,466,790✔

1349

  int32_t code = tlvEncodeObj(pEncoder, LOGIC_COND_CODE_EXPR_BASE, exprNodeToMsg, pNode);

48,466,790✔

1350

  if (TSDB_CODE_SUCCESS == code) {

48,497,865✔

1351

    code = tlvEncodeEnum(pEncoder, LOGIC_COND_CODE_COND_TYPE, pNode->condType);

48,497,865✔

1353

  if (TSDB_CODE_SUCCESS == code) {

48,488,933✔

1354

    code = tlvEncodeObj(pEncoder, LOGIC_COND_CODE_PARAMETERS, nodeListToMsg, pNode->pParameterList);

48,488,933✔

1357

  return code;

48,495,757✔

1360

static int32_t msgToLogicConditionNode(STlvDecoder* pDecoder, void* pObj) {

44,500,285✔

1361

  SLogicConditionNode* pNode = (SLogicConditionNode*)pObj;

44,500,285✔

1363

  int32_t code = TSDB_CODE_SUCCESS;

44,500,285✔

1364

  STlv*   pTlv = NULL;

44,500,285✔

1365

  tlvForEach(pDecoder, pTlv, code) {

178,011,538✔

1366

    switch (pTlv->type) {

133,511,099✔

1367

      case LOGIC_COND_CODE_EXPR_BASE:

44,502,368✔

1368

        code = tlvDecodeObjFromTlv(pTlv, msgToExprNode, &pNode->node);

44,502,368✔

1369

        break;

44,504,591✔

1370

      case LOGIC_COND_CODE_COND_TYPE:

44,504,591✔

1371

        code = tlvDecodeEnum(pTlv, &pNode->condType, sizeof(pNode->condType));

44,504,591✔

1372

        break;

44,501,712✔

1373

      case LOGIC_COND_CODE_PARAMETERS:

44,504,666✔

1374

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pParameterList);

44,504,666✔

1375

        break;

44,503,138✔

1381

  return code;

44,509,905✔

1399

static int32_t functionNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

698,047,366✔

1400

  const SFunctionNode* pNode = (const SFunctionNode*)pObj;

698,047,366✔

1402

  int32_t code = tlvEncodeObj(pEncoder, FUNCTION_CODE_EXPR_BASE, exprNodeToMsg, pNode);

698,047,366✔

1403

  if (TSDB_CODE_SUCCESS == code) {

698,526,763✔

1404

    code = tlvEncodeCStr(pEncoder, FUNCTION_CODE_FUNCTION_NAME, pNode->functionName);

698,538,124✔

1406

  if (TSDB_CODE_SUCCESS == code) {

698,580,963✔

1407

    code = tlvEncodeI32(pEncoder, FUNCTION_CODE_FUNCTION_ID, pNode->funcId);

698,568,716✔

1409

  if (TSDB_CODE_SUCCESS == code) {

698,587,551✔

1410

    code = tlvEncodeI32(pEncoder, FUNCTION_CODE_FUNCTION_TYPE, pNode->funcType);

698,576,210✔

1412

  if (TSDB_CODE_SUCCESS == code) {

698,609,297✔

1413

    code = tlvEncodeObj(pEncoder, FUNCTION_CODE_PARAMETERS, nodeListToMsg, pNode->pParameterList);

698,598,277✔

1415

  if (TSDB_CODE_SUCCESS == code) {

698,268,493✔

1416

    code = tlvEncodeI32(pEncoder, FUNCTION_CODE_UDF_BUF_SIZE, pNode->udfBufSize);

698,257,607✔

1418

  if (TSDB_CODE_SUCCESS == code) {

698,567,967✔

1419

    code = tlvEncodeBool(pEncoder, FUNCTION_NODE_HAS_PK, pNode->hasPk);

698,546,405✔

1421

  if (TSDB_CODE_SUCCESS == code) {

698,604,820✔

1422

    code = tlvEncodeI32(pEncoder, FUNCTION_NODE_PK_BYTES, pNode->pkBytes);

698,584,293✔

1424

  if (TSDB_CODE_SUCCESS == code) {

698,601,354✔

1425

    code = tlvEncodeBool(pEncoder, FUNCTION_CODE_IS_MERGE_FUNC, pNode->hasOriginalFunc);

698,581,288✔

1427

  if (TSDB_CODE_SUCCESS == code) {

698,616,253✔

1428

    code = tlvEncodeI32(pEncoder, FUNCTION_CODE_MERGE_FUNC_OF, pNode->originalFuncId);

698,596,594✔

1430

  if (TSDB_CODE_SUCCESS == code) {

698,616,626✔

1431

    code = tlvEncodeEnum(pEncoder, FUNCTION_CODE_TRIM_TYPE, pNode->trimType);

698,590,387✔

1433

  if (TSDB_CODE_SUCCESS == code) {

698,628,765✔

1434

    code = tlvEncodeObj(pEncoder, FUNCTION_SRC_FUNC_INPUT_TYPE, dataTypeInlineToMsg, &pNode->srcFuncInputType);

698,602,536✔

1437

  return code;

698,322,636✔

1440

static int32_t msgToFunctionNode(STlvDecoder* pDecoder, void* pObj) {

575,647,147✔

1441

  SFunctionNode* pNode = (SFunctionNode*)pObj;

575,647,147✔

1443

  int32_t code = TSDB_CODE_SUCCESS;

575,647,147✔

1444

  STlv*   pTlv = NULL;

575,647,147✔

1445

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

1446

    switch (pTlv->type) {

2,147,483,647✔

1447

      case FUNCTION_CODE_EXPR_BASE:

575,663,175✔

1448

        code = tlvDecodeObjFromTlv(pTlv, msgToExprNode, &pNode->node);

575,663,175✔

1449

        break;

575,642,044✔

1450

      case FUNCTION_CODE_FUNCTION_NAME:

575,666,093✔

1451

        code = tlvDecodeCStr(pTlv, pNode->functionName, sizeof(pNode->functionName));

575,666,093✔

1452

        break;

575,635,179✔

1453

      case FUNCTION_CODE_FUNCTION_ID:

575,655,140✔

1454

        code = tlvDecodeI32(pTlv, &pNode->funcId);

575,655,140✔

1455

        break;

575,658,271✔

1456

      case FUNCTION_CODE_FUNCTION_TYPE:

575,676,598✔

1457

        code = tlvDecodeI32(pTlv, &pNode->funcType);

575,676,598✔

1458

        break;

575,674,314✔

1459

      case FUNCTION_CODE_PARAMETERS:

477,447,827✔

1460

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pParameterList);

477,447,827✔

1461

        break;

477,435,655✔

1462

      case FUNCTION_CODE_UDF_BUF_SIZE:

575,664,946✔

1463

        code = tlvDecodeI32(pTlv, &pNode->udfBufSize);

575,664,946✔

1464

        break;

575,668,673✔

1465

      case FUNCTION_NODE_HAS_PK:

575,679,566✔

1466

        code = tlvDecodeBool(pTlv, &pNode->hasPk);

575,679,566✔

1467

        break;

575,669,931✔

1468

      case FUNCTION_NODE_PK_BYTES:

575,681,457✔

1469

        code = tlvDecodeI32(pTlv, &pNode->pkBytes);

575,681,457✔

1470

        break;

575,672,545✔

1471

      case FUNCTION_CODE_IS_MERGE_FUNC:

575,678,369✔

1472

        code = tlvDecodeBool(pTlv, &pNode->hasOriginalFunc);

575,678,369✔

1473

        break;

575,655,142✔

1474

      case FUNCTION_CODE_MERGE_FUNC_OF:

575,684,323✔

1475

        code = tlvDecodeI32(pTlv, &pNode->originalFuncId);

575,684,323✔

1476

        break;

575,672,763✔

1477

      case FUNCTION_CODE_TRIM_TYPE:

575,672,426✔

1478

        code = tlvDecodeEnum(pTlv, &pNode->trimType, sizeof(pNode->trimType));

575,672,426✔

1479

        break;

575,661,359✔

1480

      case FUNCTION_SRC_FUNC_INPUT_TYPE:

575,680,419✔

1481

        code = tlvDecodeObjFromTlv(pTlv, msgToDataTypeInline, &pNode->srcFuncInputType);

575,680,419✔

1482

      default:

575,661,468✔

1483

        break;

575,661,468✔

1487

  return code;

578,536,679✔

1492

static int32_t orderByExprNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

92,544,039✔

1493

  const SOrderByExprNode* pNode = (const SOrderByExprNode*)pObj;

92,544,039✔

1495

  int32_t code = tlvEncodeObj(pEncoder, ORDER_BY_EXPR_CODE_EXPR, nodeToMsg, pNode->pExpr);

92,544,039✔

1496

  if (TSDB_CODE_SUCCESS == code) {

92,570,065✔

1497

    code = tlvEncodeEnum(pEncoder, ORDER_BY_EXPR_CODE_ORDER, pNode->order);

92,570,182✔

1499

  if (TSDB_CODE_SUCCESS == code) {

92,570,459✔

1500

    code = tlvEncodeEnum(pEncoder, ORDER_BY_EXPR_CODE_NULL_ORDER, pNode->nullOrder);

92,569,552✔

1503

  return code;

92,570,466✔

1506

static int32_t msgToOrderByExprNode(STlvDecoder* pDecoder, void* pObj) {

60,725,055✔

1507

  SOrderByExprNode* pNode = (SOrderByExprNode*)pObj;

60,725,055✔

1509

  int32_t code = TSDB_CODE_SUCCESS;

60,725,055✔

1510

  STlv*   pTlv = NULL;

60,725,055✔

1511

  tlvForEach(pDecoder, pTlv, code) {

242,910,003✔

1512

    switch (pTlv->type) {

182,183,526✔

1513

      case ORDER_BY_EXPR_CODE_EXPR:

60,727,169✔

1514

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pExpr);

60,727,169✔

1515

        break;

60,727,656✔

1516

      case ORDER_BY_EXPR_CODE_ORDER:

60,728,194✔

1517

        code = tlvDecodeEnum(pTlv, &pNode->order, sizeof(pNode->order));

60,728,194✔

1518

        break;

60,728,194✔

1519

      case ORDER_BY_EXPR_CODE_NULL_ORDER:

60,728,163✔

1520

        code = tlvDecodeEnum(pTlv, &pNode->nullOrder, sizeof(pNode->nullOrder));

60,728,163✔

1521

        break;

60,728,194✔

1527

  return code;

60,725,276✔

1532

static int32_t limitNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

41,243,110✔

1533

  const SLimitNode* pNode = (const SLimitNode*)pObj;

41,243,110✔

1535

  int32_t code = tlvEncodeObj(pEncoder, LIMIT_CODE_LIMIT, nodeToMsg, pNode->limit);

41,243,110✔

1536

  if (TSDB_CODE_SUCCESS == code && pNode->offset) {

41,262,915✔

1537

    code = tlvEncodeObj(pEncoder, LIMIT_CODE_OFFSET, nodeToMsg, pNode->offset);

11,159,963✔

1540

  return code;

41,256,255✔

1543

static int32_t msgToLimitNode(STlvDecoder* pDecoder, void* pObj) {

34,881,436✔

1544

  SLimitNode* pNode = (SLimitNode*)pObj;

34,881,436✔

1546

  int32_t code = TSDB_CODE_SUCCESS;

34,881,436✔

1547

  STlv*   pTlv = NULL;

34,881,436✔

1548

  tlvForEach(pDecoder, pTlv, code) {

80,804,015✔

1549

    switch (pTlv->type) {

45,921,059✔

1550

      case LIMIT_CODE_LIMIT:

34,885,021✔

1551

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->limit);

34,885,021✔

1552

        break;

34,884,286✔

1553

      case LIMIT_CODE_OFFSET:

11,036,038✔

1554

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->offset);

11,036,038✔

1555

        break;

11,034,965✔

1561

  return code;

34,882,303✔

1566

static int32_t nameToMsg(const void* pObj, STlvEncoder* pEncoder) {

427,502,331✔

1567

  const SName* pNode = (const SName*)pObj;

427,502,331✔

1569

  int32_t code = tlvEncodeU8(pEncoder, NAME_CODE_TYPE, pNode->type);

427,502,331✔

1570

  if (TSDB_CODE_SUCCESS == code) {

427,934,491✔

1571

    code = tlvEncodeI32(pEncoder, NAME_CODE_ACCT_ID, pNode->acctId);

427,937,368✔

1573

  if (TSDB_CODE_SUCCESS == code) {

427,956,820✔

1574

    code = tlvEncodeCStr(pEncoder, NAME_CODE_DB_NAME, pNode->dbname);

427,877,511✔

1576

  if (TSDB_CODE_SUCCESS == code) {

427,749,045✔

1577

    code = tlvEncodeCStr(pEncoder, NAME_CODE_TABLE_NAME, pNode->tname);

427,676,754✔

1580

  return code;

427,978,258✔

1583

static int32_t msgToName(STlvDecoder* pDecoder, void* pObj) {

300,492,577✔

1584

  SName* pNode = (SName*)pObj;

300,492,577✔

1586

  int32_t code = TSDB_CODE_SUCCESS;

300,492,577✔

1587

  STlv*   pTlv = NULL;

300,492,577✔

1588

  tlvForEach(pDecoder, pTlv, code) {

1,502,571,888✔

1589

    switch (pTlv->type) {

1,202,080,972✔

1590

      case NAME_CODE_TYPE:

300,512,715✔

1591

        code = tlvDecodeU8(pTlv, &pNode->type);

300,512,715✔

1592

        break;

300,515,945✔

1593

      case NAME_CODE_ACCT_ID:

300,525,005✔

1594

        code = tlvDecodeI32(pTlv, &pNode->acctId);

300,525,005✔

1595

        break;

300,523,643✔

1596

      case NAME_CODE_DB_NAME:

300,527,488✔

1597

        code = tlvDecodeCStr(pTlv, pNode->dbname, sizeof(pNode->dbname));

300,527,488✔

1598

        break;

300,503,546✔

1599

      case NAME_CODE_TABLE_NAME:

300,519,530✔

1600

        code = tlvDecodeCStr(pTlv, pNode->tname, sizeof(pNode->tname));

300,519,530✔

1601

        break;

300,522,883✔

1607

  return code;

300,541,816✔

1612

static int32_t timeWindowToMsg(const void* pObj, STlvEncoder* pEncoder) {

23,012,639✔

1613

  const STimeWindow* pNode = (const STimeWindow*)pObj;

23,012,639✔

1615

  int32_t code = tlvEncodeI64(pEncoder, TIME_WINDOW_CODE_START_KEY, pNode->skey);

23,012,639✔

1616

  if (TSDB_CODE_SUCCESS == code) {

23,022,068✔

1617

    code = tlvEncodeI64(pEncoder, TIME_WINDOW_CODE_END_KEY, pNode->ekey);

23,022,432✔

1620

  return code;

23,025,279✔

1623

static int32_t msgToTimeWindow(STlvDecoder* pDecoder, void* pObj) {

15,111,504✔

1624

  STimeWindow* pNode = (STimeWindow*)pObj;

15,111,504✔

1626

  int32_t code = TSDB_CODE_SUCCESS;

15,111,504✔

1627

  STlv*   pTlv = NULL;

15,111,504✔

1628

  tlvForEach(pDecoder, pTlv, code) {

45,335,142✔

1629

    switch (pTlv->type) {

30,223,391✔

1630

      case TIME_WINDOW_CODE_START_KEY:

15,111,076✔

1631

        code = tlvDecodeI64(pTlv, &pNode->skey);

15,111,076✔

1632

        break;

15,111,605✔

1633

      case TIME_WINDOW_CODE_END_KEY:

15,112,315✔

1634

        code = tlvDecodeI64(pTlv, &pNode->ekey);

15,112,315✔

1635

        break;

15,112,033✔

1641

  return code;

15,111,454✔

1646

static int32_t nodeListNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

11,086,955✔

1647

  const SNodeListNode* pNode = (const SNodeListNode*)pObj;

11,086,955✔

1649

  int32_t code = tlvEncodeObj(pEncoder, NODE_LIST_CODE_EXPR_BASE, exprNodeToMsg, pNode);

11,086,955✔

1650

  if (TSDB_CODE_SUCCESS == code) {

11,104,363✔

1651

    code = tlvEncodeObj(pEncoder, NODE_LIST_CODE_NODE_LIST, nodeListToMsg, pNode->pNodeList);

11,104,363✔

1654

  return code;

11,101,117✔

1657

static int32_t msgToNodeListNode(STlvDecoder* pDecoder, void* pObj) {

7,570,224✔

1658

  SNodeListNode* pNode = (SNodeListNode*)pObj;

7,570,224✔

1660

  int32_t code = TSDB_CODE_SUCCESS;

7,570,224✔

1661

  STlv*   pTlv = NULL;

7,570,224✔

1662

  tlvForEach(pDecoder, pTlv, code) {

22,711,732✔

1663

    switch (pTlv->type) {

15,141,508✔

1664

      case NODE_LIST_CODE_EXPR_BASE:

7,570,754✔

1665

        code = tlvDecodeObjFromTlv(pTlv, msgToExprNode, &pNode->node);

7,570,754✔

1666

        break;

7,570,754✔

1667

      case NODE_LIST_CODE_NODE_LIST:

7,570,754✔

1668

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pNodeList);

7,570,754✔

1669

        break;

7,570,754✔

1675

  return code;

7,571,284✔

1680

static int32_t targetNodeInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,147,483,647✔

1681

  const STargetNode* pNode = (const STargetNode*)pObj;

2,147,483,647✔

1683

  int32_t code = tlvEncodeValueI64(pEncoder, pNode->dataBlockId);

2,147,483,647✔

1684

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1685

    code = tlvEncodeValueI16(pEncoder, pNode->slotId);

2,147,483,647✔

1688

  return code;

2,147,483,647✔

1691

static int32_t targetNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,147,483,647✔

1692

  const STargetNode* pNode = (const STargetNode*)pObj;

2,147,483,647✔

1694

  int32_t code = tlvEncodeObj(pEncoder, TARGET_CODE_INLINE_ATTRS, targetNodeInlineToMsg, pNode);

2,147,483,647✔

1695

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1696

    code = tlvEncodeObj(pEncoder, TARGET_CODE_EXPR, nodeToMsg, pNode->pExpr);

2,147,483,647✔

1699

  return code;

2,147,483,647✔

1702

static int32_t msgToTargetNodeInline(STlvDecoder* pDecoder, void* pObj) {

2,147,483,647✔

1703

  STargetNode* pNode = (STargetNode*)pObj;

2,147,483,647✔

1705

  int32_t code = tlvDecodeValueI64(pDecoder, &pNode->dataBlockId);

2,147,483,647✔

1706

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1707

    code = tlvDecodeValueI16(pDecoder, &pNode->slotId);

2,147,483,647✔

1710

  return code;

2,147,483,647✔

1713

static int32_t msgToTargetNode(STlvDecoder* pDecoder, void* pObj) {

2,147,483,647✔

1714

  STargetNode* pNode = (STargetNode*)pObj;

2,147,483,647✔

1716

  int32_t code = TSDB_CODE_SUCCESS;

2,147,483,647✔

1717

  STlv*   pTlv = NULL;

2,147,483,647✔

1718

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

1719

    switch (pTlv->type) {

2,147,483,647✔

1720

      case TARGET_CODE_INLINE_ATTRS:

2,147,483,647✔

1721

        code = tlvDecodeObjFromTlv(pTlv, msgToTargetNodeInline, pNode);

2,147,483,647✔

1722

        break;

2,147,483,647✔

1723

      case TARGET_CODE_EXPR:

2,147,483,647✔

1724

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pExpr);

2,147,483,647✔

1725

        break;

2,147,483,647✔

1731

  return code;

2,147,483,647✔

1778

static int32_t dataBlockDescNodeInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {

1,588,555,944✔

1779

  const SDataBlockDescNode* pNode = (const SDataBlockDescNode*)pObj;

1,588,555,944✔

1781

  int32_t code = tlvEncodeValueI64(pEncoder, pNode->dataBlockId);

1,588,555,944✔

1782

  if (TSDB_CODE_SUCCESS == code) {

1,587,249,199✔

1783

    code = tlvEncodeValueI32(pEncoder, pNode->totalRowSize);

1,587,268,518✔

1785

  if (TSDB_CODE_SUCCESS == code) {

1,589,166,775✔

1786

    code = tlvEncodeValueI32(pEncoder, pNode->outputRowSize);

1,589,178,334✔

1788

  if (TSDB_CODE_SUCCESS == code) {

1,589,284,808✔

1789

    code = tlvEncodeValueU8(pEncoder, pNode->precision);

1,589,301,339✔

1792

  return code;

1,589,391,159✔

1795

static int32_t dataBlockDescNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

1,588,284,197✔

1796

  const SDataBlockDescNode* pNode = (const SDataBlockDescNode*)pObj;

1,588,284,197✔

1798

  int32_t code = tlvEncodeObj(pEncoder, DATA_BLOCK_DESC_CODE_INLINE_ATTRS, dataBlockDescNodeInlineToMsg, pNode);

1,588,284,197✔

1799

  if (TSDB_CODE_SUCCESS == code) {

1,589,397,774✔

1800

    code = tlvEncodeObj(pEncoder, DATA_BLOCK_DESC_CODE_SLOTS, nodeListToMsg, pNode->pSlots);

1,589,405,439✔

1803

  return code;

1,589,524,140✔

1806

static int32_t msgToDataBlockDescNodeInline(STlvDecoder* pDecoder, void* pObj) {

1,127,435,061✔

1807

  SDataBlockDescNode* pNode = (SDataBlockDescNode*)pObj;

1,127,435,061✔

1809

  int32_t code = tlvDecodeValueI64(pDecoder, &pNode->dataBlockId);

1,127,435,061✔

1810

  if (TSDB_CODE_SUCCESS == code) {

1,127,326,070✔

1811

    code = tlvDecodeValueI32(pDecoder, &pNode->totalRowSize);

1,127,328,361✔

1813

  if (TSDB_CODE_SUCCESS == code) {

1,127,413,590✔

1814

    code = tlvDecodeValueI32(pDecoder, &pNode->outputRowSize);

1,127,413,590✔

1816

  if (TSDB_CODE_SUCCESS == code) {

1,127,437,955✔

1817

    code = tlvDecodeValueU8(pDecoder, &pNode->precision);

1,127,437,955✔

1820

  return code;

1,127,410,722✔

1823

static int32_t msgToDataBlockDescNode(STlvDecoder* pDecoder, void* pObj) {

1,127,424,010✔

1824

  SDataBlockDescNode* pNode = (SDataBlockDescNode*)pObj;

1,127,424,010✔

1826

  int32_t code = TSDB_CODE_SUCCESS;

1,127,424,010✔

1827

  STlv*   pTlv = NULL;

1,127,424,010✔

1828

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

1829

    switch (pTlv->type) {

2,147,483,647✔

1830

      case DATA_BLOCK_DESC_CODE_INLINE_ATTRS:

1,127,468,273✔

1831

        code = tlvDecodeObjFromTlv(pTlv, msgToDataBlockDescNodeInline, pNode);

1,127,468,273✔

1832

        break;

1,127,411,618✔

1833

      case DATA_BLOCK_DESC_CODE_SLOTS:

1,127,465,026✔

1834

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pSlots);

1,127,465,026✔

1835

        break;

1,127,430,420✔

1841

  return code;

1,127,527,096✔

1846

static int32_t slotDescNodeInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,147,483,647✔

1847

  const SSlotDescNode* pNode = (const SSlotDescNode*)pObj;

2,147,483,647✔

1849

  int32_t code = tlvEncodeValueI16(pEncoder, pNode->slotId);

2,147,483,647✔

1850

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1851

    code = dataTypeInlineToMsg(&pNode->dataType, pEncoder);

2,147,483,647✔

1853

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1854

    code = tlvEncodeValueBool(pEncoder, pNode->reserve);

2,147,483,647✔

1856

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1857

    code = tlvEncodeValueBool(pEncoder, pNode->output);

2,147,483,647✔

1859

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1860

    code = tlvEncodeValueBool(pEncoder, pNode->tag);

2,147,483,647✔

1863

  return code;

2,147,483,647✔

1866

static int32_t slotDescNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,147,483,647✔

1867

  return tlvEncodeObj(pEncoder, SLOT_DESC_CODE_INLINE_ATTRS, slotDescNodeInlineToMsg, pObj);

2,147,483,647✔

1870

static int32_t msgToSlotDescNodeInline(STlvDecoder* pDecoder, void* pObj) {

2,147,483,647✔

1871

  SSlotDescNode* pNode = (SSlotDescNode*)pObj;

2,147,483,647✔

1873

  int32_t code = tlvDecodeValueI16(pDecoder, &pNode->slotId);

2,147,483,647✔

1874

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1875

    code = msgToDataTypeInline(pDecoder, &pNode->dataType);

2,147,483,647✔

1877

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1878

    code = tlvDecodeValueBool(pDecoder, &pNode->reserve);

2,147,483,647✔

1880

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1881

    code = tlvDecodeValueBool(pDecoder, &pNode->output);

2,147,483,647✔

1883

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1884

    code = tlvDecodeValueBool(pDecoder, &pNode->tag);

2,147,483,647✔

1887

  return code;

2,147,483,647✔

1890

static int32_t msgToSlotDescNode(STlvDecoder* pDecoder, void* pObj) {

2,147,483,647✔

1891

  SSlotDescNode* pNode = (SSlotDescNode*)pObj;

2,147,483,647✔

1893

  int32_t code = TSDB_CODE_SUCCESS;

2,147,483,647✔

1894

  STlv*   pTlv = NULL;

2,147,483,647✔

1895

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

1896

    switch (pTlv->type) {

2,147,483,647✔

1897

      case SLOT_DESC_CODE_INLINE_ATTRS:

2,147,483,647✔

1898

        code = tlvDecodeObjFromTlv(pTlv, msgToSlotDescNodeInline, pNode);

2,147,483,647✔

1899

        break;

2,147,483,647✔

1905

  return code;

2,147,483,647✔

1910

static int32_t epInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {

680,174,488✔

1911

  const SEp* pNode = (const SEp*)pObj;

680,174,488✔

1913

  int32_t code = tlvEncodeValueCStr(pEncoder, pNode->fqdn);

680,174,488✔

1914

  if (TSDB_CODE_SUCCESS == code) {

680,396,077✔

1915

    code = tlvEncodeValueU16(pEncoder, pNode->port);

680,398,757✔

1918

  return code;

680,156,283✔

1921

static int32_t epToMsg(const void* pObj, STlvEncoder* pEncoder) {

35,955,077✔

1922

  const SEp* pNode = (const SEp*)pObj;

35,955,077✔

1924

  int32_t code = tlvEncodeCStr(pEncoder, EP_CODE_FQDN, pNode->fqdn);

35,955,077✔

1925

  if (TSDB_CODE_SUCCESS == code) {

35,995,662✔

1926

    code = tlvEncodeU16(pEncoder, EP_CODE_port, pNode->port);

35,995,662✔

1929

  return code;

35,992,784✔

1932

static int32_t msgToEpInline(STlvDecoder* pDecoder, void* pObj) {

483,255,736✔

1933

  SEp* pNode = (SEp*)pObj;

483,255,736✔

1935

  int32_t code = tlvDecodeValueCStr(pDecoder, pNode->fqdn);

483,255,736✔

1936

  if (TSDB_CODE_SUCCESS == code) {

483,297,535✔

1937

    code = tlvDecodeValueU16(pDecoder, &pNode->port);

483,296,625✔

1940

  return code;

483,276,132✔

1943

static int32_t msgToEp(STlvDecoder* pDecoder, void* pObj) {

19,005,446✔

1944

  SEp* pNode = (SEp*)pObj;

19,005,446✔

1946

  int32_t code = TSDB_CODE_SUCCESS;

19,005,446✔

1947

  STlv*   pTlv = NULL;

19,005,446✔

1948

  tlvForEach(pDecoder, pTlv, code) {

57,013,556✔

1949

    switch (pTlv->type) {

38,009,840✔

1950

      case EP_CODE_FQDN:

19,004,920✔

1951

        code = tlvDecodeCStr(pTlv, pNode->fqdn, sizeof(pNode->fqdn));

19,004,920✔

1952

        break;

19,003,792✔

1953

      case EP_CODE_port:

19,004,920✔

1954

        code = tlvDecodeU16(pTlv, &pNode->port);

19,004,920✔

1955

        break;

19,004,844✔

1961

  return code;

19,005,370✔

1966

static int32_t epSetInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {

752,949,500✔

1967

  const SEpSet* pNode = (const SEpSet*)pObj;

752,949,500✔

1969

  int32_t code = tlvEncodeValueI8(pEncoder, pNode->inUse);

752,949,500✔

1970

  if (TSDB_CODE_SUCCESS == code) {

753,044,478✔

1971

    code = tlvEncodeValueArray(pEncoder, epInlineToMsg, pNode->eps, sizeof(SEp), pNode->numOfEps);

753,064,156✔

1974

  return code;

752,864,745✔

1977

static int32_t epSetToMsg(const void* pObj, STlvEncoder* pEncoder) {

35,600,801✔

1978

  const SEpSet* pNode = (const SEpSet*)pObj;

35,600,801✔

1980

  int32_t code = tlvEncodeI8(pEncoder, EP_SET_CODE_IN_USE, pNode->inUse);

35,600,801✔

1981

  if (TSDB_CODE_SUCCESS == code) {

35,629,422✔

1982

    code = tlvEncodeI8(pEncoder, EP_SET_CODE_NUM_OF_EPS, pNode->numOfEps);

35,628,936✔

1984

  if (TSDB_CODE_SUCCESS == code) {

35,628,042✔

1985

    code = tlvEncodeObjArray(pEncoder, EP_SET_CODE_EPS, epToMsg, pNode->eps, sizeof(SEp), pNode->numOfEps);

35,628,042✔

1988

  return code;

35,579,805✔

1991

static int32_t msgToEpSetInline(STlvDecoder* pDecoder, void* pObj) {

538,476,861✔

1992

  SEpSet* pNode = (SEpSet*)pObj;

538,476,861✔

1994

  int32_t code = tlvDecodeValueI8(pDecoder, &pNode->inUse);

538,476,861✔

1995

  if (TSDB_CODE_SUCCESS == code) {

538,509,039✔

1996

    int32_t numOfEps = 0;

538,508,501✔

1997

    code = tlvDecodeValueArray(pDecoder, msgToEpInline, pNode->eps, sizeof(SEp), &numOfEps);

538,509,113✔

1998

    pNode->numOfEps = numOfEps;

538,493,142✔

2001

  return code;

538,496,256✔

2004

static int32_t msgToEpSet(STlvDecoder* pDecoder, void* pObj) {

18,675,831✔

2005

  SEpSet* pNode = (SEpSet*)pObj;

18,675,831✔

2007

  int32_t code = TSDB_CODE_SUCCESS;

18,675,831✔

2008

  STlv*   pTlv = NULL;

18,675,831✔

2009

  tlvForEach(pDecoder, pTlv, code) {

74,700,618✔

2010

    switch (pTlv->type) {

56,025,915✔

2011

      case EP_SET_CODE_IN_USE:

18,674,779✔

2012

        code = tlvDecodeI8(pTlv, &pNode->inUse);

18,674,779✔

2013

        break;

18,674,253✔

2014

      case EP_SET_CODE_NUM_OF_EPS:

18,675,305✔

2015

        code = tlvDecodeI8(pTlv, &pNode->numOfEps);

18,675,305✔

2016

        break;

18,675,305✔

2017

      case EP_SET_CODE_EPS:

18,676,357✔

2018

        code = tlvDecodeObjArrayFromTlv(pTlv, msgToEp, pNode->eps, sizeof(SEp));

18,676,357✔

2019

        break;

18,675,229✔

2025

  return code;

18,674,703✔

2030

static int32_t queryNodeAddrInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {

752,950,111✔

2031

  const SQueryNodeAddr* pNode = (const SQueryNodeAddr*)pObj;

752,950,111✔

2033

  int32_t code = tlvEncodeValueI32(pEncoder, pNode->nodeId);

752,950,111✔

2034

  if (TSDB_CODE_SUCCESS == code) {

752,949,140✔

2035

    code = epSetInlineToMsg(&pNode->epSet, pEncoder);

752,954,521✔

2038

  return code;

752,861,151✔

2052

static int32_t msgToQueryNodeAddrInline(STlvDecoder* pDecoder, void* pObj) {

538,468,707✔

2053

  SQueryNodeAddr* pNode = (SQueryNodeAddr*)pObj;

538,468,707✔

2055

  int32_t code = tlvDecodeValueI32(pDecoder, &pNode->nodeId);

538,468,707✔

2056

  if (TSDB_CODE_SUCCESS == code) {

538,508,903✔

2057

    code = msgToEpSetInline(pDecoder, &pNode->epSet);

538,508,903✔

2060

  return code;

538,493,201✔

2084

static int32_t downstreamSourceNodeInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {

241,845,026✔

2085

  const SDownstreamSourceNode* pNode = (const SDownstreamSourceNode*)pObj;

241,845,026✔

2087

  int32_t code = queryNodeAddrInlineToMsg(&pNode->addr, pEncoder);

241,845,026✔

2088

  if (TSDB_CODE_SUCCESS == code) {

241,845,312✔

2089

    code = tlvEncodeValueU64(pEncoder, pNode->taskId);

241,843,719✔

2091

  if (TSDB_CODE_SUCCESS == code) {

241,846,003✔

2092

    code = tlvEncodeValueU64(pEncoder, pNode->sId);

241,846,003✔

2094

  if (TSDB_CODE_SUCCESS == code) {

241,845,285✔

2095

    code = tlvEncodeValueI32(pEncoder, pNode->execId);

241,845,285✔

2097

  if (TSDB_CODE_SUCCESS == code) {

241,846,820✔

2098

    code = tlvEncodeValueI32(pEncoder, pNode->fetchMsgType);

241,846,396✔

2100

  if (TSDB_CODE_SUCCESS == code) {

241,847,251✔

2101

    code = tlvEncodeValueU64(pEncoder, pNode->clientId);

241,846,827✔

2104

  return code;

241,846,201✔

2107

static int32_t downstreamSourceNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

241,846,009✔

2108

  return tlvEncodeObj(pEncoder, DOWNSTREAM_SOURCE_CODE_INLINE_ATTRS, downstreamSourceNodeInlineToMsg, pObj);

241,846,009✔

2111

static int32_t msgToDownstreamSourceNodeInlineToMsg(STlvDecoder* pDecoder, void* pObj) {

179,581,742✔

2112

  SDownstreamSourceNode* pNode = (SDownstreamSourceNode*)pObj;

179,581,742✔

2114

  int32_t code = msgToQueryNodeAddrInline(pDecoder, &pNode->addr);

179,581,742✔

2115

  if (TSDB_CODE_SUCCESS == code) {

179,582,280✔

2116

    code = tlvDecodeValueU64(pDecoder, &pNode->taskId);

179,581,742✔

2118

  if (TSDB_CODE_SUCCESS == code) {

179,581,742✔

2119

    code = tlvDecodeValueU64(pDecoder, &pNode->sId);

179,581,742✔

2121

  if (TSDB_CODE_SUCCESS == code) {

179,581,372✔

2122

    code = tlvDecodeValueI32(pDecoder, &pNode->execId);

179,581,372✔

2124

  if (TSDB_CODE_SUCCESS == code) {

179,582,280✔

2125

    code = tlvDecodeValueI32(pDecoder, &pNode->fetchMsgType);

179,582,280✔

2127

  if (TSDB_CODE_SUCCESS == code && !tlvDecodeEnd(pDecoder)) {

179,582,280✔

2128

    code = tlvDecodeValueU64(pDecoder, &pNode->clientId);

179,581,742✔

2131

  return code;

179,582,280✔

2134

static int32_t msgToDownstreamSourceNode(STlvDecoder* pDecoder, void* pObj) {

179,581,742✔

2135

  SDownstreamSourceNode* pNode = (SDownstreamSourceNode*)pObj;

179,581,742✔

2137

  int32_t code = TSDB_CODE_SUCCESS;

179,581,742✔

2138

  STlv*   pTlv = NULL;

179,581,742✔

2139

  tlvForEach(pDecoder, pTlv, code) {

359,163,644✔

2140

    switch (pTlv->type) {

179,582,280✔

2141

      case DOWNSTREAM_SOURCE_CODE_INLINE_ATTRS:

179,582,280✔

2142

        code = tlvDecodeObjFromTlv(pTlv, msgToDownstreamSourceNodeInlineToMsg, pNode);

179,582,280✔

2143

        break;

179,582,280✔

2149

  return code;

179,582,313✔

2154

static int32_t whenThenNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

7,159,302✔

2155

  const SWhenThenNode* pNode = (const SWhenThenNode*)pObj;

7,159,302✔

2157

  int32_t code = tlvEncodeObj(pEncoder, WHEN_THEN_CODE_EXPR_BASE, exprNodeToMsg, pNode);

7,159,302✔

2158

  if (TSDB_CODE_SUCCESS == code) {

7,160,362✔

2159

    code = tlvEncodeObj(pEncoder, WHEN_THEN_CODE_WHEN, nodeToMsg, pNode->pWhen);

7,160,362✔

2161

  if (TSDB_CODE_SUCCESS == code) {

7,160,446✔

2162

    code = tlvEncodeObj(pEncoder, WHEN_THEN_CODE_THEN, nodeToMsg, pNode->pThen);

7,160,446✔

2165

  return code;

7,160,446✔

2168

static int32_t msgToWhenThenNode(STlvDecoder* pDecoder, void* pObj) {

1,621,401✔

2169

  SWhenThenNode* pNode = (SWhenThenNode*)pObj;

1,621,401✔

2171

  int32_t code = TSDB_CODE_SUCCESS;

1,621,401✔

2172

  STlv*   pTlv = NULL;

1,621,401✔

2173

  tlvForEach(pDecoder, pTlv, code) {

6,485,604✔

2174

    switch (pTlv->type) {

4,864,203✔

2175

      case WHEN_THEN_CODE_EXPR_BASE:

1,621,401✔

2176

        code = tlvDecodeObjFromTlv(pTlv, msgToExprNode, &pNode->node);

1,621,401✔

2177

        break;

1,621,401✔

2178

      case WHEN_THEN_CODE_WHEN:

1,621,401✔

2179

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pWhen);

1,621,401✔

2180

        break;

1,621,401✔

2181

      case WHEN_THEN_CODE_THEN:

1,621,401✔

2182

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pThen);

1,621,401✔

2183

        break;

1,621,401✔

2189

  return code;

1,621,401✔

2194

static int32_t caseWhenNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

6,977,767✔

2195

  const SCaseWhenNode* pNode = (const SCaseWhenNode*)pObj;

6,977,767✔

2197

  int32_t code = tlvEncodeObj(pEncoder, CASE_WHEN_CODE_EXPR_BASE, exprNodeToMsg, pNode);

6,977,767✔

2198

  if (TSDB_CODE_SUCCESS == code) {

6,978,443✔

2199

    code = tlvEncodeObj(pEncoder, CASE_WHEN_CODE_CASE, nodeToMsg, pNode->pCase);

6,978,443✔

2201

  if (TSDB_CODE_SUCCESS == code) {

6,977,913✔

2202

    code = tlvEncodeObj(pEncoder, CASE_WHEN_CODE_ELSE, nodeToMsg, pNode->pElse);

6,977,820✔

2204

  if (TSDB_CODE_SUCCESS == code) {

6,978,461✔

2205

    code = tlvEncodeObj(pEncoder, CASE_WHEN_CODE_WHEN_THEN_LIST, nodeListToMsg, pNode->pWhenThenList);

6,978,368✔

2208

  return code;

6,978,368✔

2211

static int32_t msgToCaseWhenNode(STlvDecoder* pDecoder, void* pObj) {

1,440,469✔

2212

  SCaseWhenNode* pNode = (SCaseWhenNode*)pObj;

1,440,469✔

2214

  int32_t code = TSDB_CODE_SUCCESS;

1,440,469✔

2215

  STlv*   pTlv = NULL;

1,440,469✔

2216

  tlvForEach(pDecoder, pTlv, code) {

5,842,950✔

2217

    switch (pTlv->type) {

4,402,481✔

2218

      case CASE_WHEN_CODE_EXPR_BASE:

1,440,469✔

2219

        code = tlvDecodeObjFromTlv(pTlv, msgToExprNode, &pNode->node);

1,440,469✔

2220

        break;

1,440,469✔

2221

      case CASE_WHEN_CODE_CASE:

140,794✔

2222

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pCase);

140,794✔

2223

        break;

140,794✔

2224

      case CASE_WHEN_CODE_ELSE:

1,380,749✔

2225

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pElse);

1,380,749✔

2226

        break;

1,380,749✔

2227

      case CASE_WHEN_CODE_WHEN_THEN_LIST:

1,440,469✔

2228

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pWhenThenList);

1,440,469✔

2229

        break;

1,440,469✔

2235

  return code;

1,440,469✔

2240

static int32_t windowOffsetNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

325,560✔

2241

  const SWindowOffsetNode* pNode = (const SWindowOffsetNode*)pObj;

325,560✔

2243

  int32_t code = tlvEncodeObj(pEncoder, WINDOW_OFFSET_CODE_START_OFFSET, nodeToMsg, pNode->pStartOffset);

325,560✔

2244

  if (TSDB_CODE_SUCCESS == code) {

325,560✔

2245

    code = tlvEncodeObj(pEncoder, WINDOW_OFFSET_CODE_END_OFFSET, nodeToMsg, pNode->pEndOffset);

325,560✔

2248

  return code;

325,560✔

2251

static int32_t msgToWindowOffsetNode(STlvDecoder* pDecoder, void* pObj) {

327,012✔

2252

  SWindowOffsetNode* pNode = (SWindowOffsetNode*)pObj;

327,012✔

2254

  int32_t code = TSDB_CODE_SUCCESS;

327,012✔

2255

  STlv*   pTlv = NULL;

327,012✔

2256

  tlvForEach(pDecoder, pTlv, code) {

981,036✔

2257

    switch (pTlv->type) {

654,024✔

2258

      case WINDOW_OFFSET_CODE_START_OFFSET:

327,012✔

2259

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pStartOffset);

327,012✔

2260

        break;

327,012✔

2261

      case WINDOW_OFFSET_CODE_END_OFFSET:

327,012✔

2262

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pEndOffset);

327,012✔

2263

        break;

327,012✔

2269

  return code;

327,012✔

2285

static int32_t physiNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

1,077,495,522✔

2286

  const SPhysiNode* pNode = (const SPhysiNode*)pObj;

1,077,495,522✔

2288

  int32_t code = tlvEncodeObj(pEncoder, PHY_NODE_CODE_OUTPUT_DESC, nodeToMsg, pNode->pOutputDataBlockDesc);

1,077,495,522✔

2289

  if (TSDB_CODE_SUCCESS == code) {

1,078,300,694✔

2290

    code = tlvEncodeObj(pEncoder, PHY_NODE_CODE_CONDITIONS, nodeToMsg, pNode->pConditions);

1,078,156,128✔

2292

  if (TSDB_CODE_SUCCESS == code) {

1,078,215,523✔

2293

    code = tlvEncodeObj(pEncoder, PHY_NODE_CODE_CHILDREN, nodeListToMsg, pNode->pChildren);

1,078,225,145✔

2295

  if (TSDB_CODE_SUCCESS == code) {

1,077,967,712✔

2296

    code = tlvEncodeObj(pEncoder, PHY_NODE_CODE_LIMIT, nodeToMsg, pNode->pLimit);

1,077,987,438✔

2298

  if (TSDB_CODE_SUCCESS == code) {

1,077,701,752✔

2299

    code = tlvEncodeObj(pEncoder, PHY_NODE_CODE_SLIMIT, nodeToMsg, pNode->pSlimit);

1,077,701,062✔

2301

  if (TSDB_CODE_SUCCESS == code) {

1,077,489,595✔

2302

    code = tlvEncodeEnum(pEncoder, PHY_NODE_CODE_INPUT_TS_ORDER, pNode->inputTsOrder);

1,077,497,579✔

2304

  if (TSDB_CODE_SUCCESS == code) {

1,077,259,277✔

2305

    code = tlvEncodeEnum(pEncoder, PHY_NODE_CODE_OUTPUT_TS_ORDER, pNode->outputTsOrder);

1,077,269,308✔

2307

  if (TSDB_CODE_SUCCESS == code) {

1,078,284,181✔

2308

    code = tlvEncodeBool(pEncoder, PHY_NODE_CODE_DYNAMIC_OP, pNode->dynamicOp);

1,078,297,115✔

2310

  if (TSDB_CODE_SUCCESS == code) {

1,078,342,124✔

2311

    code = tlvEncodeBool(pEncoder, PHY_NODE_CODE_FORCE_NONBLOCKING_OPTR, pNode->forceCreateNonBlockingOptr);

1,078,329,005✔

2314

  return code;

1,078,398,947✔

2317

static int32_t msgToPhysiNode(STlvDecoder* pDecoder, void* pObj) {

768,456,599✔

2318

  SPhysiNode* pNode = (SPhysiNode*)pObj;

768,456,599✔

2320

  int32_t code = TSDB_CODE_SUCCESS;

768,456,599✔

2321

  STlv*   pTlv = NULL;

768,456,599✔

2322

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

2323

    switch (pTlv->type) {

2,147,483,647✔

2324

      case PHY_NODE_CODE_OUTPUT_DESC:

768,448,018✔

2325

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pOutputDataBlockDesc);

768,448,018✔

2326

        break;

768,504,395✔

2327

      case PHY_NODE_CODE_CONDITIONS:

99,432,078✔

2328

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pConditions);

99,432,078✔

2329

        break;

99,426,880✔

2330

      case PHY_NODE_CODE_CHILDREN:

359,560,741✔

2331

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pChildren);

359,560,741✔

2332

        break;

359,562,774✔

2333

      case PHY_NODE_CODE_LIMIT:

32,068,304✔

2334

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pLimit);

32,068,304✔

2335

        break;

32,066,662✔

2336

      case PHY_NODE_CODE_SLIMIT:

2,657,159✔

2337

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pSlimit);

2,657,159✔

2338

        break;

2,657,159✔

2339

      case PHY_NODE_CODE_INPUT_TS_ORDER:

768,537,013✔

2340

        code = tlvDecodeEnum(pTlv, &pNode->inputTsOrder, sizeof(pNode->inputTsOrder));

768,537,013✔

2341

        break;

768,518,726✔

2342

      case PHY_NODE_CODE_OUTPUT_TS_ORDER:

768,559,576✔

2343

        code = tlvDecodeEnum(pTlv, &pNode->outputTsOrder, sizeof(pNode->outputTsOrder));

768,559,576✔

2344

        break;

768,558,356✔

2345

      case PHY_NODE_CODE_DYNAMIC_OP:

768,559,923✔

2346

        code = tlvDecodeBool(pTlv, &pNode->dynamicOp);

768,559,923✔

2347

        break;

768,535,251✔

2348

      case PHY_NODE_CODE_FORCE_NONBLOCKING_OPTR:

768,659,133✔

2349

        code = tlvDecodeBool(pTlv, &pNode->forceCreateNonBlockingOptr);

768,659,133✔

2350

        break;

768,561,804✔

2356

  return code;

768,597,764✔

2371

static int32_t physiScanNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

427,550,987✔

2372

  const SScanPhysiNode* pNode = (const SScanPhysiNode*)pObj;

427,550,987✔

2374

  int32_t code = tlvEncodeObj(pEncoder, PHY_SCAN_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

427,550,987✔

2375

  if (TSDB_CODE_SUCCESS == code) {

427,954,672✔

2376

    code = tlvEncodeObj(pEncoder, PHY_SCAN_CODE_SCAN_COLS, nodeListToMsg, pNode->pScanCols);

427,961,928✔

2378

  if (TSDB_CODE_SUCCESS == code) {

427,942,258✔

2379

    code = tlvEncodeObj(pEncoder, PHY_SCAN_CODE_SCAN_PSEUDO_COLS, nodeListToMsg, pNode->pScanPseudoCols);

427,903,219✔

2381

  if (TSDB_CODE_SUCCESS == code) {

427,974,956✔

2382

    code = tlvEncodeU64(pEncoder, PHY_SCAN_CODE_BASE_UID, pNode->uid);

427,941,694✔

2384

  if (TSDB_CODE_SUCCESS == code) {

427,720,057✔

2385

    code = tlvEncodeU64(pEncoder, PHY_SCAN_CODE_BASE_SUID, pNode->suid);

427,688,498✔

2387

  if (TSDB_CODE_SUCCESS == code) {

427,985,303✔

2388

    code = tlvEncodeI8(pEncoder, PHY_SCAN_CODE_BASE_TABLE_TYPE, pNode->tableType);

427,954,300✔

2390

  if (TSDB_CODE_SUCCESS == code) {

428,002,046✔

2391

    code = tlvEncodeObj(pEncoder, PHY_SCAN_CODE_BASE_TABLE_NAME, nameToMsg, &pNode->tableName);

427,915,665✔

2393

  if (TSDB_CODE_SUCCESS == code) {

428,049,586✔

2394

    code = tlvEncodeBool(pEncoder, PHY_SCAN_CODE_BASE_GROUP_ORDER_SCAN, pNode->groupOrderScan);

427,963,674✔

2396

  if (TSDB_CODE_SUCCESS == code) {

428,075,395✔

2397

    code = tlvEncodeBool(pEncoder, PHY_SCAN_CODE_BASE_VIRTUAL_STABLE_SCAN, pNode->virtualStableScan);

427,990,568✔

2400

  return code;

428,006,778✔

2403

static int32_t msgToPhysiScanNode(STlvDecoder* pDecoder, void* pObj) {

300,475,387✔

2404

  SScanPhysiNode* pNode = (SScanPhysiNode*)pObj;

300,475,387✔

2406

  int32_t code = TSDB_CODE_SUCCESS;

300,475,387✔

2407

  STlv*   pTlv = NULL;

300,475,387✔

2408

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

2409

    switch (pTlv->type) {

2,147,483,647✔

2410

      case PHY_SCAN_CODE_BASE_NODE:

300,461,922✔

2411

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

300,461,922✔

2412

        break;

300,514,988✔

2413

      case PHY_SCAN_CODE_SCAN_COLS:

292,563,878✔

2414

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pScanCols);

292,563,878✔

2415

        break;

292,596,461✔

2416

      case PHY_SCAN_CODE_SCAN_PSEUDO_COLS:

76,468,699✔

2417

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pScanPseudoCols);

76,468,699✔

2418

        break;

76,467,069✔

2419

      case PHY_SCAN_CODE_BASE_UID:

300,522,470✔

2420

        code = tlvDecodeU64(pTlv, &pNode->uid);

300,522,470✔

2421

        break;

300,491,651✔

2422

      case PHY_SCAN_CODE_BASE_SUID:

300,527,918✔

2423

        code = tlvDecodeU64(pTlv, &pNode->suid);

300,527,918✔

2424

        break;

300,526,065✔

2425

      case PHY_SCAN_CODE_BASE_TABLE_TYPE:

300,528,567✔

2426

        code = tlvDecodeI8(pTlv, &pNode->tableType);

300,528,567✔

2427

        break;

300,497,152✔

2428

      case PHY_SCAN_CODE_BASE_TABLE_NAME:

300,527,251✔

2429

        code = tlvDecodeObjFromTlv(pTlv, msgToName, &pNode->tableName);

300,527,251✔

2430

        break;

300,523,436✔

2431

      case PHY_SCAN_CODE_BASE_GROUP_ORDER_SCAN:

300,527,643✔

2432

        code = tlvDecodeBool(pTlv, &pNode->groupOrderScan);

300,527,643✔

2433

        break;

300,527,480✔

2434

      case PHY_SCAN_CODE_BASE_VIRTUAL_STABLE_SCAN:

300,528,273✔

2435

        code = tlvDecodeBool(pTlv, &pNode->virtualStableScan);

300,528,273✔

2436

      default:

300,525,587✔

2437

        break;

300,525,587✔

2441

  return code;

300,600,151✔

2456

static int32_t physiVirtualTableScanNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

4,264,891✔

2457

  const SVirtualScanPhysiNode* pNode = (const SVirtualScanPhysiNode *)pObj;

4,264,891✔

2459

  int32_t code = tlvEncodeObj(pEncoder, PHY_VIRTUAL_TABLE_SCAN_CODE_SCAN, physiScanNodeToMsg, &pNode->scan);

4,264,891✔

2461

  if (TSDB_CODE_SUCCESS == code) {

4,264,891✔

2462

    code = tlvEncodeObj(pEncoder, PHY_VIRTUAL_TABLE_SCAN_CODE_GROUPTAGS, nodeListToMsg, pNode->pGroupTags);

4,264,891✔

2465

  if (TSDB_CODE_SUCCESS == code) {

4,264,891✔

2466

    code = tlvEncodeBool(pEncoder, PHY_VIRTUAL_TABLE_SCAN_CODE_GROUP_SORT, pNode->groupSort);

4,264,891✔

2469

  if (TSDB_CODE_SUCCESS == code) {

4,264,891✔

2470

    code = tlvEncodeBool(pEncoder, PHY_VIRTUAL_TABLE_SCAN_CODE_ONLY_TS, pNode->scanAllCols);

4,264,891✔

2473

  if (TSDB_CODE_SUCCESS == code) {

4,264,891✔

2474

    code = tlvEncodeObj(pEncoder, PHY_VIRTUAL_TABLE_SCAN_CODE_TARGETS, nodeListToMsg, pNode->pTargets);

4,264,891✔

2477

  if (TSDB_CODE_SUCCESS == code) {

4,264,891✔

2478

    code = tlvEncodeObj(pEncoder, PHY_VIRTUAL_TABLE_SCAN_CODE_TAGS, nodeListToMsg, pNode->pTags);

4,264,891✔

2481

  if (TSDB_CODE_SUCCESS == code) {

4,264,891✔

2482

    code = tlvEncodeObj(pEncoder, PHY_VIRTUAL_TABLE_SCAN_CODE_SUBTABLE, nodeToMsg, pNode->pSubtable);

4,264,891✔

2485

  if (TSDB_CODE_SUCCESS == code) {

4,264,891✔

2486

    code = tlvEncodeI8(pEncoder, PHY_VIRTUAL_TABLE_SCAN_CODE_IGNORE_EXPIRED, pNode->igExpired);

4,264,891✔

2489

  if (TSDB_CODE_SUCCESS == code) {

4,264,891✔

2490

    code = tlvEncodeI8(pEncoder, PHY_VIRTUAL_TABLE_SCAN_CODE_IGNORE_CHECK_UPDATE, pNode->igCheckUpdate);

4,264,891✔

2493

  return code;

4,264,891✔

2496

static int32_t msgToPhysiVirtualTableScanNode(STlvDecoder* pDecoder, void* pObj) {

3,874,185✔

2497

  SVirtualScanPhysiNode* pNode = (SVirtualScanPhysiNode*)pObj;

3,874,185✔

2499

  int32_t code = TSDB_CODE_SUCCESS;

3,874,185✔

2500

  STlv*   pTlv = NULL;

3,874,185✔

2501

  tlvForEach(pDecoder, pTlv, code) {

27,115,620✔

2502

    switch (pTlv->type) {

23,241,435✔

2503

      case PHY_VIRTUAL_TABLE_SCAN_CODE_SCAN:

3,874,185✔

2504

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiScanNode, &pNode->scan);

3,874,185✔

2505

        break;

3,874,185✔

2509

      case PHY_VIRTUAL_TABLE_SCAN_CODE_GROUP_SORT:

3,874,185✔

2510

        code = tlvDecodeBool(pTlv, &pNode->groupSort);

3,874,185✔

2511

        break;

3,874,185✔

2512

      case PHY_VIRTUAL_TABLE_SCAN_CODE_ONLY_TS:

3,874,185✔

2513

        code = tlvDecodeBool(pTlv, &pNode->scanAllCols);

3,874,185✔

2514

        break;

3,874,185✔

2515

      case PHY_VIRTUAL_TABLE_SCAN_CODE_TARGETS:

3,870,510✔

2516

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pTargets);

3,870,510✔

2517

        break;

3,870,510✔

2524

      case PHY_VIRTUAL_TABLE_SCAN_CODE_IGNORE_EXPIRED:

3,874,185✔

2525

        code = tlvDecodeI8(pTlv, &pNode->igExpired);

3,874,185✔

2526

        break;

3,874,185✔

2527

      case PHY_VIRTUAL_TABLE_SCAN_CODE_IGNORE_CHECK_UPDATE:

3,874,185✔

2528

        code = tlvDecodeI8(pTlv, &pNode->igCheckUpdate);

3,874,185✔

2529

        break;

3,874,185✔

2535

  return code;

3,874,185✔

2543

static int32_t physiTagScanNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

14,296,048✔

2544

  const STagScanPhysiNode* pNode = (const STagScanPhysiNode*)pObj;

14,296,048✔

2546

  int32_t code = tlvEncodeObj(pEncoder, PHY_TAG_SCAN_CODE_SCAN, physiScanNodeToMsg, &pNode->scan);

14,296,048✔

2548

  if (TSDB_CODE_SUCCESS == code) {

14,316,891✔

2549

    code = tlvEncodeBool(pEncoder, PHY_TAG_SCAN_CODE_ONLY_META_CTB_IDX, pNode->onlyMetaCtbIdx);

14,316,363✔

2551

  return code;

14,317,973✔

2554

static int32_t msgToPhysiTagScanNode(STlvDecoder* pDecoder, void* pObj) {

7,983,207✔

2555

  STagScanPhysiNode* pNode = (STagScanPhysiNode*)pObj;

7,983,207✔

2557

  int32_t code = TSDB_CODE_SUCCESS;

7,983,207✔

2558

  STlv*   pTlv = NULL;

7,983,207✔

2559

  tlvForEach(pDecoder, pTlv, code) {

23,951,459✔

2560

    switch (pTlv->type) {

15,967,852✔

2561

      case PHY_TAG_SCAN_CODE_SCAN:

7,983,737✔

2562

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiScanNode, &pNode->scan);

7,983,737✔

2563

        break;

7,983,607✔

2564

      case PHY_TAG_SCAN_CODE_ONLY_META_CTB_IDX:

7,984,115✔

2565

        code = tlvDecodeBool(pTlv, &pNode->onlyMetaCtbIdx);

7,984,115✔

2566

        break;

7,984,115✔

2572

  return code;

7,983,847✔

2584

static int32_t physiLastRowScanNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

1,236,375✔

2585

  const SLastRowScanPhysiNode* pNode = (const SLastRowScanPhysiNode*)pObj;

1,236,375✔

2587

  int32_t code = tlvEncodeObj(pEncoder, PHY_LAST_ROW_SCAN_CODE_SCAN, physiScanNodeToMsg, &pNode->scan);

1,236,375✔

2588

  if (TSDB_CODE_SUCCESS == code) {

1,237,575✔

2589

    code = tlvEncodeObj(pEncoder, PHY_LAST_ROW_SCAN_CODE_GROUP_TAGS, nodeListToMsg, pNode->pGroupTags);

1,237,575✔

2591

  if (TSDB_CODE_SUCCESS == code) {

1,237,461✔

2592

    code = tlvEncodeBool(pEncoder, PHY_LAST_ROW_SCAN_CODE_GROUP_SORT, pNode->groupSort);

1,237,463✔

2594

  if (TSDB_CODE_SUCCESS == code) {

1,237,538✔

2595

    code = tlvEncodeBool(pEncoder, PHY_LAST_ROW_SCAN_CODE_IGNULL, pNode->ignoreNull);

1,237,540✔

2597

  if (TSDB_CODE_SUCCESS == code) {

1,237,573✔

2598

    code = tlvEncodeObj(pEncoder, PHY_LAST_ROW_SCAN_CODE_TARGETS, nodeListToMsg, pNode->pTargets);

1,237,575✔

2600

  if (TSDB_CODE_SUCCESS == code) {

1,237,462✔

2601

    code = tlvEncodeObj(pEncoder, PHY_LAST_ROW_SCAN_CODE_FUNCTYPES, SArrayToMsg, pNode->pFuncTypes);

1,237,499✔

2604

  return code;

1,237,502✔

2607

static int32_t msgToPhysiLastRowScanNode(STlvDecoder* pDecoder, void* pObj) {

1,232,936✔

2608

  SLastRowScanPhysiNode* pNode = (SLastRowScanPhysiNode*)pObj;

1,232,936✔

2610

  int32_t code = TSDB_CODE_SUCCESS;

1,232,936✔

2611

  STlv*   pTlv = NULL;

1,232,936✔

2612

  tlvForEach(pDecoder, pTlv, code) {

6,290,152✔

2613

    switch (pTlv->type) {

5,057,216✔

2614

      case PHY_LAST_ROW_SCAN_CODE_SCAN:

1,232,936✔

2615

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiScanNode, &pNode->scan);

1,232,936✔

2616

        break;

1,232,936✔

2617

      case PHY_LAST_ROW_SCAN_CODE_GROUP_TAGS:

155,193✔

2618

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pGroupTags);

155,193✔

2619

        break;

155,193✔

2620

      case PHY_LAST_ROW_SCAN_CODE_GROUP_SORT:

1,232,936✔

2621

        code = tlvDecodeBool(pTlv, &pNode->groupSort);

1,232,936✔

2622

        break;

1,232,936✔

2623

      case PHY_LAST_ROW_SCAN_CODE_IGNULL:

1,232,936✔

2624

        code = tlvDecodeBool(pTlv, &pNode->ignoreNull);

1,232,936✔

2625

        break;

1,232,936✔

2626

      case PHY_LAST_ROW_SCAN_CODE_TARGETS:

1,203,215✔

2627

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pTargets);

1,203,215✔

2628

        break;

1,203,215✔

2638

  return code;

1,233,099✔

2654

static int32_t physiTableScanNodeInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {

376,390,511✔

2655

  const STableScanPhysiNode* pNode = (const STableScanPhysiNode*)pObj;

376,390,511✔

2657

  int32_t code = tlvEncodeValueU8(pEncoder, pNode->scanSeq[0]);

376,390,511✔

2658

  if (TSDB_CODE_SUCCESS == code) {

376,636,706✔

2659

    code = tlvEncodeValueU8(pEncoder, pNode->scanSeq[1]);

376,350,943✔

2661

  if (TSDB_CODE_SUCCESS == code) {

376,643,029✔

2662

    code = tlvEncodeValueI64(pEncoder, pNode->scanRange.skey);

376,566,928✔

2664

  if (TSDB_CODE_SUCCESS == code) {

376,696,895✔

2665

    code = tlvEncodeValueI64(pEncoder, pNode->scanRange.ekey);

376,625,753✔

2667

  if (TSDB_CODE_SUCCESS == code) {

376,682,767✔

2668

    code = tlvEncodeValueDouble(pEncoder, pNode->ratio);

376,611,769✔

2670

  if (TSDB_CODE_SUCCESS == code) {

376,111,991✔

2671

    code = tlvEncodeValueI32(pEncoder, pNode->dataRequired);

376,044,904✔

2673

  if (TSDB_CODE_SUCCESS == code) {

376,756,171✔

2674

    code = tlvEncodeValueBool(pEncoder, pNode->groupSort);

376,600,955✔

2676

  if (TSDB_CODE_SUCCESS == code) {

376,807,206✔

2677

    code = tlvEncodeValueI64(pEncoder, pNode->interval);

376,666,832✔

2679

  if (TSDB_CODE_SUCCESS == code) {

376,815,255✔

2680

    code = tlvEncodeValueI64(pEncoder, pNode->offset);

376,674,486✔

2682

  if (TSDB_CODE_SUCCESS == code) {

376,897,652✔

2683

    code = tlvEncodeValueI64(pEncoder, pNode->sliding);

376,757,692✔

2685

  if (TSDB_CODE_SUCCESS == code) {

376,850,964✔

2686

    code = tlvEncodeValueI8(pEncoder, pNode->intervalUnit);

376,650,452✔

2688

  if (TSDB_CODE_SUCCESS == code) {

376,944,321✔

2689

    code = tlvEncodeValueI8(pEncoder, pNode->slidingUnit);

376,752,006✔

2691

  if (TSDB_CODE_SUCCESS == code) {

376,897,126✔

2692

    code = tlvEncodeValueI8(pEncoder, pNode->triggerType);

376,704,643✔

2694

  if (TSDB_CODE_SUCCESS == code) {

376,962,494✔

2695

    code = tlvEncodeValueI64(pEncoder, pNode->watermark);

376,769,373✔

2697

  if (TSDB_CODE_SUCCESS == code) {

376,919,654✔

2698

    code = tlvEncodeValueI8(pEncoder, pNode->igExpired);

376,650,650✔

2700

  if (TSDB_CODE_SUCCESS == code) {

376,934,245✔

2701

    code = tlvEncodeValueBool(pEncoder, pNode->assignBlockUid);

376,678,298✔

2703

  if (TSDB_CODE_SUCCESS == code) {

376,929,548✔

2704

    code = tlvEncodeValueI8(pEncoder, pNode->igCheckUpdate);

376,675,474✔

2706

  if (TSDB_CODE_SUCCESS == code) {

376,914,920✔

2707

    code = tlvEncodeValueBool(pEncoder, pNode->filesetDelimited);

376,661,956✔

2709

  if (TSDB_CODE_SUCCESS == code) {

376,933,413✔

2710

    code = tlvEncodeValueBool(pEncoder, pNode->needCountEmptyTable);

376,575,811✔

2712

  if (TSDB_CODE_SUCCESS == code) {

377,120,616✔

2713

    code = tlvEncodeValueBool(pEncoder, pNode->paraTablesSort);

376,772,155✔

2715

  if (TSDB_CODE_SUCCESS == code) {

377,068,947✔

2716

    code = tlvEncodeValueBool(pEncoder, pNode->smallDataTsSort);

376,729,245✔

2718

  return code;

376,797,742✔

2721

static int32_t physiTableScanNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

376,497,922✔

2722

  const STableScanPhysiNode* pNode = (const STableScanPhysiNode*)pObj;

376,497,922✔

2724

  int32_t code = tlvEncodeObj(pEncoder, PHY_TABLE_SCAN_CODE_SCAN, physiScanNodeToMsg, &pNode->scan);

376,497,922✔

2725

  if (TSDB_CODE_SUCCESS == code) {

376,856,433✔

2726

    code = tlvEncodeObj(pEncoder, PHY_TABLE_SCAN_CODE_INLINE_ATTRS, physiTableScanNodeInlineToMsg, pNode);

376,864,938✔

2728

  if (TSDB_CODE_SUCCESS == code) {

376,785,327✔

2729

    code = tlvEncodeObj(pEncoder, PHY_TABLE_SCAN_CODE_EXT_SCAN_RANGE, timeWindowToMsg, pNode->pExtScanRange);

376,792,937✔

2731

  if (TSDB_CODE_SUCCESS == code) {

376,380,798✔

2732

    code = tlvEncodeObj(pEncoder, PHY_TABLE_SCAN_CODE_DYN_SCAN_FUNCS, nodeListToMsg, pNode->pDynamicScanFuncs);

376,384,762✔

2734

  if (TSDB_CODE_SUCCESS == code) {

376,331,308✔

2735

    code = tlvEncodeObj(pEncoder, PHY_TABLE_SCAN_CODE_GROUP_TAGS, nodeListToMsg, pNode->pGroupTags);

376,215,293✔

2737

  if (TSDB_CODE_SUCCESS == code) {

376,430,386✔

2738

    code = tlvEncodeObj(pEncoder, PHY_TABLE_SCAN_CODE_TAGS, nodeListToMsg, pNode->pTags);

376,369,225✔

2740

  if (TSDB_CODE_SUCCESS == code) {

376,003,841✔

2741

    code = tlvEncodeObj(pEncoder, PHY_TABLE_SCAN_CODE_SUBTABLE, nodeToMsg, pNode->pSubtable);

375,949,795✔

2743

  if (TSDB_CODE_SUCCESS == code) {

376,109,699✔

2744

    code = tlvEncodeObj(pEncoder, PHY_TABLE_SCAN_CODE_TIME_RANGE_EXPR, nodeToMsg, pNode->pTimeRange);

376,058,826✔

2746

  if (TSDB_CODE_SUCCESS == code) {

375,794,819✔

2747

    code = tlvEncodeObj(pEncoder, PHY_TABLE_SCAN_CODE_EXT_TIME_RANGE_EXPR, nodeToMsg, pNode->pExtTimeRange);

375,745,159✔

2749

  if (TSDB_CODE_SUCCESS == code) {

375,948,848✔

2750

    code = tlvEncodeObj(pEncoder, PHY_TABLE_SCAN_CODE_PRIM_COND_EXPR, nodeToMsg, pNode->pPrimaryCond);

375,901,404✔

2753

  return code;

375,615,631✔

2756

static int32_t msgToPhysiTableScanNodeInline(STlvDecoder* pDecoder, void* pObj) {

271,165,805✔

2757

  STableScanPhysiNode* pNode = (STableScanPhysiNode*)pObj;

271,165,805✔

2759

  int32_t code = tlvDecodeValueU8(pDecoder, pNode->scanSeq);

271,165,805✔

2760

  if (TSDB_CODE_SUCCESS == code) {

271,198,753✔

2761

    code = tlvDecodeValueU8(pDecoder, pNode->scanSeq + 1);

271,156,540✔

2763

  if (TSDB_CODE_SUCCESS == code) {

271,194,452✔

2764

    code = tlvDecodeValueI64(pDecoder, &pNode->scanRange.skey);

271,194,452✔

2766

  if (TSDB_CODE_SUCCESS == code) {

271,173,381✔

2767

    code = tlvDecodeValueI64(pDecoder, &pNode->scanRange.ekey);

271,173,381✔

2769

  if (TSDB_CODE_SUCCESS == code) {

271,187,758✔

2770

    code = tlvDecodeValueDouble(pDecoder, &pNode->ratio);

271,187,758✔

2772

  if (TSDB_CODE_SUCCESS == code) {

271,144,349✔

2773

    code = tlvDecodeValueI32(pDecoder, &pNode->dataRequired);

271,144,349✔

2775

  if (TSDB_CODE_SUCCESS == code) {

271,197,802✔

2776

    code = tlvDecodeValueBool(pDecoder, &pNode->groupSort);

271,197,802✔

2778

  if (TSDB_CODE_SUCCESS == code) {

271,161,867✔

2779

    code = tlvDecodeValueI64(pDecoder, &pNode->interval);

271,161,867✔

2781

  if (TSDB_CODE_SUCCESS == code) {

271,206,309✔

2782

    code = tlvDecodeValueI64(pDecoder, &pNode->offset);

271,206,309✔

2784

  if (TSDB_CODE_SUCCESS == code) {

271,165,232✔

2785

    code = tlvDecodeValueI64(pDecoder, &pNode->sliding);

271,165,232✔

2787

  if (TSDB_CODE_SUCCESS == code) {

271,195,896✔

2788

    code = tlvDecodeValueI8(pDecoder, &pNode->intervalUnit);

271,195,896✔

2790

  if (TSDB_CODE_SUCCESS == code) {

271,164,874✔

2791

    code = tlvDecodeValueI8(pDecoder, &pNode->slidingUnit);

271,164,874✔

2793

  if (TSDB_CODE_SUCCESS == code) {

271,201,591✔

2794

    code = tlvDecodeValueI8(pDecoder, &pNode->triggerType);

271,201,591✔

2796

  if (TSDB_CODE_SUCCESS == code) {

271,166,476✔

2797

    code = tlvDecodeValueI64(pDecoder, &pNode->watermark);

271,166,476✔

2799

  if (TSDB_CODE_SUCCESS == code) {

271,205,300✔

2800

    code = tlvDecodeValueI8(pDecoder, &pNode->igExpired);

271,205,300✔

2802

  if (TSDB_CODE_SUCCESS == code) {

271,164,548✔

2803

    code = tlvDecodeValueBool(pDecoder, &pNode->assignBlockUid);

271,164,548✔

2805

  if (TSDB_CODE_SUCCESS == code) {

271,201,073✔

2806

    code = tlvDecodeValueI8(pDecoder, &pNode->igCheckUpdate);

271,201,073✔

2808

  if (TSDB_CODE_SUCCESS == code) {

271,168,799✔

2809

    code = tlvDecodeValueBool(pDecoder, &pNode->filesetDelimited);

271,168,799✔

2811

  if (TSDB_CODE_SUCCESS == code) {

271,205,016✔

2812

    code = tlvDecodeValueBool(pDecoder, &pNode->needCountEmptyTable);

271,205,016✔

2814

  if (TSDB_CODE_SUCCESS == code) {

271,161,103✔

2815

    code = tlvDecodeValueBool(pDecoder, &pNode->paraTablesSort);

271,161,103✔

2817

  if (TSDB_CODE_SUCCESS == code) {

271,202,932✔

2818

    code = tlvDecodeValueBool(pDecoder, &pNode->smallDataTsSort);

271,202,932✔

2820

  return code;

271,163,829✔

2823

static int32_t msgToPhysiTableScanNode(STlvDecoder* pDecoder, void* pObj) {

271,175,051✔

2824

  STableScanPhysiNode* pNode = (STableScanPhysiNode*)pObj;

271,175,051✔

2826

  int32_t code = TSDB_CODE_SUCCESS;

271,175,051✔

2827

  STlv*   pTlv = NULL;

271,175,051✔

2828

  tlvForEach(pDecoder, pTlv, code) {

858,444,092✔

2829

    switch (pTlv->type) {

587,298,327✔

2830

      case PHY_TABLE_SCAN_CODE_SCAN:

271,155,741✔

2831

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiScanNode, &pNode->scan);

271,155,741✔

2832

        break;

271,193,485✔

2833

      case PHY_TABLE_SCAN_CODE_INLINE_ATTRS:

271,169,460✔

2834

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiTableScanNodeInline, pNode);

271,169,460✔

2835

        break;

271,179,384✔

2839

      case PHY_TABLE_SCAN_CODE_GROUP_TAGS:

40,338,907✔

2840

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pGroupTags);

40,338,907✔

2841

        break;

40,330,078✔

2851

      case PHY_TABLE_SCAN_CODE_EXT_SCAN_RANGE:

3,904,148✔

2852

        pNode->pExtScanRange = taosMemoryMalloc(sizeof(*pNode->pExtScanRange));

3,904,148✔

2853

        if (NULL == pNode->pExtScanRange) {

3,904,148✔

2857

        code = tlvDecodeObjFromTlv(pTlv, msgToTimeWindow, pNode->pExtScanRange);

3,904,148✔

2858

        break;

3,904,148✔

2862

      case PHY_TABLE_SCAN_CODE_PRIM_COND_EXPR:

727,146✔

2863

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pPrimaryCond);

727,146✔

2864

        break;

648,156✔

2870

  return code;

271,215,514✔

2882

static int32_t physiSysTableScanNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

31,275,866✔

2883

  const SSystemTableScanPhysiNode* pNode = (const SSystemTableScanPhysiNode*)pObj;

31,275,866✔

2885

  int32_t code = tlvEncodeObj(pEncoder, PHY_SYSTABLE_SCAN_CODE_SCAN, physiScanNodeToMsg, &pNode->scan);

31,275,866✔

2886

  if (TSDB_CODE_SUCCESS == code) {

31,300,904✔

2887

    code = tlvEncodeObj(pEncoder, PHY_SYSTABLE_SCAN_CODE_MGMT_EP_SET, epSetToMsg, &pNode->mgmtEpSet);

31,300,904✔

2889

  if (TSDB_CODE_SUCCESS == code) {

31,249,206✔

2890

    code = tlvEncodeBool(pEncoder, PHY_SYSTABLE_SCAN_CODE_SHOW_REWRITE, pNode->showRewrite);

31,249,206✔

2892

  if (TSDB_CODE_SUCCESS == code) {

31,299,421✔

2893

    code = tlvEncodeI32(pEncoder, PHY_SYSTABLE_SCAN_CODE_ACCOUNT_ID, pNode->accountId);

31,299,421✔

2895

  if (TSDB_CODE_SUCCESS == code) {

31,300,482✔

2896

    code = tlvEncodeBool(pEncoder, PHY_SYSTABLE_SCAN_CODE_SYS_INFO, pNode->sysInfo);

31,300,482✔

2898

  if (TSDB_CODE_SUCCESS == code) {

31,302,502✔

2899

    code = tlvEncodeU16(pEncoder, PHY_SYSTABLE_SCAN_CODE_PRIV_INFO, pNode->privInfo);

31,302,502✔

2902

  return code;

31,302,421✔

2905

static int32_t msgToPhysiSysTableScanNode(STlvDecoder* pDecoder, void* pObj) {

16,222,806✔

2906

  SSystemTableScanPhysiNode* pNode = (SSystemTableScanPhysiNode*)pObj;

16,222,806✔

2908

  int32_t code = TSDB_CODE_SUCCESS;

16,222,806✔

2909

  STlv*   pTlv = NULL;

16,222,806✔

2910

  tlvForEach(pDecoder, pTlv, code) {

113,562,270✔

2911

    switch (pTlv->type) {

97,340,066✔

2912

      case PHY_SYSTABLE_SCAN_CODE_SCAN:

16,221,654✔

2913

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiScanNode, &pNode->scan);

16,221,654✔

2914

        break;

16,222,906✔

2915

      case PHY_SYSTABLE_SCAN_CODE_MGMT_EP_SET:

16,222,304✔

2916

        code = tlvDecodeObjFromTlv(pTlv, msgToEpSet, &pNode->mgmtEpSet);

16,222,304✔

2917

        break;

16,222,830✔

2918

      case PHY_SYSTABLE_SCAN_CODE_SHOW_REWRITE:

16,223,432✔

2919

        code = tlvDecodeBool(pTlv, &pNode->showRewrite);

16,223,432✔

2920

        break;

16,223,432✔

2921

      case PHY_SYSTABLE_SCAN_CODE_ACCOUNT_ID:

16,223,432✔

2922

        code = tlvDecodeI32(pTlv, &pNode->accountId);

16,223,432✔

2923

        break;

16,223,432✔

2924

      case PHY_SYSTABLE_SCAN_CODE_SYS_INFO:

16,223,432✔

2925

        code = tlvDecodeBool(pTlv, &pNode->sysInfo);

16,223,432✔

2926

        break;

16,223,432✔

2927

      case PHY_SYSTABLE_SCAN_CODE_PRIV_INFO:

16,223,432✔

2928

        code = tlvDecodeU16(pTlv, &pNode->privInfo);

16,223,432✔

2929

      default:

16,223,432✔

2930

        break;

16,223,432✔

2934

  return code;

16,222,622✔

2945

static int32_t physiProjectNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

208,675,617✔

2946

  const SProjectPhysiNode* pNode = (const SProjectPhysiNode*)pObj;

208,675,617✔

2948

  int32_t code = tlvEncodeObj(pEncoder, PHY_PROJECT_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

208,675,617✔

2949

  if (TSDB_CODE_SUCCESS == code) {

208,790,570✔

2950

    code = tlvEncodeObj(pEncoder, PHY_PROJECT_CODE_PROJECTIONS, nodeListToMsg, pNode->pProjections);

208,794,414✔

2952

  if (TSDB_CODE_SUCCESS == code) {

208,785,859✔

2953

    code = tlvEncodeBool(pEncoder, PHY_PROJECT_CODE_MERGE_DATA_BLOCK, pNode->mergeDataBlock);

208,788,820✔

2955

  if (TSDB_CODE_SUCCESS == code) {

208,791,393✔

2956

    code = tlvEncodeBool(pEncoder, PHY_PROJECT_CODE_IGNORE_GROUP_ID, pNode->ignoreGroupId);

208,794,833✔

2958

  if (TSDB_CODE_SUCCESS == code) {

208,795,425✔

2959

    code = tlvEncodeBool(pEncoder, PHY_PROJECT_CODE_INPUT_IGNORE_GROUP, pNode->inputIgnoreGroup);

208,767,609✔

2962

  return code;

208,779,268✔

2965

static int32_t msgToPhysiProjectNode(STlvDecoder* pDecoder, void* pObj) {

146,171,714✔

2966

  SProjectPhysiNode* pNode = (SProjectPhysiNode*)pObj;

146,171,714✔

2968

  int32_t code = TSDB_CODE_SUCCESS;

146,171,714✔

2969

  STlv*   pTlv = NULL;

146,171,714✔

2970

  tlvForEach(pDecoder, pTlv, code) {

877,084,539✔

2971

    switch (pTlv->type) {

730,913,417✔

2972

      case PHY_PROJECT_CODE_BASE_NODE:

146,149,209✔

2973

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

146,149,209✔

2974

        break;

146,181,945✔

2975

      case PHY_PROJECT_CODE_PROJECTIONS:

146,181,426✔

2976

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pProjections);

146,181,426✔

2977

        break;

146,182,451✔

2978

      case PHY_PROJECT_CODE_MERGE_DATA_BLOCK:

146,182,730✔

2979

        code = tlvDecodeBool(pTlv, &pNode->mergeDataBlock);

146,182,730✔

2980

        break;

146,182,275✔

2981

      case PHY_PROJECT_CODE_IGNORE_GROUP_ID:

146,183,383✔

2982

        code = tlvDecodeBool(pTlv, &pNode->ignoreGroupId);

146,183,383✔

2983

        break;

146,183,383✔

2984

      case PHY_PROJECT_CODE_INPUT_IGNORE_GROUP:

146,212,673✔

2985

        code = tlvDecodeBool(pTlv, &pNode->inputIgnoreGroup);

146,212,673✔

2986

        break;

146,182,286✔

2992

  return code;

146,176,878✔

3019

static int32_t physiMergeJoinNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

15,872,579✔

3020

  const SSortMergeJoinPhysiNode* pNode = (const SSortMergeJoinPhysiNode*)pObj;

15,872,579✔

3022

  int32_t code = tlvEncodeObj(pEncoder, PHY_SORT_MERGE_JOIN_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

15,872,579✔

3023

  if (TSDB_CODE_SUCCESS == code) {

15,872,665✔

3024

    code = tlvEncodeEnum(pEncoder, PHY_SORT_MERGE_JOIN_CODE_JOIN_TYPE, pNode->joinType);

15,872,665✔

3026

  if (TSDB_CODE_SUCCESS == code) {

15,872,665✔

3027

    code = tlvEncodeEnum(pEncoder, PHY_SORT_MERGE_JOIN_CODE_SUB_TYPE, pNode->subType);

15,872,665✔

3029

  if (TSDB_CODE_SUCCESS == code) {

15,872,665✔

3030

    code = tlvEncodeObj(pEncoder, PHY_SORT_MERGE_JOIN_CODE_WINDOW_OFFSET, nodeToMsg, pNode->pWindowOffset);

15,872,665✔

3032

  if (TSDB_CODE_SUCCESS == code) {

15,872,665✔

3033

    code = tlvEncodeObj(pEncoder, PHY_SORT_MERGE_JOIN_CODE_JOIN_LIMIT, nodeToMsg, pNode->pJLimit);

15,872,665✔

3035

  if (TSDB_CODE_SUCCESS == code) {

15,872,665✔

3036

    code = tlvEncodeI32(pEncoder, PHY_SORT_MERGE_JOIN_CODE_ASOF_OP, pNode->asofOpType);

15,872,665✔

3038

  if (TSDB_CODE_SUCCESS == code) {

15,872,588✔

3039

    code = tlvEncodeObj(pEncoder, PHY_SORT_MERGE_JOIN_CODE_LEFT_PRIM_EXPR, nodeToMsg, pNode->leftPrimExpr);

15,872,588✔

3041

  if (TSDB_CODE_SUCCESS == code) {

15,872,665✔

3042

    code = tlvEncodeObj(pEncoder, PHY_SORT_MERGE_JOIN_CODE_RIGHT_PRIM_EXPR, nodeToMsg, pNode->rightPrimExpr);

15,872,665✔

3044

  if (TSDB_CODE_SUCCESS == code) {

15,872,665✔

3045

    code = tlvEncodeI32(pEncoder, PHY_SORT_MERGE_JOIN_CODE_LEFT_PRIM_SLOT_ID, pNode->leftPrimSlotId);

15,872,665✔

3047

  if (TSDB_CODE_SUCCESS == code) {

15,872,665✔

3048

    code = tlvEncodeI32(pEncoder, PHY_SORT_MERGE_JOIN_CODE_RIGHT_PRIM_SLOT_ID, pNode->rightPrimSlotId);

15,872,665✔

3050

  if (TSDB_CODE_SUCCESS == code) {

15,872,160✔

3051

    code = tlvEncodeObj(pEncoder, PHY_SORT_MERGE_JOIN_CODE_LEFT_EQ_COLS, nodeListToMsg, pNode->pEqLeft);

15,872,160✔

3053

  if (TSDB_CODE_SUCCESS == code) {

15,872,160✔

3054

    code = tlvEncodeObj(pEncoder, PHY_SORT_MERGE_JOIN_CODE_RIGHT_EQ_COLS, nodeListToMsg, pNode->pEqRight);

15,872,160✔

3056

  if (TSDB_CODE_SUCCESS == code) {

15,871,655✔

3057

    code = tlvEncodeObj(pEncoder, PHY_SORT_MERGE_JOIN_CODE_COL_ON_CONDITIONS, nodeToMsg, pNode->pColOnCond);

15,871,655✔

3059

  if (TSDB_CODE_SUCCESS == code) {

15,871,261✔

3060

    code = tlvEncodeObj(pEncoder, PHY_SORT_MERGE_JOIN_CODE_FULL_ON_CONDITIONS, nodeToMsg, pNode->pFullOnCond);

15,871,261✔

3062

  if (TSDB_CODE_SUCCESS == code) {

15,871,261✔

3063

    code = tlvEncodeObj(pEncoder, PHY_SORT_MERGE_JOIN_CODE_TARGETS, nodeListToMsg, pNode->pTargets);

15,871,184✔

3065

  if (TSDB_CODE_SUCCESS == code) {

15,872,742✔

3066

    code = tlvEncodeI64(pEncoder, PHY_SORT_MERGE_JOIN_CODE_INPUT_ROW_NUM0, pNode->inputStat[0].inputRowNum);

15,872,665✔

3068

  if (TSDB_CODE_SUCCESS == code) {

15,872,742✔

3069

    code = tlvEncodeI64(pEncoder, PHY_SORT_MERGE_JOIN_CODE_INPUT_ROW_NUM1, pNode->inputStat[1].inputRowNum);

15,872,665✔

3071

  if (TSDB_CODE_SUCCESS == code) {

15,872,656✔

3072

    code = tlvEncodeI32(pEncoder, PHY_SORT_MERGE_JOIN_CODE_INPUT_ROW_SIZE0, pNode->inputStat[0].inputRowSize);

15,872,579✔

3074

  if (TSDB_CODE_SUCCESS == code) {

15,872,742✔

3075

    code = tlvEncodeI32(pEncoder, PHY_SORT_MERGE_JOIN_CODE_INPUT_ROW_SIZE1, pNode->inputStat[1].inputRowSize);

15,872,579✔

3077

  if (TSDB_CODE_SUCCESS == code) {

15,872,828✔

3078

    code = tlvEncodeBool(pEncoder, PHY_SORT_MERGE_JOIN_CODE_SEQ_WIN_GROUP, pNode->seqWinGroup);

15,872,665✔

3080

  if (TSDB_CODE_SUCCESS == code) {

15,872,828✔

3081

    code = tlvEncodeBool(pEncoder, PHY_SORT_MERGE_JOIN_CODE_GROUP_JOIN, pNode->grpJoin);

15,872,665✔

3084

  return code;

15,872,665✔

3087

static int32_t msgToPhysiMergeJoinNode(STlvDecoder* pDecoder, void* pObj) {

12,977,992✔

3088

  SSortMergeJoinPhysiNode* pNode = (SSortMergeJoinPhysiNode*)pObj;

12,977,992✔

3090

  int32_t code = TSDB_CODE_SUCCESS;

12,977,992✔

3091

  STlv*   pTlv = NULL;

12,977,992✔

3092

  tlvForEach(pDecoder, pTlv, code) {

190,947,103✔

3093

    switch (pTlv->type) {

177,969,111✔

3094

      case PHY_SORT_MERGE_JOIN_CODE_BASE_NODE:

12,977,487✔

3095

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

12,977,487✔

3096

        break;

12,977,992✔

3097

      case PHY_SORT_MERGE_JOIN_CODE_JOIN_TYPE:

12,977,992✔

3098

        code = tlvDecodeEnum(pTlv, &pNode->joinType, sizeof(pNode->joinType));

12,977,992✔

3099

        break;

12,977,992✔

3100

      case PHY_SORT_MERGE_JOIN_CODE_SUB_TYPE:

12,977,992✔

3101

        code = tlvDecodeEnum(pTlv, &pNode->subType, sizeof(pNode->subType));

12,977,992✔

3102

        break;

12,977,992✔

3103

      case PHY_SORT_MERGE_JOIN_CODE_WINDOW_OFFSET:

327,012✔

3104

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pWindowOffset);

327,012✔

3105

        break;

327,012✔

3106

      case PHY_SORT_MERGE_JOIN_CODE_JOIN_LIMIT:

160,631✔

3107

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pJLimit);

160,631✔

3108

        break;

160,631✔

3109

      case PHY_SORT_MERGE_JOIN_CODE_ASOF_OP:

12,977,992✔

3110

        code = tlvDecodeI32(pTlv, &pNode->asofOpType);

12,977,992✔

3111

        break;

12,977,992✔

3112

      case PHY_SORT_MERGE_JOIN_CODE_LEFT_PRIM_EXPR:

311,103✔

3113

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->leftPrimExpr);

311,103✔

3114

        break;

311,103✔

3115

      case PHY_SORT_MERGE_JOIN_CODE_RIGHT_PRIM_EXPR:

275,418✔

3116

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->rightPrimExpr);

275,418✔

3117

        break;

275,418✔

3118

      case PHY_SORT_MERGE_JOIN_CODE_LEFT_PRIM_SLOT_ID:

12,977,992✔

3119

        code = tlvDecodeI32(pTlv, &pNode->leftPrimSlotId);

12,977,992✔

3120

        break;

12,977,464✔

3121

      case PHY_SORT_MERGE_JOIN_CODE_RIGHT_PRIM_SLOT_ID:

12,977,992✔

3122

        code = tlvDecodeI32(pTlv, &pNode->rightPrimSlotId);

12,977,992✔

3123

        break;

12,977,992✔

3124

      case PHY_SORT_MERGE_JOIN_CODE_LEFT_EQ_COLS:

101,539✔

3125

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pEqLeft);

101,539✔

3126

        break;

101,539✔

3127

      case PHY_SORT_MERGE_JOIN_CODE_RIGHT_EQ_COLS:

101,539✔

3128

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pEqRight);

101,539✔

3129

        break;

101,539✔

3130

      case PHY_SORT_MERGE_JOIN_CODE_COL_ON_CONDITIONS:

3,957,513✔

3131

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pColOnCond);

3,957,513✔

3132

        break;

3,957,513✔

3133

      case PHY_SORT_MERGE_JOIN_CODE_FULL_ON_CONDITIONS:

4,020,988✔

3134

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pFullOnCond);

4,020,988✔

3135

        break;

4,020,988✔

3136

      case PHY_SORT_MERGE_JOIN_CODE_TARGETS:

12,977,487✔

3137

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pTargets);

12,977,487✔

3138

        break;

12,977,992✔

3139

      case PHY_SORT_MERGE_JOIN_CODE_INPUT_ROW_NUM0:

12,977,992✔

3140

        code = tlvDecodeI64(pTlv, &pNode->inputStat[0].inputRowNum);

12,977,992✔

3141

        break;

12,977,992✔

3142

      case PHY_SORT_MERGE_JOIN_CODE_INPUT_ROW_NUM1:

12,977,992✔

3143

        code = tlvDecodeI64(pTlv, &pNode->inputStat[1].inputRowNum);

12,977,992✔

3144

        break;

12,977,992✔

3145

      case PHY_SORT_MERGE_JOIN_CODE_INPUT_ROW_SIZE0:

12,977,992✔

3146

        code = tlvDecodeI32(pTlv, &pNode->inputStat[0].inputRowSize);

12,977,992✔

3147

        break;

12,977,992✔

3148

      case PHY_SORT_MERGE_JOIN_CODE_INPUT_ROW_SIZE1:

12,977,992✔

3149

        code = tlvDecodeI32(pTlv, &pNode->inputStat[1].inputRowSize);

12,977,992✔

3150

        break;

12,977,992✔

3151

      case PHY_SORT_MERGE_JOIN_CODE_SEQ_WIN_GROUP:

12,977,992✔

3152

        code = tlvDecodeBool(pTlv, &pNode->seqWinGroup);

12,977,992✔

3153

        break;

12,977,992✔

3154

      case PHY_SORT_MERGE_JOIN_CODE_GROUP_JOIN:

12,978,474✔

3155

        code = tlvDecodeBool(pTlv, &pNode->grpJoin);

12,978,474✔

3156

        break;

12,977,992✔

3162

  return code;

12,978,497✔

3189

static int32_t physiHashJoinNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

1,224,398✔

3190

  const SHashJoinPhysiNode* pNode = (const SHashJoinPhysiNode*)pObj;

1,224,398✔

3192

  int32_t code = tlvEncodeObj(pEncoder, PHY_HASH_JOIN_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

1,224,398✔

3193

  if (TSDB_CODE_SUCCESS == code) {

1,224,398✔

3194

    code = tlvEncodeEnum(pEncoder, PHY_HASH_JOIN_CODE_JOIN_TYPE, pNode->joinType);

1,224,398✔

3196

  if (TSDB_CODE_SUCCESS == code) {

1,224,398✔

3197

    code = tlvEncodeEnum(pEncoder, PHY_HASH_JOIN_CODE_JOIN_STYPE, pNode->subType);

1,224,398✔

3199

  if (TSDB_CODE_SUCCESS == code) {

1,224,398✔

3200

    code = tlvEncodeObj(pEncoder, PHY_HASH_JOIN_CODE_ON_LEFT_COLUMN, nodeListToMsg, pNode->pOnLeft);

1,224,398✔

3202

  if (TSDB_CODE_SUCCESS == code) {

1,224,398✔

3203

    code = tlvEncodeObj(pEncoder, PHY_HASH_JOIN_CODE_ON_RIGHT_COLUMN, nodeListToMsg, pNode->pOnRight);

1,224,398✔

3205

  if (TSDB_CODE_SUCCESS == code) {

1,224,398✔

3206

    code = tlvEncodeObj(pEncoder, PHY_HASH_JOIN_CODE_LEFT_PRIM_EXPR, nodeToMsg, pNode->leftPrimExpr);

1,224,398✔

3208

  if (TSDB_CODE_SUCCESS == code) {

1,224,398✔

3209

    code = tlvEncodeObj(pEncoder, PHY_HASH_JOIN_CODE_RIGHT_PRIM_EXPR, nodeToMsg, pNode->rightPrimExpr);

1,224,398✔

3211

  if (TSDB_CODE_SUCCESS == code) {

1,224,398✔

3212

    code = tlvEncodeI32(pEncoder, PHY_HASH_JOIN_CODE_LEFT_PRIM_SLOTID, pNode->leftPrimSlotId);

1,224,398✔

3214

  if (TSDB_CODE_SUCCESS == code) {

1,224,398✔

3215

    code = tlvEncodeI32(pEncoder, PHY_HASH_JOIN_CODE_RIGHT_PRIM_SLOTID, pNode->rightPrimSlotId);

1,224,398✔

3217

  if (TSDB_CODE_SUCCESS == code) {

1,224,398✔

3218

    code = tlvEncodeI32(pEncoder, PHY_HASH_JOIN_CODE_TIME_RANGE_TARGET, pNode->timeRangeTarget);

1,224,398✔

3220

  if (TSDB_CODE_SUCCESS == code) {

1,224,398✔

3221

    code = tlvEncodeObj(pEncoder, PHY_HASH_JOIN_CODE_ON_CONDITIONS, nodeToMsg, pNode->pFullOnCond);

1,224,398✔

3223

  if (TSDB_CODE_SUCCESS == code) {

1,224,398✔

3224

    code = tlvEncodeObj(pEncoder, PHY_HASH_JOIN_CODE_TARGETS, nodeListToMsg, pNode->pTargets);

1,224,398✔

3226

  if (TSDB_CODE_SUCCESS == code) {

1,224,398✔

3227

    code = tlvEncodeI64(pEncoder, PHY_HASH_JOIN_CODE_INPUT_ROW_NUM0, pNode->inputStat[0].inputRowNum);

1,224,398✔

3229

  if (TSDB_CODE_SUCCESS == code) {

1,224,398✔

3230

    code = tlvEncodeI64(pEncoder, PHY_HASH_JOIN_CODE_INPUT_ROW_NUM1, pNode->inputStat[1].inputRowNum);

1,224,398✔

3232

  if (TSDB_CODE_SUCCESS == code) {

1,224,398✔

3233

    code = tlvEncodeI32(pEncoder, PHY_HASH_JOIN_CODE_INPUT_ROW_SIZE0, pNode->inputStat[0].inputRowSize);

1,224,398✔

3235

  if (TSDB_CODE_SUCCESS == code) {

1,224,398✔

3236

    code = tlvEncodeI32(pEncoder, PHY_HASH_JOIN_CODE_INPUT_ROW_SIZE1, pNode->inputStat[1].inputRowSize);

1,224,398✔

3238

  if (TSDB_CODE_SUCCESS == code) {

1,224,398✔

3239

    code = tlvEncodeObj(pEncoder, PHY_HASH_JOIN_CODE_LEFT_ON_COND, nodeToMsg, pNode->pLeftOnCond);

1,224,398✔

3241

  if (TSDB_CODE_SUCCESS == code) {

1,224,398✔

3242

    code = tlvEncodeObj(pEncoder, PHY_HASH_JOIN_CODE_RIGHT_ON_COND, nodeToMsg, pNode->pRightOnCond);

1,224,398✔

3244

  if (TSDB_CODE_SUCCESS == code) {

1,224,398✔

3245

    code = tlvEncodeI64(pEncoder, PHY_HASH_JOIN_CODE_TIME_RANGE_SKEY, pNode->timeRange.skey);

1,224,398✔

3247

  if (TSDB_CODE_SUCCESS == code) {

1,224,398✔

3248

    code = tlvEncodeI64(pEncoder, PHY_HASH_JOIN_CODE_TIME_RANGE_EKEY, pNode->timeRange.ekey);

1,224,398✔

3251

  return code;

1,224,398✔

3255

static int32_t msgToPhysiHashJoinNode(STlvDecoder* pDecoder, void* pObj) {

1,224,119✔

3256

  SHashJoinPhysiNode* pNode = (SHashJoinPhysiNode*)pObj;

1,224,119✔

3258

  int32_t code = TSDB_CODE_SUCCESS;

1,224,119✔

3259

  STlv*   pTlv = NULL;

1,224,119✔

3260

  tlvForEach(pDecoder, pTlv, code) {

19,585,904✔

3261

    switch (pTlv->type) {

18,361,785✔

3262

      case PHY_HASH_JOIN_CODE_BASE_NODE:

1,224,119✔

3263

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

1,224,119✔

3264

        break;

1,224,119✔

3265

      case PHY_HASH_JOIN_CODE_JOIN_TYPE:

1,224,119✔

3266

        code = tlvDecodeEnum(pTlv, &pNode->joinType, sizeof(pNode->joinType));

1,224,119✔

3267

        break;

1,224,119✔

3268

      case PHY_HASH_JOIN_CODE_JOIN_STYPE:

1,224,119✔

3269

        code = tlvDecodeEnum(pTlv, &pNode->subType, sizeof(pNode->subType));

1,224,119✔

3270

        break;

1,224,119✔

3271

      case PHY_HASH_JOIN_CODE_ON_LEFT_COLUMN:

1,224,119✔

3272

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pOnLeft);

1,224,119✔

3273

        break;

1,224,119✔

3274

      case PHY_HASH_JOIN_CODE_ON_RIGHT_COLUMN:

1,224,119✔

3275

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pOnRight);

1,224,119✔

3276

        break;

1,224,119✔

3283

      case PHY_HASH_JOIN_CODE_LEFT_PRIM_SLOTID:

1,224,119✔

3284

        code = tlvDecodeI32(pTlv, &pNode->leftPrimSlotId);

1,224,119✔

3285

        break;

1,224,119✔

3286

      case PHY_HASH_JOIN_CODE_RIGHT_PRIM_SLOTID:

1,224,119✔

3287

        code = tlvDecodeI32(pTlv, &pNode->rightPrimSlotId);

1,224,119✔

3288

        break;

1,224,119✔

3289

      case PHY_HASH_JOIN_CODE_TIME_RANGE_TARGET:

1,224,119✔

3290

        code = tlvDecodeI32(pTlv, &pNode->timeRangeTarget);

1,224,119✔

3291

        break;

1,224,119✔

3295

      case PHY_HASH_JOIN_CODE_TARGETS:

1,224,119✔

3296

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pTargets);

1,224,119✔

3297

        break;

1,224,119✔

3298

      case PHY_HASH_JOIN_CODE_INPUT_ROW_NUM0:

1,224,119✔

3299

        code = tlvDecodeI64(pTlv, &pNode->inputStat[0].inputRowNum);

1,224,119✔

3300

        break;

1,224,119✔

3301

      case PHY_HASH_JOIN_CODE_INPUT_ROW_NUM1:

1,224,119✔

3302

        code = tlvDecodeI64(pTlv, &pNode->inputStat[1].inputRowNum);

1,224,119✔

3303

        break;

1,224,119✔

3304

      case PHY_HASH_JOIN_CODE_INPUT_ROW_SIZE0:

1,224,119✔

3305

        code = tlvDecodeI32(pTlv, &pNode->inputStat[0].inputRowSize);

1,224,119✔

3306

        break;

1,224,119✔

3307

      case PHY_HASH_JOIN_CODE_INPUT_ROW_SIZE1:

1,224,119✔

3308

        code = tlvDecodeI32(pTlv, &pNode->inputStat[1].inputRowSize);

1,224,119✔

3309

        break;

1,224,119✔

3316

      case PHY_HASH_JOIN_CODE_TIME_RANGE_SKEY:

1,224,119✔

3317

        code = tlvDecodeI64(pTlv, &pNode->timeRange.skey);

1,224,119✔

3318

        break;

1,224,119✔

3319

      case PHY_HASH_JOIN_CODE_TIME_RANGE_EKEY:

1,224,119✔

3320

        code = tlvDecodeI64(pTlv, &pNode->timeRange.ekey);

1,224,119✔

3321

        break;

1,224,119✔

3327

  return code;

1,224,119✔

3341

static int32_t physiAggNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

163,522,851✔

3342

  const SAggPhysiNode* pNode = (const SAggPhysiNode*)pObj;

163,522,851✔

3344

  int32_t code = tlvEncodeObj(pEncoder, PHY_AGG_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

163,522,851✔

3345

  if (TSDB_CODE_SUCCESS == code) {

163,633,521✔

3346

    code = tlvEncodeObj(pEncoder, PHY_AGG_CODE_EXPR, nodeListToMsg, pNode->pExprs);

163,637,670✔

3348

  if (TSDB_CODE_SUCCESS == code) {

163,539,049✔

3349

    code = tlvEncodeObj(pEncoder, PHY_AGG_CODE_GROUP_KEYS, nodeListToMsg, pNode->pGroupKeys);

163,523,830✔

3351

  if (TSDB_CODE_SUCCESS == code) {

163,547,277✔

3352

    code = tlvEncodeObj(pEncoder, PHY_AGG_CODE_AGG_FUNCS, nodeListToMsg, pNode->pAggFuncs);

163,534,197✔

3354

  if (TSDB_CODE_SUCCESS == code) {

163,640,566✔

3355

    code = tlvEncodeBool(pEncoder, PHY_AGG_CODE_MERGE_DATA_BLOCK, pNode->mergeDataBlock);

163,627,623✔

3357

  if (TSDB_CODE_SUCCESS == code) {

163,655,906✔

3358

    code = tlvEncodeBool(pEncoder, PHY_AGG_CODE_GROUP_KEY_OPTIMIZE, pNode->groupKeyOptimized);

163,643,123✔

3360

  if (TSDB_CODE_SUCCESS == code) {

163,651,274✔

3361

    code = tlvEncodeBool(pEncoder, PHY_AGG_CODE_HAS_COUNT_LIKE_FUNCS, pNode->hasCountLikeFunc);

163,634,395✔

3364

  return code;

163,640,762✔

3367

static int32_t msgToPhysiAggNode(STlvDecoder* pDecoder, void* pObj) {

127,389,478✔

3368

  SAggPhysiNode* pNode = (SAggPhysiNode*)pObj;

127,389,478✔

3370

  int32_t code = TSDB_CODE_SUCCESS;

127,389,478✔

3371

  STlv*   pTlv = NULL;

127,389,478✔

3372

  tlvForEach(pDecoder, pTlv, code) {

803,066,110✔

3373

    switch (pTlv->type) {

675,674,828✔

3374

      case PHY_AGG_CODE_BASE_NODE:

127,379,682✔

3375

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

127,379,682✔

3376

        break;

127,397,956✔

3377

      case PHY_AGG_CODE_EXPR:

34,559,652✔

3378

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pExprs);

34,559,652✔

3379

        break;

34,559,506✔

3380

      case PHY_AGG_CODE_GROUP_KEYS:

32,028,380✔

3381

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pGroupKeys);

32,028,380✔

3382

        break;

32,027,854✔

3383

      case PHY_AGG_CODE_AGG_FUNCS:

99,476,803✔

3384

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pAggFuncs);

99,476,803✔

3385

        break;

99,489,413✔

3386

      case PHY_AGG_CODE_MERGE_DATA_BLOCK:

127,391,329✔

3387

        code = tlvDecodeBool(pTlv, &pNode->mergeDataBlock);

127,391,329✔

3388

        break;

127,398,640✔

3389

      case PHY_AGG_CODE_GROUP_KEY_OPTIMIZE:

127,400,361✔

3390

        code = tlvDecodeBool(pTlv, &pNode->groupKeyOptimized);

127,400,361✔

3391

        break;

127,400,176✔

3392

      case PHY_AGG_CODE_HAS_COUNT_LIKE_FUNCS:

127,434,884✔

3393

        code = tlvDecodeBool(pTlv, &pNode->hasCountLikeFunc);

127,434,884✔

3394

        break;

127,400,361✔

3400

  return code;

127,400,449✔

3415

static int32_t physiExchangeNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

142,571,908✔

3416

  const SExchangePhysiNode* pNode = (const SExchangePhysiNode*)pObj;

142,571,908✔

3418

  int32_t code = tlvEncodeObj(pEncoder, PHY_EXCHANGE_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

142,571,908✔

3419

  if (TSDB_CODE_SUCCESS == code) {

142,575,361✔

3420

    code = tlvEncodeI32(pEncoder, PHY_EXCHANGE_CODE_SRC_START_GROUP_ID, pNode->srcStartGroupId);

142,575,428✔

3422

  if (TSDB_CODE_SUCCESS == code) {

142,575,074✔

3423

    code = tlvEncodeI32(pEncoder, PHY_EXCHANGE_CODE_SRC_END_GROUP_ID, pNode->srcEndGroupId);

142,574,514✔

3425

  if (TSDB_CODE_SUCCESS == code && pNode->childrenVgIds) {

142,575,694✔

3426

    code = tlvEncodeObj(pEncoder, PHY_EXCHANGE_CODE_CHILDREN_VGIDS, SArrayToMsg, pNode->childrenVgIds);

142,575,134✔

3428

  if (TSDB_CODE_SUCCESS == code) {

142,575,015✔

3429

    code = tlvEncodeBool(pEncoder, PHY_EXCHANGE_CODE_SINGLE_CHANNEL, pNode->grpSingleChannel);

142,574,599✔

3431

  if (TSDB_CODE_SUCCESS == code) {

142,575,614✔

3432

    code = tlvEncodeObj(pEncoder, PHY_EXCHANGE_CODE_SRC_ENDPOINTS, nodeListToMsg, pNode->pSrcEndPoints);

142,575,265✔

3434

  if (TSDB_CODE_SUCCESS == code) {

142,575,065✔

3435

    code = tlvEncodeBool(pEncoder, PHY_EXCHANGE_CODE_SEQ_RECV_DATA, pNode->seqRecvData);

142,574,879✔

3437

  if (TSDB_CODE_SUCCESS == code) {

142,575,320✔

3438

    code = tlvEncodeBool(pEncoder, PHY_EXCHANGE_CODE_DYN_TBNAME, pNode->dynTbname);

142,575,134✔

3440

  if (TSDB_CODE_SUCCESS == code) {

142,574,160✔

3441

    code = tlvEncodeBool(pEncoder, PHY_EXCHANGE_CODE_SINGLE_SOURCE, pNode->singleSrc);

142,574,000✔

3444

  return code;

142,575,115✔

3447

static int32_t msgToPhysiExchangeNode(STlvDecoder* pDecoder, void* pObj) {

110,468,216✔

3448

  SExchangePhysiNode* pNode = (SExchangePhysiNode*)pObj;

110,468,216✔

3450

  int32_t code = TSDB_CODE_SUCCESS;

110,468,216✔

3451

  STlv*   pTlv = NULL;

110,468,216✔

3452

  tlvForEach(pDecoder, pTlv, code) {

1,104,690,856✔

3453

    switch (pTlv->type) {

994,220,988✔

3454

      case PHY_EXCHANGE_CODE_BASE_NODE:

110,468,745✔

3455

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

110,468,745✔

3456

        break;

110,468,754✔

3457

      case PHY_EXCHANGE_CODE_SRC_START_GROUP_ID:

110,469,283✔

3458

        code = tlvDecodeI32(pTlv, &pNode->srcStartGroupId);

110,469,283✔

3459

        break;

110,469,283✔

3460

      case PHY_EXCHANGE_CODE_SRC_END_GROUP_ID:

110,469,283✔

3461

        code = tlvDecodeI32(pTlv, &pNode->srcEndGroupId);

110,469,283✔

3462

        break;

110,469,283✔

3463

      case PHY_EXCHANGE_CODE_CHILDREN_VGIDS:

110,469,283✔

3464

        code = msgToSArray(pTlv, (void**)&pNode->childrenVgIds);

110,469,283✔

3465

        break;

110,468,905✔

3466

      case PHY_EXCHANGE_CODE_SINGLE_CHANNEL:

110,469,283✔

3467

        code = tlvDecodeBool(pTlv, &pNode->grpSingleChannel);

110,469,283✔

3468

        break;

110,468,216✔

3469

      case PHY_EXCHANGE_CODE_SRC_ENDPOINTS:

110,469,283✔

3470

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pSrcEndPoints);

110,469,283✔

3471

        break;

110,469,283✔

3472

      case PHY_EXCHANGE_CODE_SEQ_RECV_DATA:

110,469,283✔

3473

        code = tlvDecodeBool(pTlv, &pNode->seqRecvData);

110,469,283✔

3474

        break;

110,469,283✔

3475

      case PHY_EXCHANGE_CODE_DYN_TBNAME:

110,469,283✔

3476

        code = tlvDecodeBool(pTlv, &pNode->dynTbname);

110,469,283✔

3477

        break;

110,469,283✔

3478

      case PHY_EXCHANGE_CODE_SINGLE_SOURCE:

110,467,800✔

3479

        code = tlvDecodeBool(pTlv, &pNode->singleSrc);

110,467,800✔

3480

        break;

110,469,283✔

3486

  return code;

110,477,287✔

3501

static int32_t physiMergeNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

18,263,404✔

3502

  const SMergePhysiNode* pNode = (const SMergePhysiNode*)pObj;

18,263,404✔

3504

  int32_t code = tlvEncodeObj(pEncoder, PHY_MERGE_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

18,263,404✔

3505

  if (TSDB_CODE_SUCCESS == code) {

18,263,538✔

3506

    code = tlvEncodeObj(pEncoder, PHY_MERGE_CODE_MERGE_KEYS, nodeListToMsg, pNode->pMergeKeys);

18,263,538✔

3508

  if (TSDB_CODE_SUCCESS == code) {

18,263,538✔

3509

    code = tlvEncodeObj(pEncoder, PHY_MERGE_CODE_TARGETS, nodeListToMsg, pNode->pTargets);

18,263,538✔

3511

  if (TSDB_CODE_SUCCESS == code) {

18,263,538✔

3512

    code = tlvEncodeI32(pEncoder, PHY_MERGE_CODE_NUM_OF_CHANNELS, pNode->numOfChannels);

18,263,538✔

3514

  if (TSDB_CODE_SUCCESS == code) {

18,263,538✔

3515

    code = tlvEncodeI32(pEncoder, PHY_MERGE_CODE_SRC_GROUP_ID, pNode->srcGroupId);

18,263,471✔

3517

  if (TSDB_CODE_SUCCESS == code) {

18,263,605✔

3518

    code = tlvEncodeBool(pEncoder, PHY_MERGE_CODE_GROUP_SORT, pNode->groupSort);

18,263,538✔

3520

  if (TSDB_CODE_SUCCESS == code) {

18,263,605✔

3521

    code = tlvEncodeBool(pEncoder, PHY_MERGE_CODE_IGNORE_GROUP_ID, pNode->ignoreGroupId);

18,263,538✔

3523

  if (TSDB_CODE_SUCCESS == code) {

18,263,605✔

3524

    code = tlvEncodeBool(pEncoder, PHY_MERGE_CODE_INPUT_WITH_GROUP_ID, pNode->inputWithGroupId);

18,263,471✔

3526

  if (TSDB_CODE_SUCCESS == code) {

18,263,672✔

3527

    code = tlvEncodeI32(pEncoder, PHY_MERGE_CODE_TYPE, pNode->type);

18,263,471✔

3530

  return code;

18,263,538✔

3533

static int32_t msgToPhysiMergeNode(STlvDecoder* pDecoder, void* pObj) {

13,819,489✔

3534

  SMergePhysiNode* pNode = (SMergePhysiNode*)pObj;

13,819,489✔

3536

  int32_t code = TSDB_CODE_SUCCESS;

13,819,489✔

3537

  STlv*   pTlv = NULL;

13,819,489✔

3538

  tlvForEach(pDecoder, pTlv, code) {

137,587,711✔

3539

    switch (pTlv->type) {

123,768,222✔

3540

      case PHY_MERGE_CODE_BASE_NODE:

13,819,489✔

3541

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

13,819,489✔

3542

        break;

13,819,489✔

3543

      case PHY_MERGE_CODE_MERGE_KEYS:

13,212,310✔

3544

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pMergeKeys);

13,212,310✔

3545

        break;

13,212,310✔

3546

      case PHY_MERGE_CODE_TARGETS:

13,819,489✔

3547

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pTargets);

13,819,489✔

3548

        break;

13,819,489✔

3549

      case PHY_MERGE_CODE_NUM_OF_CHANNELS:

13,819,489✔

3550

        code = tlvDecodeI32(pTlv, &pNode->numOfChannels);

13,819,489✔

3551

        break;

13,819,489✔

3552

      case PHY_MERGE_CODE_SRC_GROUP_ID:

13,819,489✔

3553

        code = tlvDecodeI32(pTlv, &pNode->srcGroupId);

13,819,489✔

3554

        break;

13,819,489✔

3555

      case PHY_MERGE_CODE_GROUP_SORT:

13,819,489✔

3556

        code = tlvDecodeBool(pTlv, &pNode->groupSort);

13,819,489✔

3557

        break;

13,819,489✔

3558

      case PHY_MERGE_CODE_IGNORE_GROUP_ID:

13,819,489✔

3559

        code = tlvDecodeBool(pTlv, &pNode->ignoreGroupId);

13,819,489✔

3560

        break;

13,819,489✔

3561

      case PHY_MERGE_CODE_INPUT_WITH_GROUP_ID:

13,819,489✔

3562

        code = tlvDecodeBool(pTlv, &pNode->inputWithGroupId);

13,819,489✔

3563

        break;

13,819,489✔

3564

      case PHY_MERGE_CODE_TYPE:

13,819,489✔

3565

        code = tlvDecodeI32(pTlv, (int32_t*)&pNode->type);

13,819,489✔

3566

        break;

13,819,489✔

3572

  return code;

13,819,489✔

3584

static int32_t physiSortNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

53,423,389✔

3585

  const SSortPhysiNode* pNode = (const SSortPhysiNode*)pObj;

53,423,389✔

3587

  int32_t code = tlvEncodeObj(pEncoder, PHY_SORT_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

53,423,389✔

3588

  if (TSDB_CODE_SUCCESS == code) {

53,446,043✔

3589

    code = tlvEncodeObj(pEncoder, PHY_SORT_CODE_EXPR, nodeListToMsg, pNode->pExprs);

53,446,165✔

3591

  if (TSDB_CODE_SUCCESS == code) {

53,436,806✔

3592

    code = tlvEncodeObj(pEncoder, PHY_SORT_CODE_SORT_KEYS, nodeListToMsg, pNode->pSortKeys);

53,428,571✔

3594

  if (TSDB_CODE_SUCCESS == code) {

53,454,949✔

3595

    code = tlvEncodeObj(pEncoder, PHY_SORT_CODE_TARGETS, nodeListToMsg, pNode->pTargets);

53,446,851✔

3597

  if (TSDB_CODE_SUCCESS == code) {

53,455,492✔

3598

    code = tlvEncodeBool(pEncoder, PHY_SORT_CODE_CALC_GROUPID, pNode->calcGroupId);

53,447,487✔

3600

  if (TSDB_CODE_SUCCESS == code) {

53,455,898✔

3601

    code = tlvEncodeBool(pEncoder, PHY_SORT_CODE_EXCLUDE_PK_COL, pNode->excludePkCol);

53,447,893✔

3604

  return code;

53,448,078✔

3607

static int32_t msgToPhysiSortNode(STlvDecoder* pDecoder, void* pObj) {

32,793,393✔

3608

  SSortPhysiNode* pNode = (SSortPhysiNode*)pObj;

32,793,393✔

3610

  int32_t code = TSDB_CODE_SUCCESS;

32,793,393✔

3611

  STlv*   pTlv = NULL;

32,793,393✔

3612

  tlvForEach(pDecoder, pTlv, code) {

197,209,348✔

3613

    switch (pTlv->type) {

164,416,284✔

3614

      case PHY_SORT_CODE_BASE_NODE:

32,792,983✔

3615

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

32,792,983✔

3616

        break;

32,794,981✔

3617

      case PHY_SORT_CODE_EXPR:

439,678✔

3618

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pExprs);

439,678✔

3619

        break;

439,678✔

3620

      case PHY_SORT_CODE_SORT_KEYS:

32,794,836✔

3621

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pSortKeys);

32,794,836✔

3622

        break;

32,793,039✔

3623

      case PHY_SORT_CODE_TARGETS:

32,795,507✔

3624

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pTargets);

32,795,507✔

3625

        break;

32,795,507✔

3626

      case PHY_SORT_CODE_CALC_GROUPID:

32,795,507✔

3627

        code = tlvDecodeBool(pTlv, &pNode->calcGroupId);

32,795,507✔

3628

        break;

32,795,507✔

3629

      case PHY_SORT_CODE_EXCLUDE_PK_COL:

32,795,507✔

3630

        code = tlvDecodeBool(pTlv, &pNode->excludePkCol);

32,795,507✔

3631

      default:

32,795,507✔

3632

        break;

32,795,507✔

3636

  return code;

32,797,697✔

3655

static int32_t physiWindowNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

22,441,504✔

3656

  const SWindowPhysiNode* pNode = (const SWindowPhysiNode*)pObj;

22,441,504✔

3658

  int32_t code = tlvEncodeObj(pEncoder, PHY_WINDOW_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

22,441,504✔

3659

  if (TSDB_CODE_SUCCESS == code) {

22,457,741✔

3660

    code = tlvEncodeObj(pEncoder, PHY_WINDOW_CODE_EXPR, nodeListToMsg, pNode->pExprs);

22,457,671✔

3662

  if (TSDB_CODE_SUCCESS == code) {

22,452,668✔

3663

    code = tlvEncodeObj(pEncoder, PHY_WINDOW_CODE_FUNCS, nodeListToMsg, pNode->pFuncs);

22,452,682✔

3665

  if (TSDB_CODE_SUCCESS == code) {

22,457,012✔

3666

    code = tlvEncodeObj(pEncoder, PHY_WINDOW_CODE_TS_PK, nodeToMsg, pNode->pTspk);

22,457,212✔

3668

  if (TSDB_CODE_SUCCESS == code) {

22,458,090✔

3669

    code = tlvEncodeObj(pEncoder, PHY_WINDOW_CODE_TS_END, nodeToMsg, pNode->pTsEnd);

22,457,876✔

3671

  if (TSDB_CODE_SUCCESS == code) {

22,457,380✔

3672

    code = tlvEncodeI8(pEncoder, PHY_WINDOW_CODE_TRIGGER_TYPE, pNode->unusedParam1);

22,457,408✔

3674

  if (TSDB_CODE_SUCCESS == code) {

22,458,185✔

3675

    code = tlvEncodeI64(pEncoder, PHY_WINDOW_CODE_WATERMARK, pNode->unusedParam2);

22,458,213✔

3677

  if (TSDB_CODE_SUCCESS == code) {

22,457,593✔

3678

    code = tlvEncodeI64(pEncoder, PHY_WINDOW_CODE_DELETE_MARK, pNode->unusedParam3);

22,457,621✔

3680

  if (TSDB_CODE_SUCCESS == code) {

22,457,880✔

3681

    code = tlvEncodeI8(pEncoder, PHY_WINDOW_CODE_IG_EXPIRED, pNode->unusedParam4);

22,457,105✔

3683

  if (TSDB_CODE_SUCCESS == code) {

22,459,362✔

3684

    code = tlvEncodeBool(pEncoder, PHY_WINDOW_CODE_MERGE_DATA_BLOCK, pNode->mergeDataBlock);

22,458,654✔

3686

  if (TSDB_CODE_SUCCESS == code) {

22,458,163✔

3687

    code = tlvEncodeI8(pEncoder, PHY_WINDOW_CODE_INDEF_ROWS_FUNC, pNode->indefRowsFunc);

22,457,455✔

3690

  return code;

22,455,661✔

3693

static int32_t msgToPhysiWindowNode(STlvDecoder* pDecoder, void* pObj) {

8,493,449✔

3694

  SWindowPhysiNode* pNode = (SWindowPhysiNode*)pObj;

8,493,449✔

3696

  int32_t code = TSDB_CODE_SUCCESS;

8,493,449✔

3697

  STlv*   pTlv = NULL;

8,493,449✔

3698

  tlvForEach(pDecoder, pTlv, code) {

86,345,049✔

3699

    switch (pTlv->type) {

77,850,018✔

3700

      case PHY_WINDOW_CODE_BASE_NODE:

8,493,518✔

3701

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

8,493,518✔

3702

        break;

8,494,927✔

3703

      case PHY_WINDOW_CODE_EXPR:

912,626✔

3704

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pExprs);

912,626✔

3705

        break;

912,626✔

3706

      case PHY_WINDOW_CODE_FUNCS:

8,418,226✔

3707

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pFuncs);

8,418,226✔

3708

        break;

8,418,226✔

3709

      case PHY_WINDOW_CODE_TS_PK:

8,494,927✔

3710

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pTspk);

8,494,927✔

3711

        break;

8,494,927✔

3712

      case PHY_WINDOW_CODE_TS_END:

560,937✔

3713

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pTsEnd);

560,937✔

3714

        break;

560,937✔

3715

      case PHY_WINDOW_CODE_TRIGGER_TYPE:

8,494,927✔

3716

        code = tlvDecodeI8(pTlv, &pNode->unusedParam1);

8,494,927✔

3717

        break;

8,494,927✔

3718

      case PHY_WINDOW_CODE_WATERMARK:

8,494,927✔

3719

        code = tlvDecodeI64(pTlv, &pNode->unusedParam2);

8,494,927✔

3720

        break;

8,494,927✔

3721

      case PHY_WINDOW_CODE_DELETE_MARK:

8,494,927✔

3722

        code = tlvDecodeI64(pTlv, &pNode->unusedParam3);

8,494,927✔

3723

        break;

8,494,927✔

3724

      case PHY_WINDOW_CODE_IG_EXPIRED:

8,494,927✔

3725

        code = tlvDecodeI8(pTlv, &pNode->unusedParam4);

8,494,927✔

3726

        break;

8,494,927✔

3727

      case PHY_WINDOW_CODE_MERGE_DATA_BLOCK:

8,494,927✔

3728

        code = tlvDecodeBool(pTlv, &pNode->mergeDataBlock);

8,494,927✔

3729

        break;

8,494,927✔

3730

      case PHY_WINDOW_CODE_INDEF_ROWS_FUNC:

8,495,149✔

3731

        code = tlvDecodeI8(pTlv, &pNode->indefRowsFunc);

8,495,149✔

3732

        break;

8,494,927✔

3738

  return code;

8,497,335✔

3743

static int32_t physiIntervalNodeInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {

13,335,176✔

3744

  const SIntervalPhysiNode* pNode = (const SIntervalPhysiNode*)pObj;

13,335,176✔

3746

  int32_t code = tlvEncodeValueI64(pEncoder, pNode->interval);

13,335,176✔

3747

  if (TSDB_CODE_SUCCESS == code) {

13,342,108✔

3748

    code = tlvEncodeValueI64(pEncoder, pNode->offset);

13,342,250✔

3750

  if (TSDB_CODE_SUCCESS == code) {

13,341,850✔

3751

    code = tlvEncodeValueI64(pEncoder, pNode->sliding);

13,342,055✔

3753

  if (TSDB_CODE_SUCCESS == code) {

13,342,707✔

3754

    code = tlvEncodeValueI8(pEncoder, pNode->intervalUnit);

13,342,749✔

3756

  if (TSDB_CODE_SUCCESS == code) {

13,343,813✔

3757

    code = tlvEncodeValueI8(pEncoder, pNode->slidingUnit);

13,342,203✔

3760

  return code;

13,342,832✔

3763

static int32_t physiIntervalNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

13,329,741✔

3764

  const SIntervalPhysiNode* pNode = (const SIntervalPhysiNode*)pObj;

13,329,741✔

3766

  int32_t code = tlvEncodeObj(pEncoder, PHY_INTERVAL_CODE_WINDOW, physiWindowNodeToMsg, &pNode->window);

13,329,741✔

3767

  if (TSDB_CODE_SUCCESS == code) {

13,343,846✔

3768

    code = tlvEncodeObj(pEncoder, PHY_INTERVAL_CODE_INLINE_ATTRS, physiIntervalNodeInlineToMsg, pNode);

13,343,930✔

3770

  if (TSDB_CODE_SUCCESS == code) {

13,342,520✔

3771

    code = tlvEncodeObj(pEncoder, PHY_INTERVAL_CODE_TIME_RANGE, timeWindowToMsg, &pNode->timeRange);

13,342,671✔

3774

  return code;

13,338,918✔

3777

static int32_t msgToPhysiIntervalNodeInline(STlvDecoder* pDecoder, void* pObj) {

5,455,211✔

3778

  SIntervalPhysiNode* pNode = (SIntervalPhysiNode*)pObj;

5,455,211✔

3780

  int32_t code = tlvDecodeValueI64(pDecoder, &pNode->interval);

5,455,211✔

3781

  if (TSDB_CODE_SUCCESS == code) {

5,455,740✔

3782

    code = tlvDecodeValueI64(pDecoder, &pNode->offset);

5,455,740✔

3784

  if (TSDB_CODE_SUCCESS == code) {

5,455,740✔

3785

    code = tlvDecodeValueI64(pDecoder, &pNode->sliding);

5,455,740✔

3787

  if (TSDB_CODE_SUCCESS == code) {

5,455,740✔

3788

    code = tlvDecodeValueI8(pDecoder, &pNode->intervalUnit);

5,455,740✔

3790

  if (TSDB_CODE_SUCCESS == code) {

5,455,740✔

3791

    code = tlvDecodeValueI8(pDecoder, &pNode->slidingUnit);

5,455,740✔

3794

  return code;

5,455,740✔

3797

static int32_t msgToPhysiIntervalNode(STlvDecoder* pDecoder, void* pObj) {

5,454,816✔

3798

  SIntervalPhysiNode* pNode = (SIntervalPhysiNode*)pObj;

5,454,816✔

3800

  int32_t code = TSDB_CODE_SUCCESS;

5,454,816✔

3801

  STlv*   pTlv = NULL;

5,454,816✔

3802

  tlvForEach(pDecoder, pTlv, code) {

21,822,036✔

3803

    switch (pTlv->type) {

16,367,074✔

3804

      case PHY_INTERVAL_CODE_WINDOW:

5,454,405✔

3805

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiWindowNode, &pNode->window);

5,454,405✔

3806

        break;

5,455,211✔

3807

      case PHY_INTERVAL_CODE_INLINE_ATTRS:

5,455,740✔

3808

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiIntervalNodeInline, pNode);

5,455,740✔

3809

        break;

5,455,740✔

3810

      case PHY_INTERVAL_CODE_TIME_RANGE:

5,455,594✔

3811

        code = tlvDecodeObjFromTlv(pTlv, msgToTimeWindow, &pNode->timeRange);

5,455,594✔

3812

      default:

5,455,740✔

3813

        break;

5,455,740✔

3817

  return code;

5,455,977✔

3834

static int32_t physiFillNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

513,405✔

3835

  const SFillPhysiNode* pNode = (const SFillPhysiNode*)pObj;

513,405✔

3837

  int32_t code = tlvEncodeObj(pEncoder, PHY_FILL_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

513,405✔

3838

  if (TSDB_CODE_SUCCESS == code) {

514,626✔

3839

    code = tlvEncodeEnum(pEncoder, PHY_FILL_CODE_MODE, pNode->mode);

514,626✔

3841

  if (TSDB_CODE_SUCCESS == code) {

514,626✔

3842

    code = tlvEncodeObj(pEncoder, PHY_FILL_CODE_FILL_EXPRS, nodeListToMsg, pNode->pFillExprs);

514,626✔

3844

  if (TSDB_CODE_SUCCESS == code) {

514,626✔

3845

    code = tlvEncodeObj(pEncoder, PHY_FILL_CODE_NOT_FILL_EXPRS, nodeListToMsg, pNode->pNotFillExprs);

514,626✔

3847

  if (TSDB_CODE_SUCCESS == code) {

514,626✔

3848

    code = tlvEncodeObj(pEncoder, PHY_FILL_CODE_WSTART, nodeToMsg, pNode->pWStartTs);

514,626✔

3850

  if (TSDB_CODE_SUCCESS == code) {

514,626✔

3851

    code = tlvEncodeObj(pEncoder, PHY_FILL_CODE_VALUES, nodeToMsg, pNode->pValues);

514,626✔

3853

  if (TSDB_CODE_SUCCESS == code) {

514,626✔

3854

    code = tlvEncodeObj(pEncoder, PHY_FILL_CODE_TIME_RANGE, timeWindowToMsg, &pNode->timeRange);

514,626✔

3856

  if (TSDB_CODE_SUCCESS == code) {

514,626✔

3857

    code = tlvEncodeObj(pEncoder, PHY_FILL_CODE_FILL_NULL_EXPRS, nodeListToMsg, pNode->pFillNullExprs);

514,626✔

3859

  if (TSDB_CODE_SUCCESS == code) {

514,626✔

3860

    code = tlvEncodeObj(pEncoder, PHY_FILL_CODE_TIME_RANGE_EXPR, nodeToMsg, pNode->pTimeRange);

514,626✔

3862

  if (TSDB_CODE_SUCCESS == code) {

514,626✔

3863

    code = tlvEncodeObj(pEncoder, PHY_FILL_CODE_SURROUNDING_TIME, nodeToMsg,

514,626✔

3864

                        pNode->pSurroundingTime);

514,626✔

3866

  return code;

514,626✔

3869

static int32_t msgToPhysiFillNode(STlvDecoder* pDecoder, void* pObj) {

509,283✔

3870

  SFillPhysiNode* pNode = (SFillPhysiNode*)pObj;

509,283✔

3872

  int32_t code = TSDB_CODE_SUCCESS;

509,283✔

3873

  STlv*   pTlv = NULL;

509,283✔

3874

  tlvForEach(pDecoder, pTlv, code) {

3,598,996✔

3875

    switch (pTlv->type) {

3,089,713✔

3876

      case PHY_FILL_CODE_BASE_NODE:

509,283✔

3877

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

509,283✔

3878

        break;

509,283✔

3879

      case PHY_FILL_CODE_MODE:

509,283✔

3880

        code = tlvDecodeEnum(pTlv, &pNode->mode, sizeof(pNode->mode));

509,283✔

3881

        break;

509,283✔

3882

      case PHY_FILL_CODE_FILL_EXPRS:

508,515✔

3883

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pFillExprs);

508,515✔

3884

        break;

508,515✔

3885

      case PHY_FILL_CODE_NOT_FILL_EXPRS:

435,225✔

3886

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pNotFillExprs);

435,225✔

3887

        break;

435,225✔

3888

      case PHY_FILL_CODE_WSTART:

509,283✔

3889

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pWStartTs);

509,283✔

3890

        break;

509,283✔

3891

      case PHY_FILL_CODE_VALUES:

84,544✔

3892

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pValues);

84,544✔

3893

        break;

84,544✔

3894

      case PHY_FILL_CODE_TIME_RANGE:

509,283✔

3895

        code = tlvDecodeObjFromTlv(pTlv, msgToTimeWindow, (void**)&pNode->timeRange);

509,283✔

3896

        break;

509,283✔

3897

      case PHY_FILL_CODE_FILL_NULL_EXPRS:

18,537✔

3898

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pFillNullExprs);

18,537✔

3899

        break;

18,537✔

3903

      case PHY_FILL_CODE_SURROUNDING_TIME:

5,760✔

3904

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pSurroundingTime);

5,760✔

3905

        break;

5,760✔

3911

  return code;

509,283✔

3916

static int32_t physiSessionWindowNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,403,511✔

3917

  const SSessionWinodwPhysiNode* pNode = (const SSessionWinodwPhysiNode*)pObj;

2,403,511✔

3919

  int32_t code = tlvEncodeObj(pEncoder, PHY_SESSION_CODE_WINDOW, physiWindowNodeToMsg, &pNode->window);

2,403,511✔

3920

  if (TSDB_CODE_SUCCESS == code) {

2,403,918✔

3921

    code = tlvEncodeI64(pEncoder, PHY_SESSION_CODE_GAP, pNode->gap);

2,403,918✔

3924

  return code;

2,403,918✔

3927

static int32_t msgToPhysiSessionWindowNode(STlvDecoder* pDecoder, void* pObj) {

560,937✔

3928

  SSessionWinodwPhysiNode* pNode = (SSessionWinodwPhysiNode*)pObj;

560,937✔

3930

  int32_t code = TSDB_CODE_SUCCESS;

560,937✔

3931

  STlv*   pTlv = NULL;

560,937✔

3932

  tlvForEach(pDecoder, pTlv, code) {

1,682,811✔

3933

    switch (pTlv->type) {

1,121,874✔

3934

      case PHY_SESSION_CODE_WINDOW:

560,937✔

3935

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiWindowNode, &pNode->window);

560,937✔

3936

        break;

560,937✔

3937

      case PHY_SESSION_CODE_GAP:

560,937✔

3938

        code = tlvDecodeI64(pTlv, &pNode->gap);

560,937✔

3939

        break;

560,937✔

3945

  return code;

560,937✔

3957

static int32_t physiExternalWindowNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

947,585✔

3958

  const SExternalWindowPhysiNode* pNode = (const SExternalWindowPhysiNode*)pObj;

947,585✔

3959

  int32_t code = tlvEncodeObj(pEncoder, PHY_EXT_CODE_WINDOW, physiWindowNodeToMsg, &pNode->window);

947,585✔

3960

  if (TSDB_CODE_SUCCESS == code) {

947,585✔

3961

    code = tlvEncodeI64(pEncoder, PHY_EXT_CODE_SKEY, pNode->timeRange.skey);

947,585✔

3963

  if (TSDB_CODE_SUCCESS == code) {

947,585✔

3964

    code = tlvEncodeI64(pEncoder, PHY_EXT_CODE_EKEY, pNode->timeRange.ekey);

947,585✔

3966

  if (TSDB_CODE_SUCCESS == code) {

947,585✔

3967

    code = tlvEncodeObj(pEncoder, PHY_EXT_CODE_TIME_RANGE_EXPR, nodeToMsg, pNode->pTimeRange);

947,585✔

3969

  if (TSDB_CODE_SUCCESS == code) {

947,585✔

3970

    code = tlvEncodeBool(pEncoder, PHY_EXT_CODE_IS_SINGLE_TABLE, pNode->isSingleTable);

947,585✔

3972

  if (TSDB_CODE_SUCCESS == code) {

947,585✔

3973

    code = tlvEncodeBool(pEncoder, PHY_EXT_CODE_INPUT_HAS_ORDER, pNode->inputHasOrder);

947,585✔

3975

  if (TSDB_CODE_SUCCESS == code) {

947,585✔

3976

    code = tlvEncodeI64(pEncoder, PHY_EXT_CODE_ORG_TABLE_UID, pNode->orgTableUid);

947,585✔

3978

  if (TSDB_CODE_SUCCESS == code) {

947,585✔

3979

    code = tlvEncodeI32(pEncoder, PHY_EXT_CODE_ORG_TABLE_VGID, pNode->orgTableVgId);

947,585✔

3982

  return code;

947,585✔

3985

static int32_t msgToPhysiExternalWindowNode(STlvDecoder* pDecoder, void* pObj) {

937,134✔

3986

  SExternalWindowPhysiNode* pNode = (SExternalWindowPhysiNode*)pObj;

937,134✔

3988

  int32_t code = TSDB_CODE_SUCCESS;

937,134✔

3989

  STlv*   pTlv = NULL;

937,134✔

3990

  tlvForEach(pDecoder, pTlv, code) {

7,497,072✔

3991

    switch (pTlv->type) {

6,559,938✔

3992

      case PHY_EXT_CODE_WINDOW:

937,134✔

3993

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiWindowNode, &pNode->window);

937,134✔

3994

        break;

937,134✔

3995

      case PHY_EXT_CODE_SKEY:

937,134✔

3996

        code = tlvDecodeI64(pTlv, &pNode->timeRange.skey);

937,134✔

3997

        break;

937,134✔

3998

      case PHY_EXT_CODE_EKEY:

937,134✔

3999

        code = tlvDecodeI64(pTlv, &pNode->timeRange.ekey);

937,134✔

4000

        break;

937,134✔

4004

      case PHY_EXT_CODE_IS_SINGLE_TABLE:

937,134✔

4005

        code = tlvDecodeBool(pTlv, &pNode->isSingleTable);

937,134✔

4006

        break;

937,134✔

4007

      case PHY_EXT_CODE_INPUT_HAS_ORDER:

937,134✔

4008

        code = tlvDecodeBool(pTlv, &pNode->inputHasOrder);

937,134✔

4009

        break;

937,134✔

4010

      case PHY_EXT_CODE_ORG_TABLE_UID:

937,134✔

4011

        code = tlvDecodeI64(pTlv, &pNode->orgTableUid);

937,134✔

4012

        break;

937,134✔

4013

      case PHY_EXT_CODE_ORG_TABLE_VGID:

937,134✔

4014

        code = tlvDecodeI32(pTlv, &pNode->orgTableVgId);

937,134✔

4015

        break;

937,134✔

4020

  return code;

937,134✔

4025

static int32_t physiStateWindowNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,370,160✔

4026

  const SStateWindowPhysiNode* pNode = (const SStateWindowPhysiNode*)pObj;

2,370,160✔

4028

  int32_t code = tlvEncodeObj(pEncoder, PHY_STATE_CODE_WINDOW, physiWindowNodeToMsg, &pNode->window);

2,370,160✔

4029

  if (TSDB_CODE_SUCCESS == code) {

2,370,160✔

4030

    code = tlvEncodeObj(pEncoder, PHY_STATE_CODE_KEY, nodeToMsg, pNode->pStateKey);

2,370,160✔

4032

  if (TSDB_CODE_SUCCESS == code) {

2,370,160✔

4033

    code = tlvEncodeI32(pEncoder, PHY_STATE_CODE_TRUE_FOR_TYPE, pNode->trueForType);

2,370,160✔

4035

  if (TSDB_CODE_SUCCESS == code) {

2,370,160✔

4036

    code = tlvEncodeI32(pEncoder, PHY_STATE_CODE_TRUE_FOR_COUNT, pNode->trueForCount);

2,370,160✔

4038

  if (TSDB_CODE_SUCCESS == code) {

2,370,160✔

4039

    code = tlvEncodeI64(pEncoder, PHY_STATE_CODE_TRUE_FOR_DURATION, pNode->trueForDuration);

2,370,160✔

4041

  if (TSDB_CODE_SUCCESS == code) {

2,370,160✔

4042

    code = tlvEncodeI32(pEncoder, PHY_STATE_CODE_EXTEND_OPTION, pNode->extendOption);

2,370,160✔

4045

  return code;

2,370,160✔

4048

static int32_t msgToPhysiStateWindowNode(STlvDecoder* pDecoder, void* pObj) {

977,597✔

4049

  SStateWindowPhysiNode* pNode = (SStateWindowPhysiNode*)pObj;

977,597✔

4051

  int32_t code = TSDB_CODE_SUCCESS;

977,597✔

4052

  STlv*   pTlv = NULL;

977,597✔

4053

  tlvForEach(pDecoder, pTlv, code) {

6,843,179✔

4054

    switch (pTlv->type) {

5,865,582✔

4055

      case PHY_STATE_CODE_WINDOW:

977,597✔

4056

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiWindowNode, &pNode->window);

977,597✔

4057

        break;

977,597✔

4058

      case PHY_STATE_CODE_KEY:

977,597✔

4059

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pStateKey);

977,597✔

4060

        break;

977,597✔

4061

      case PHY_STATE_CODE_TRUE_FOR_TYPE:

977,597✔

4062

        code = tlvDecodeI32(pTlv, (int32_t*)&pNode->trueForType);

977,597✔

4063

        break;

977,597✔

4064

      case PHY_STATE_CODE_TRUE_FOR_COUNT:

977,597✔

4065

        code = tlvDecodeI32(pTlv, &pNode->trueForCount);

977,597✔

4066

        break;

977,597✔

4067

      case PHY_STATE_CODE_TRUE_FOR_DURATION:

977,597✔

4068

        code = tlvDecodeI64(pTlv, &pNode->trueForDuration);

977,597✔

4069

        break;

977,597✔

4070

      case PHY_STATE_CODE_EXTEND_OPTION:

977,597✔

4071

        code = tlvDecodeI32(pTlv, (int32_t*)&pNode->extendOption);

977,597✔

4072

      default:

977,597✔

4073

        break;

977,597✔

4077

  return code;

977,597✔

4082

static int32_t physiEventWindowNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

1,765,120✔

4083

  const SEventWinodwPhysiNode* pNode = (const SEventWinodwPhysiNode*)pObj;

1,765,120✔

4085

  int32_t code = tlvEncodeObj(pEncoder, PHY_EVENT_CODE_WINDOW, physiWindowNodeToMsg, &pNode->window);

1,765,120✔

4086

  if (TSDB_CODE_SUCCESS == code) {

1,764,805✔

4087

    code = tlvEncodeObj(pEncoder, PHY_EVENT_CODE_START_COND, nodeToMsg, pNode->pStartCond);

1,764,805✔

4089

  if (TSDB_CODE_SUCCESS == code) {

1,765,213✔

4090

    code = tlvEncodeObj(pEncoder, PHY_EVENT_CODE_END_COND, nodeToMsg, pNode->pEndCond);

1,765,213✔

4092

  if (TSDB_CODE_SUCCESS == code) {

1,765,213✔

4093

    code = tlvEncodeI32(pEncoder, PHY_EVENT_CODE_TRUE_FOR_TYPE, pNode->trueForType);

1,765,213✔

4095

  if (TSDB_CODE_SUCCESS == code) {

1,765,213✔

4096

    code = tlvEncodeI32(pEncoder, PHY_EVENT_CODE_TRUE_FOR_COUNT, pNode->trueForCount);

1,765,213✔

4098

  if (TSDB_CODE_SUCCESS == code) {

1,765,213✔

4099

    code = tlvEncodeI64(pEncoder, PHY_EVENT_CODE_TRUE_FOR_DURATION, pNode->trueForDuration);

1,765,213✔

4102

  return code;

1,765,213✔

4105

static int32_t msgToPhysiEventWindowNode(STlvDecoder* pDecoder, void* pObj) {

312,591✔

4106

  SEventWinodwPhysiNode* pNode = (SEventWinodwPhysiNode*)pObj;

312,591✔

4108

  int32_t code = TSDB_CODE_SUCCESS;

312,591✔

4109

  STlv*   pTlv = NULL;

312,591✔

4110

  tlvForEach(pDecoder, pTlv, code) {

2,188,137✔

4111

    switch (pTlv->type) {

1,875,546✔

4112

      case PHY_EVENT_CODE_WINDOW:

312,591✔

4113

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiWindowNode, &pNode->window);

312,591✔

4114

        break;

312,591✔

4115

      case PHY_EVENT_CODE_START_COND:

312,591✔

4116

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pStartCond);

312,591✔

4117

        break;

312,591✔

4118

      case PHY_EVENT_CODE_END_COND:

312,591✔

4119

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pEndCond);

312,591✔

4120

        break;

312,591✔

4121

      case PHY_EVENT_CODE_TRUE_FOR_TYPE:

312,591✔

4122

        code = tlvDecodeI32(pTlv, (int32_t *)&pNode->trueForType);

312,591✔

4123

        break;

312,591✔

4124

      case PHY_EVENT_CODE_TRUE_FOR_COUNT:

312,591✔

4125

        code = tlvDecodeI32(pTlv, &pNode->trueForCount);

312,591✔

4126

        break;

312,591✔

4127

      case PHY_EVENT_CODE_TRUE_FOR_DURATION:

312,591✔

4128

        code = tlvDecodeI64(pTlv, &pNode->trueForDuration);

312,591✔

4129

        break;

312,591✔

4135

  return code;

312,591✔

4140

static int32_t physiCountWindowNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

1,627,185✔

4141

  const SCountWindowPhysiNode* pNode = (const SCountWindowPhysiNode*)pObj;

1,627,185✔

4143

  int32_t code = tlvEncodeObj(pEncoder, PHY_COUNT_CODE_WINDOW, physiWindowNodeToMsg, &pNode->window);

1,627,185✔

4144

  if (TSDB_CODE_SUCCESS == code) {

1,627,185✔

4145

    code = tlvEncodeI64(pEncoder, PHY_COUNT_CODE_WINDOW_COUNT, pNode->windowCount);

1,627,185✔

4147

  if (TSDB_CODE_SUCCESS == code) {

1,627,185✔

4148

    code = tlvEncodeI64(pEncoder, PHY_COUNT_CODE_WINDOW_SLIDING, pNode->windowSliding);

1,627,185✔

4151

  return code;

1,627,185✔

4154

static int32_t msgToPhysiCountWindowNode(STlvDecoder* pDecoder, void* pObj) {

250,928✔

4155

  SCountWindowPhysiNode* pNode = (SCountWindowPhysiNode*)pObj;

250,928✔

4157

  int32_t code = TSDB_CODE_SUCCESS;

250,928✔

4158

  STlv*   pTlv = NULL;

250,928✔

4159

  tlvForEach(pDecoder, pTlv, code) {

1,003,712✔

4160

    switch (pTlv->type) {

752,784✔

4161

      case PHY_COUNT_CODE_WINDOW:

250,928✔

4162

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiWindowNode, &pNode->window);

250,928✔

4163

        break;

250,928✔

4164

      case PHY_COUNT_CODE_WINDOW_COUNT:

250,928✔

4165

        code = tlvDecodeI64(pTlv, &pNode->windowCount);

250,928✔

4166

        break;

250,928✔

4167

      case PHY_COUNT_CODE_WINDOW_SLIDING:

250,928✔

4168

        code = tlvDecodeI64(pTlv, &pNode->windowSliding);

250,928✔

4169

        break;

250,928✔

4175

  return code;

250,928✔

4227

static int32_t physiPartitionNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

10,566,801✔

4228

  const SPartitionPhysiNode* pNode = (const SPartitionPhysiNode*)pObj;

10,566,801✔

4230

  int32_t code = tlvEncodeObj(pEncoder, PHY_PARTITION_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

10,566,801✔

4231

  if (TSDB_CODE_SUCCESS == code) {

10,573,729✔

4232

    code = tlvEncodeObj(pEncoder, PHY_PARTITION_CODE_EXPR, nodeListToMsg, pNode->pExprs);

10,573,703✔

4234

  if (TSDB_CODE_SUCCESS == code) {

10,572,331✔

4235

    code = tlvEncodeObj(pEncoder, PHY_PARTITION_CODE_KEYS, nodeListToMsg, pNode->pPartitionKeys);

10,568,260✔

4237

  if (TSDB_CODE_SUCCESS == code) {

10,578,594✔

4238

    code = tlvEncodeObj(pEncoder, PHY_PARTITION_CODE_TARGETS, nodeListToMsg, pNode->pTargets);

10,574,523✔

4240

  if (TSDB_CODE_SUCCESS == code) {

10,578,455✔

4241

    code = tlvEncodeBool(pEncoder, PHY_PARTITION_CODE_HAS_OUTPUT_TS_ORDER, pNode->needBlockOutputTsOrder);

10,574,451✔

4243

  if (TSDB_CODE_SUCCESS == code) {

10,579,020✔

4244

    code = tlvEncodeI32(pEncoder, PHY_PARTITION_CODE_TS_SLOTID, pNode->tsSlotId);

10,575,016✔

4247

  return code;

10,574,649✔

4250

static int32_t msgToPhysiPartitionNode(STlvDecoder* pDecoder, void* pObj) {

2,980,067✔

4251

  SPartitionPhysiNode* pNode = (SPartitionPhysiNode*)pObj;

2,980,067✔

4253

  int32_t code = TSDB_CODE_SUCCESS;

2,980,067✔

4254

  STlv*   pTlv = NULL;

2,980,067✔

4255

  tlvForEach(pDecoder, pTlv, code) {

17,968,073✔

4256

    switch (pTlv->type) {

14,988,400✔

4257

      case PHY_PARTITION_CODE_BASE_NODE:

2,980,097✔

4258

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

2,980,097✔

4259

        break;

2,981,020✔

4260

      case PHY_PARTITION_CODE_EXPR:

83,300✔

4261

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pExprs);

83,300✔

4262

        break;

83,300✔

4263

      case PHY_PARTITION_CODE_KEYS:

2,981,020✔

4264

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pPartitionKeys);

2,981,020✔

4265

        break;

2,981,020✔

4266

      case PHY_PARTITION_CODE_TARGETS:

2,981,020✔

4267

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pTargets);

2,981,020✔

4268

        break;

2,981,020✔

4269

      case PHY_PARTITION_CODE_HAS_OUTPUT_TS_ORDER:

2,981,020✔

4270

        code = tlvDecodeBool(pTlv, &pNode->needBlockOutputTsOrder);

2,981,020✔

4271

        break;

2,981,020✔

4272

      case PHY_PARTITION_CODE_TS_SLOTID:

2,981,943✔

4273

        code = tlvDecodeI32(pTlv, &pNode->tsSlotId);

2,981,943✔

4274

        break;

2,980,626✔

4280

  return code;

2,979,673✔

4285

static int32_t physiIndefRowsFuncNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

3,151,025✔

4286

  const SIndefRowsFuncPhysiNode* pNode = (const SIndefRowsFuncPhysiNode*)pObj;

3,151,025✔

4288

  int32_t code = tlvEncodeObj(pEncoder, PHY_INDEF_ROWS_FUNC_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

3,151,025✔

4289

  if (TSDB_CODE_SUCCESS == code) {

3,151,403✔

4290

    code = tlvEncodeObj(pEncoder, PHY_INDEF_ROWS_FUNC_CODE_EXPRS, nodeListToMsg, pNode->pExprs);

3,151,403✔

4292

  if (TSDB_CODE_SUCCESS == code) {

3,151,403✔

4293

    code = tlvEncodeObj(pEncoder, PHY_INDEF_ROWS_FUNC_CODE_FUNCS, nodeListToMsg, pNode->pFuncs);

3,151,403✔

4296

  return code;

3,151,403✔

4299

static int32_t msgToPhysiIndefRowsFuncNode(STlvDecoder* pDecoder, void* pObj) {

3,123,662✔

4300

  SIndefRowsFuncPhysiNode* pNode = (SIndefRowsFuncPhysiNode*)pObj;

3,123,662✔

4302

  int32_t code = TSDB_CODE_SUCCESS;

3,123,662✔

4303

  STlv*   pTlv = NULL;

3,123,662✔

4304

  tlvForEach(pDecoder, pTlv, code) {

9,393,816✔

4305

    switch (pTlv->type) {

6,270,532✔

4306

      case PHY_INDEF_ROWS_FUNC_CODE_BASE_NODE:

3,123,132✔

4307

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

3,123,132✔

4308

        break;

3,123,662✔

4309

      case PHY_INDEF_ROWS_FUNC_CODE_EXPRS:

23,208✔

4310

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pExprs);

23,208✔

4311

        break;

23,208✔

4312

      case PHY_INDEF_ROWS_FUNC_CODE_FUNCS:

3,124,192✔

4313

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pFuncs);

3,124,192✔

4314

        break;

3,123,284✔

4320

  return code;

3,123,132✔

4337

static int32_t physiInterpFuncNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

3,451,522✔

4338

  const SInterpFuncPhysiNode* pNode = (const SInterpFuncPhysiNode*)pObj;

3,451,522✔

4340

  int32_t code = tlvEncodeObj(pEncoder, PHY_INERP_FUNC_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

3,451,522✔

4341

  if (TSDB_CODE_SUCCESS == code) {

3,451,522✔

4342

    code = tlvEncodeObj(pEncoder, PHY_INERP_FUNC_CODE_EXPR, nodeListToMsg, pNode->pExprs);

3,451,522✔

4344

  if (TSDB_CODE_SUCCESS == code) {

3,451,522✔

4345

    code = tlvEncodeObj(pEncoder, PHY_INERP_FUNC_CODE_FUNCS, nodeListToMsg, pNode->pFuncs);

3,451,522✔

4347

  if (TSDB_CODE_SUCCESS == code) {

3,451,522✔

4348

    code = tlvEncodeObj(pEncoder, PHY_INERP_FUNC_CODE_TIME_RANGE, timeWindowToMsg, &pNode->timeRange);

3,451,522✔

4350

  if (TSDB_CODE_SUCCESS == code) {

3,451,522✔

4351

    code = tlvEncodeObj(pEncoder, PHY_INERP_FUNC_CODE_TIME_RANGE_EXPR, nodeToMsg, pNode->pTimeRange);

3,451,522✔

4353

  if (TSDB_CODE_SUCCESS == code) {

3,451,522✔

4354

    code = tlvEncodeI64(pEncoder, PHY_INERP_FUNC_CODE_INTERVAL, pNode->interval);

3,451,522✔

4356

  if (TSDB_CODE_SUCCESS == code) {

3,451,522✔

4357

    code = tlvEncodeI8(pEncoder, PHY_INERP_FUNC_CODE_INTERVAL_UNIT, pNode->intervalUnit);

3,451,522✔

4359

  if (TSDB_CODE_SUCCESS == code) {

3,451,522✔

4360

    code = tlvEncodeEnum(pEncoder, PHY_INERP_FUNC_CODE_FILL_MODE, pNode->fillMode);

3,451,522✔

4362

  if (TSDB_CODE_SUCCESS == code) {

3,451,522✔

4363

    code = tlvEncodeObj(pEncoder, PHY_INERP_FUNC_CODE_FILL_VALUES, nodeToMsg, pNode->pFillValues);

3,451,522✔

4365

  if (TSDB_CODE_SUCCESS == code) {

3,451,522✔

4366

    code = tlvEncodeObj(pEncoder, PHY_INERP_FUNC_CODE_TIME_SERIES, nodeToMsg, pNode->pTimeSeries);

3,451,522✔

4368

  if (TSDB_CODE_SUCCESS == code) {

3,451,522✔

4369

    code = tlvEncodeI64(pEncoder, PHY_INTERP_FUNC_CODE_SURROUNDING_TIME, pNode->surroundingTime);

3,451,522✔

4372

  return code;

3,451,522✔

4375

static int32_t msgToPhysiInterpFuncNode(STlvDecoder* pDecoder, void* pObj) {

3,443,288✔

4376

  SInterpFuncPhysiNode* pNode = (SInterpFuncPhysiNode*)pObj;

3,443,288✔

4378

  int32_t code = TSDB_CODE_SUCCESS;

3,443,288✔

4379

  STlv*   pTlv = NULL;

3,443,288✔

4380

  tlvForEach(pDecoder, pTlv, code) {

32,729,920✔

4381

    switch (pTlv->type) {

29,286,632✔

4382

      case PHY_INERP_FUNC_CODE_BASE_NODE:

3,443,288✔

4383

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

3,443,288✔

4384

        break;

3,443,288✔

4385

      case PHY_INERP_FUNC_CODE_EXPR:

86,617✔

4386

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pExprs);

86,617✔

4387

        break;

86,617✔

4388

      case PHY_INERP_FUNC_CODE_FUNCS:

3,443,288✔

4389

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pFuncs);

3,443,288✔

4390

        break;

3,443,288✔

4391

      case PHY_INERP_FUNC_CODE_TIME_RANGE:

3,443,288✔

4392

        code = tlvDecodeObjFromTlv(pTlv, msgToTimeWindow, &pNode->timeRange);

3,443,288✔

4393

        break;

3,443,288✔

4397

      case PHY_INERP_FUNC_CODE_INTERVAL:

3,443,288✔

4398

        code = tlvDecodeI64(pTlv, &pNode->interval);

3,443,288✔

4399

        break;

3,443,288✔

4400

      case PHY_INERP_FUNC_CODE_INTERVAL_UNIT:

3,443,288✔

4401

        code = tlvDecodeI8(pTlv, &pNode->intervalUnit);

3,443,288✔

4402

        break;

3,443,288✔

4403

      case PHY_INERP_FUNC_CODE_FILL_MODE:

3,443,288✔

4404

        code = tlvDecodeEnum(pTlv, &pNode->fillMode, sizeof(pNode->fillMode));

3,443,288✔

4405

        break;

3,443,288✔

4406

      case PHY_INERP_FUNC_CODE_FILL_VALUES:

1,653,711✔

4407

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pFillValues);

1,653,711✔

4408

        break;

1,653,711✔

4409

      case PHY_INERP_FUNC_CODE_TIME_SERIES:

3,443,288✔

4410

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pTimeSeries);

3,443,288✔

4411

        break;

3,443,288✔

4412

      case PHY_INTERP_FUNC_CODE_SURROUNDING_TIME:

3,443,288✔

4413

        code = tlvDecodeI64(pTlv, &pNode->surroundingTime);

3,443,288✔

4414

        break;

3,443,288✔

4420

  return code;

3,443,288✔

4469

static int32_t physicDataSinkNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

510,846,341✔

4470

  const SDataSinkNode* pNode = (const SDataSinkNode*)pObj;

510,846,341✔

4471

  return tlvEncodeObj(pEncoder, PHY_DATA_SINK_CODE_INPUT_DESC, nodeToMsg, pNode->pInputDataBlockDesc);

510,846,341✔

4474

static int32_t msgToPhysicDataSinkNode(STlvDecoder* pDecoder, void* pObj) {

358,886,726✔

4475

  SDataSinkNode* pNode = (SDataSinkNode*)pObj;

358,886,726✔

4477

  int32_t code = TSDB_CODE_SUCCESS;

358,886,726✔

4478

  STlv*   pTlv = NULL;

358,886,726✔

4479

  tlvForEach(pDecoder, pTlv, code) {

717,837,511✔

4480

    switch (pTlv->type) {

358,929,322✔

4481

      case PHY_DATA_SINK_CODE_INPUT_DESC:

358,930,817✔

4482

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pInputDataBlockDesc);

358,930,817✔

4483

        break;

358,934,507✔

4489

  return code;

358,954,512✔

4495

static int32_t physiDispatchNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

508,767,008✔

4496

  const SDataDispatcherNode* pNode = (const SDataDispatcherNode*)pObj;

508,767,008✔

4497

  int32_t                    code = tlvEncodeObj(pEncoder, PHY_DISPATCH_CODE_SINK, physicDataSinkNodeToMsg, &pNode->sink);

508,767,008✔

4498

  if (TSDB_CODE_SUCCESS == code) {

509,310,958✔

4499

    code = tlvEncodeBool(pEncoder, PHY_DISPATCH_DYNAMIC_SCHEMA, pNode->dynamicSchema);

509,316,012✔

4501

  return code;

509,364,860✔

4504

static int32_t msgToPhysiDispatchNode(STlvDecoder* pDecoder, void* pObj) {

356,804,700✔

4505

  SDataDispatcherNode* pNode = (SDataDispatcherNode*)pObj;

356,804,700✔

4507

  int32_t code = TSDB_CODE_SUCCESS;

356,804,700✔

4508

  STlv*   pTlv = NULL;

356,804,700✔

4509

  tlvForEach(pDecoder, pTlv, code) {

1,070,517,494✔

4510

    switch (pTlv->type) {

713,691,987✔

4511

      case PHY_DISPATCH_CODE_SINK:

356,819,008✔

4512

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysicDataSinkNode, &pNode->sink);

356,819,008✔

4513

        break;

356,847,756✔

4514

      case PHY_DISPATCH_DYNAMIC_SCHEMA:

356,873,895✔

4515

        code = tlvDecodeBool(pTlv, &pNode->dynamicSchema);

356,873,895✔

4516

        break;

356,847,670✔

4522

  return code;

356,863,206✔

4537

static int32_t physiQueryInsertNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

286,779✔

4538

  const SQueryInserterNode* pNode = (const SQueryInserterNode*)pObj;

286,779✔

4540

  int32_t code = tlvEncodeObj(pEncoder, PHY_QUERY_INSERT_CODE_SINK, physicDataSinkNodeToMsg, &pNode->sink);

286,779✔

4541

  if (TSDB_CODE_SUCCESS == code) {

286,779✔

4542

    code = tlvEncodeObj(pEncoder, PHY_QUERY_INSERT_CODE_COLS, nodeListToMsg, pNode->pCols);

286,779✔

4544

  if (TSDB_CODE_SUCCESS == code) {

286,779✔

4545

    code = tlvEncodeU64(pEncoder, PHY_QUERY_INSERT_CODE_TABLE_ID, pNode->tableId);

286,779✔

4547

  if (TSDB_CODE_SUCCESS == code) {

286,779✔

4548

    code = tlvEncodeU64(pEncoder, PHY_QUERY_INSERT_CODE_STABLE_ID, pNode->stableId);

286,779✔

4550

  if (TSDB_CODE_SUCCESS == code) {

286,779✔

4551

    code = tlvEncodeI8(pEncoder, PHY_QUERY_INSERT_CODE_TABLE_TYPE, pNode->tableType);

286,779✔

4553

  if (TSDB_CODE_SUCCESS == code) {

286,779✔

4554

    code = tlvEncodeCStr(pEncoder, PHY_QUERY_INSERT_CODE_TABLE_NAME, pNode->tableName);

286,779✔

4556

  if (TSDB_CODE_SUCCESS == code) {

286,779✔

4557

    code = tlvEncodeI32(pEncoder, PHY_QUERY_INSERT_CODE_VG_ID, pNode->vgId);

286,779✔

4559

  if (TSDB_CODE_SUCCESS == code) {

286,779✔

4560

    code = tlvEncodeObj(pEncoder, PHY_QUERY_INSERT_CODE_EP_SET, epSetToMsg, &pNode->epSet);

286,779✔

4562

  if (TSDB_CODE_SUCCESS == code) {

286,779✔

4563

    code = tlvEncodeBool(pEncoder, PHY_QUERY_INSERT_CODE_EXPLAIN, pNode->explain);

286,779✔

4566

  return code;

286,779✔

4569

static int32_t msgToPhysiQueryInsertNode(STlvDecoder* pDecoder, void* pObj) {

286,373✔

4570

  SQueryInserterNode* pNode = (SQueryInserterNode*)pObj;

286,373✔

4572

  int32_t code = TSDB_CODE_SUCCESS;

286,373✔

4573

  STlv*   pTlv = NULL;

286,373✔

4574

  tlvForEach(pDecoder, pTlv, code) {

2,863,730✔

4575

    switch (pTlv->type) {

2,577,357✔

4576

      case PHY_QUERY_INSERT_CODE_SINK:

286,373✔

4577

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysicDataSinkNode, &pNode->sink);

286,373✔

4578

        break;

286,373✔

4579

      case PHY_QUERY_INSERT_CODE_COLS:

286,373✔

4580

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pCols);

286,373✔

4581

        break;

286,373✔

4582

      case PHY_QUERY_INSERT_CODE_TABLE_ID:

286,373✔

4583

        code = tlvDecodeU64(pTlv, &pNode->tableId);

286,373✔

4584

        break;

286,373✔

4585

      case PHY_QUERY_INSERT_CODE_STABLE_ID:

286,373✔

4586

        code = tlvDecodeU64(pTlv, &pNode->stableId);

286,373✔

4587

        break;

286,373✔

4588

      case PHY_QUERY_INSERT_CODE_TABLE_TYPE:

286,373✔

4589

        code = tlvDecodeI8(pTlv, &pNode->tableType);

286,373✔

4590

        break;

286,373✔

4591

      case PHY_QUERY_INSERT_CODE_TABLE_NAME:

286,373✔

4592

        code = tlvDecodeCStr(pTlv, pNode->tableName, sizeof(pNode->tableName));

286,373✔

4593

        break;

286,373✔

4594

      case PHY_QUERY_INSERT_CODE_VG_ID:

286,373✔

4595

        code = tlvDecodeI32(pTlv, &pNode->vgId);

286,373✔

4596

        break;

286,373✔

4597

      case PHY_QUERY_INSERT_CODE_EP_SET:

286,373✔

4598

        code = tlvDecodeObjFromTlv(pTlv, msgToEpSet, &pNode->epSet);

286,373✔

4599

        break;

286,373✔

4600

      case PHY_QUERY_INSERT_CODE_EXPLAIN:

286,373✔

4601

        code = tlvDecodeBool(pTlv, &pNode->explain);

286,373✔

4602

        break;

286,373✔

4608

  return code;

286,373✔

4623

static int32_t physiDeleteNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

1,803,701✔

4624

  const SDataDeleterNode* pNode = (const SDataDeleterNode*)pObj;

1,803,701✔

4626

  int32_t code = tlvEncodeObj(pEncoder, PHY_DELETER_CODE_SINK, physicDataSinkNodeToMsg, &pNode->sink);

1,803,701✔

4627

  if (TSDB_CODE_SUCCESS == code) {

1,803,701✔

4628

    code = tlvEncodeU64(pEncoder, PHY_DELETER_CODE_TABLE_ID, pNode->tableId);

1,803,701✔

4630

  if (TSDB_CODE_SUCCESS == code) {

1,803,701✔

4631

    code = tlvEncodeI8(pEncoder, PHY_DELETER_CODE_TABLE_TYPE, pNode->tableType);

1,803,701✔

4633

  if (TSDB_CODE_SUCCESS == code) {

1,803,701✔

4634

    code = tlvEncodeCStr(pEncoder, PHY_DELETER_CODE_TABLE_FNAME, pNode->tableFName);

1,803,701✔

4636

  if (TSDB_CODE_SUCCESS == code) {

1,803,701✔

4637

    code = tlvEncodeCStr(pEncoder, PHY_DELETER_CODE_TS_COL_NAME, pNode->tsColName);

1,803,701✔

4639

  if (TSDB_CODE_SUCCESS == code) {

1,803,701✔

4640

    code = tlvEncodeObj(pEncoder, PHY_DELETER_CODE_DELETE_TIME_RANGE, timeWindowToMsg, &pNode->deleteTimeRange);

1,803,701✔

4642

  if (TSDB_CODE_SUCCESS == code) {

1,803,701✔

4643

    code = tlvEncodeObj(pEncoder, PHY_DELETER_CODE_AFFECTED_ROWS, nodeToMsg, pNode->pAffectedRows);

1,803,701✔

4645

  if (TSDB_CODE_SUCCESS == code) {

1,803,701✔

4646

    code = tlvEncodeObj(pEncoder, PHY_DELETER_CODE_START_TS, nodeToMsg, pNode->pStartTs);

1,803,701✔

4648

  if (TSDB_CODE_SUCCESS == code) {

1,803,701✔

4649

    code = tlvEncodeObj(pEncoder, PHY_DELETER_CODE_END_TS, nodeToMsg, pNode->pEndTs);

1,803,701✔

4652

  return code;

1,803,701✔

4655

static int32_t msgToPhysiDeleteNode(STlvDecoder* pDecoder, void* pObj) {

1,799,574✔

4656

  SDataDeleterNode* pNode = (SDataDeleterNode*)pObj;

1,799,574✔

4658

  int32_t code = TSDB_CODE_SUCCESS;

1,799,574✔

4659

  STlv*   pTlv = NULL;

1,799,574✔

4660

  tlvForEach(pDecoder, pTlv, code) {

17,995,740✔

4661

    switch (pTlv->type) {

16,196,166✔

4662

      case PHY_DELETER_CODE_SINK:

1,799,574✔

4663

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysicDataSinkNode, &pNode->sink);

1,799,574✔

4664

        break;

1,799,574✔

4665

      case PHY_DELETER_CODE_TABLE_ID:

1,799,574✔

4666

        code = tlvDecodeU64(pTlv, &pNode->tableId);

1,799,574✔

4667

        break;

1,799,574✔

4668

      case PHY_DELETER_CODE_TABLE_TYPE:

1,799,574✔

4669

        code = tlvDecodeI8(pTlv, &pNode->tableType);

1,799,574✔

4670

        break;

1,799,574✔

4671

      case PHY_DELETER_CODE_TABLE_FNAME:

1,799,574✔

4672

        code = tlvDecodeCStr(pTlv, pNode->tableFName, sizeof(pNode->tableFName));

1,799,574✔

4673

        break;

1,799,574✔

4674

      case PHY_DELETER_CODE_TS_COL_NAME:

1,799,574✔

4675

        code = tlvDecodeCStr(pTlv, pNode->tsColName, sizeof(pNode->tsColName));

1,799,574✔

4676

        break;

1,799,574✔

4677

      case PHY_DELETER_CODE_DELETE_TIME_RANGE:

1,799,574✔

4678

        code = tlvDecodeObjFromTlv(pTlv, msgToTimeWindow, &pNode->deleteTimeRange);

1,799,574✔

4679

        break;

1,799,574✔

4680

      case PHY_DELETER_CODE_AFFECTED_ROWS:

1,799,574✔

4681

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pAffectedRows);

1,799,574✔

4682

        break;

1,799,574✔

4683

      case PHY_DELETER_CODE_START_TS:

1,799,574✔

4684

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pStartTs);

1,799,574✔

4685

        break;

1,799,574✔

4686

      case PHY_DELETER_CODE_END_TS:

1,799,574✔

4687

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pEndTs);

1,799,574✔

4688

        break;

1,799,574✔

4694

  return code;

1,799,574✔

4706

static int32_t physiGroupCacheNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

1,223,602✔

4707

  const SGroupCachePhysiNode* pNode = (const SGroupCachePhysiNode*)pObj;

1,223,602✔

4709

  int32_t code = tlvEncodeObj(pEncoder, PHY_GROUP_CACHE_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

1,223,602✔

4710

  if (TSDB_CODE_SUCCESS == code) {

1,223,602✔

4711

    code = tlvEncodeObj(pEncoder, PHY_GROUP_CACHE_CODE_GROUP_COLUMNS, nodeListToMsg, pNode->pGroupCols);

1,223,602✔

4713

  if (TSDB_CODE_SUCCESS == code) {

1,223,602✔

4714

    code = tlvEncodeBool(pEncoder, PHY_GROUP_CACHE_CODE_GROUP_COLS_MAY_BE_NULL, pNode->grpColsMayBeNull);

1,223,602✔

4716

  if (TSDB_CODE_SUCCESS == code) {

1,223,602✔

4717

    code = tlvEncodeBool(pEncoder, PHY_GROUP_CACHE_CODE_GROUP_BY_UID, pNode->grpByUid);

1,223,602✔

4719

  if (TSDB_CODE_SUCCESS == code) {

1,223,602✔

4720

    code = tlvEncodeBool(pEncoder, PHY_GROUP_CACHE_CODE_GLOBAL_GROUP, pNode->globalGrp);

1,223,602✔

4722

  if (TSDB_CODE_SUCCESS == code) {

1,223,602✔

4723

    code = tlvEncodeBool(pEncoder, PHY_GROUP_CACHE_CODE_BATCH_FETCH, pNode->batchFetch);

1,223,602✔

4726

  return code;

1,223,602✔

4729

static int32_t msgToPhysiGroupCacheNode(STlvDecoder* pDecoder, void* pObj) {

1,223,323✔

4730

  SGroupCachePhysiNode* pNode = (SGroupCachePhysiNode*)pObj;

1,223,323✔

4732

  int32_t code = TSDB_CODE_SUCCESS;

1,223,323✔

4733

  STlv*   pTlv = NULL;

1,223,323✔

4734

  tlvForEach(pDecoder, pTlv, code) {

7,339,938✔

4735

    switch (pTlv->type) {

6,116,615✔

4736

      case PHY_GROUP_CACHE_CODE_BASE_NODE:

1,223,323✔

4737

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

1,223,323✔

4738

        break;

1,223,323✔

4742

      case PHY_GROUP_CACHE_CODE_GROUP_COLS_MAY_BE_NULL:

1,223,323✔

4743

        code = tlvDecodeBool(pTlv, &pNode->grpColsMayBeNull);

1,223,323✔

4744

        break;

1,223,323✔

4745

      case PHY_GROUP_CACHE_CODE_GROUP_BY_UID:

1,223,323✔

4746

        code = tlvDecodeBool(pTlv, &pNode->grpByUid);

1,223,323✔

4747

        break;

1,223,323✔

4748

      case PHY_GROUP_CACHE_CODE_GLOBAL_GROUP:

1,223,323✔

4749

        code = tlvDecodeBool(pTlv, &pNode->globalGrp);

1,223,323✔

4750

        break;

1,223,323✔

4751

      case PHY_GROUP_CACHE_CODE_BATCH_FETCH:

1,223,323✔

4752

        code = tlvDecodeBool(pTlv, &pNode->batchFetch);

1,223,323✔

4753

        break;

1,223,323✔

4759

  return code;

1,223,323✔

4796

static int32_t physiDynQueryCtrlNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

5,262,429✔

4797

  const SDynQueryCtrlPhysiNode* pNode = (const SDynQueryCtrlPhysiNode*)pObj;

5,262,429✔

4799

  int32_t code = tlvEncodeObj(pEncoder, PHY_DYN_QUERY_CTRL_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

5,262,429✔

4800

  if (TSDB_CODE_SUCCESS == code) {

5,262,429✔

4801

    code = tlvEncodeEnum(pEncoder, PHY_DYN_QUERY_CTRL_CODE_QUERY_TYPE, pNode->qType);

5,262,429✔

4803

  if (TSDB_CODE_SUCCESS == code) {

5,262,429✔

4804

    switch (pNode->qType) {

5,262,429✔

4805

      case DYN_QTYPE_STB_HASH: {

1,223,602✔

4806

        code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_BATCH_FETCH, pNode->stbJoin.batchFetch);

1,223,602✔

4807

        if (TSDB_CODE_SUCCESS == code) {

1,223,602✔

4808

          code = tlvEncodeEnum(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT0, pNode->stbJoin.vgSlot[0]);

1,223,602✔

4810

        if (TSDB_CODE_SUCCESS == code) {

1,223,602✔

4811

          code = tlvEncodeEnum(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT1, pNode->stbJoin.vgSlot[1]);

1,223,602✔

4813

        if (TSDB_CODE_SUCCESS == code) {

1,223,602✔

4814

          code = tlvEncodeEnum(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_UID_SLOT0, pNode->stbJoin.uidSlot[0]);

1,223,602✔

4816

        if (TSDB_CODE_SUCCESS == code) {

1,223,602✔

4817

          code = tlvEncodeEnum(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_UID_SLOT1, pNode->stbJoin.uidSlot[1]);

1,223,602✔

4819

        if (TSDB_CODE_SUCCESS == code) {

1,223,602✔

4820

          code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_SRC_SCAN0, pNode->stbJoin.srcScan[0]);

1,223,602✔

4822

        if (TSDB_CODE_SUCCESS == code) {

1,223,602✔

4823

          code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_SRC_SCAN1, pNode->stbJoin.srcScan[1]);

1,223,602✔

4825

        break;

1,223,602✔

4827

      case DYN_QTYPE_VTB_WINDOW: {

524,189✔

4828

        code = tlvEncodeI32(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_WSTART_SLOTID, pNode->vtbWindow.wstartSlotId);

524,189✔

4829

        if (TSDB_CODE_SUCCESS == code) {

524,189✔

4830

          code = tlvEncodeI32(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_WEND_SLOTID, pNode->vtbWindow.wendSlotId);

524,189✔

4832

        if (TSDB_CODE_SUCCESS == code) {

524,189✔

4833

          code = tlvEncodeI32(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_WDURATION_SLOTID, pNode->vtbWindow.wdurationSlotId);

524,189✔

4835

        if (TSDB_CODE_SUCCESS == code) {

524,189✔

4836

          code = tlvEncodeObj(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_TARGETS, nodeListToMsg, pNode->vtbWindow.pTargets);

524,189✔

4838

        if (TSDB_CODE_SUCCESS == code) {

524,189✔

4839

          code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_IS_VSTB, pNode->vtbWindow.isVstb);

524,189✔

4841

        if (TSDB_CODE_SUCCESS == code) {

524,189✔

4842

          code = tlvEncodeI32(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_STATE_EXTEND_OPTION, pNode->vtbWindow.extendOption);

524,189✔

4850

        code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_SCAN_ALL_COLS, pNode->vtbScan.scanAllCols);

4,038,827✔

4851

        if (TSDB_CODE_SUCCESS == code) {

4,038,827✔

4852

          code = tlvEncodeU64(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_SUID, pNode->vtbScan.suid);

4,038,827✔

4854

        if (TSDB_CODE_SUCCESS == code) {

4,038,827✔

4855

          code = tlvEncodeCStr(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_DBNAME, pNode->vtbScan.dbName);

4,038,827✔

4857

        if (TSDB_CODE_SUCCESS == code) {

4,038,827✔

4858

          code = tlvEncodeCStr(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_STBNAME, pNode->vtbScan.tbName);

4,038,827✔

4860

        if (TSDB_CODE_SUCCESS == code) {

4,038,827✔

4861

          code = tlvEncodeI32(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_ACCOUNT_ID, pNode->vtbScan.accountId);

4,038,827✔

4863

        if (TSDB_CODE_SUCCESS == code) {

4,038,827✔

4864

          code = tlvEncodeObj(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_EP_SET, epSetToMsg, &pNode->vtbScan.mgmtEpSet);

4,038,827✔

4866

        if (TSDB_CODE_SUCCESS == code) {

4,038,827✔

4867

          code = tlvEncodeObj(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_SCAN_COLS, nodeListToMsg, pNode->vtbScan.pScanCols);

4,038,827✔

4869

        if (TSDB_CODE_SUCCESS == code) {

4,038,827✔

4870

          code = tlvEncodeU64(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_UID, pNode->vtbScan.uid);

4,038,827✔

4872

        if (TSDB_CODE_SUCCESS == code) {

4,038,827✔

4873

          code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_IS_SUPER_TABLE, pNode->vtbScan.isSuperTable);

4,038,827✔

4875

        if (TSDB_CODE_SUCCESS == code) {

4,038,827✔

4876

          code = tlvEncodeI32(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_RVERSION, pNode->vtbScan.rversion);

4,038,827✔

4878

        if (TSDB_CODE_SUCCESS == code) {

4,038,827✔

4879

          code = tlvEncodeObj(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_ORG_VG_IDS, nodeListToMsg, pNode->vtbScan.pOrgVgIds);

4,038,827✔

4881

        if (TSDB_CODE_SUCCESS == code) {

4,038,827✔

4882

          code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_BATCH_PROCESS_CHILD, pNode->vtbScan.batchProcessChild);

4,038,827✔

4884

        if (TSDB_CODE_SUCCESS == code) {

4,038,827✔

4885

          code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_HAS_PARTITION, pNode->vtbScan.hasPartition);

4,038,827✔

4887

        break;

4,038,827✔

4893

  if (TSDB_CODE_SUCCESS == code) {

5,262,429✔

4894

    code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_DYN_TBNAME, pNode->dynTbname);

5,262,429✔

4896

  return code;

5,262,429✔

4899

static int32_t msgToPhysiDynQueryCtrlNode(STlvDecoder* pDecoder, void* pObj) {

3,389,349✔

4900

  SDynQueryCtrlPhysiNode* pNode = (SDynQueryCtrlPhysiNode*)pObj;

3,389,349✔

4902

  int32_t code = TSDB_CODE_SUCCESS;

3,389,349✔

4903

  STlv*   pTlv = NULL;

3,389,349✔

4904

  tlvForEach(pDecoder, pTlv, code) {

53,085,600✔

4905

    switch (pTlv->type) {

49,696,251✔

4906

      case PHY_DYN_QUERY_CTRL_CODE_BASE_NODE:

3,389,349✔

4907

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

3,389,349✔

4908

        break;

3,389,349✔

4909

      case PHY_DYN_QUERY_CTRL_CODE_QUERY_TYPE:

3,389,349✔

4910

        code = tlvDecodeEnum(pTlv, &pNode->qType, sizeof(pNode->qType));

3,389,349✔

4911

        break;

3,389,349✔

4912

      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_BATCH_FETCH:

1,223,323✔

4913

        code = tlvDecodeBool(pTlv, &pNode->stbJoin.batchFetch);

1,223,323✔

4914

        break;

1,223,323✔

4915

      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT0:

1,223,323✔

4916

        code = tlvDecodeEnum(pTlv, &pNode->stbJoin.vgSlot[0], sizeof(pNode->stbJoin.vgSlot[0]));

1,223,323✔

4917

        break;

1,223,323✔

4918

      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT1:

1,223,323✔

4919

        code = tlvDecodeEnum(pTlv, &pNode->stbJoin.vgSlot[1], sizeof(pNode->stbJoin.vgSlot[1]));

1,223,323✔

4920

        break;

1,223,323✔

4921

      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_UID_SLOT0:

1,223,323✔

4922

        code = tlvDecodeEnum(pTlv, &pNode->stbJoin.uidSlot[0], sizeof(pNode->stbJoin.uidSlot[0]));

1,223,323✔

4923

        break;

1,223,323✔

4924

      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_UID_SLOT1:

1,223,323✔

4925

        code = tlvDecodeEnum(pTlv, &pNode->stbJoin.uidSlot[1], sizeof(pNode->stbJoin.uidSlot[1]));

1,223,323✔

4926

        break;

1,223,323✔

4927

      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_SRC_SCAN0:

1,223,323✔

4928

        code = tlvDecodeBool(pTlv, &pNode->stbJoin.srcScan[0]);

1,223,323✔

4929

        break;

1,223,323✔

4930

      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_SRC_SCAN1:

1,223,323✔

4931

        code = tlvDecodeBool(pTlv, &pNode->stbJoin.srcScan[1]);

1,223,323✔

4932

        break;

1,223,323✔

4933

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_SCAN_ALL_COLS:

2,166,026✔

4934

        code = tlvDecodeBool(pTlv, &pNode->vtbScan.scanAllCols);

2,166,026✔

4935

        break;

2,166,026✔

4936

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_SUID:

2,166,026✔

4937

        code = tlvDecodeU64(pTlv, &pNode->vtbScan.suid);

2,166,026✔

4938

        break;

2,166,026✔

4939

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_DBNAME:

2,166,026✔

4940

        code = tlvDecodeCStr(pTlv, pNode->vtbScan.dbName, sizeof(pNode->vtbScan.dbName));

2,166,026✔

4941

        break;

2,166,026✔

4942

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_STBNAME:

2,166,026✔

4943

        code = tlvDecodeCStr(pTlv, pNode->vtbScan.tbName, sizeof(pNode->vtbScan.tbName));

2,166,026✔

4944

        break;

2,166,026✔

4945

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_ACCOUNT_ID:

2,166,026✔

4946

        code = tlvDecodeI32(pTlv, &pNode->vtbScan.accountId);

2,166,026✔

4947

        break;

2,166,026✔

4948

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_EP_SET:

2,166,026✔

4949

        code = tlvDecodeObjFromTlv(pTlv, msgToEpSet, &pNode->vtbScan.mgmtEpSet);

2,166,026✔

4950

        break;

2,166,026✔

4951

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_SCAN_COLS:

2,166,026✔

4952

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->vtbScan.pScanCols);

2,166,026✔

4953

        break;

2,166,026✔

4954

      case PHY_DYN_QUERY_CTRL_CODE_DYN_TBNAME:

3,389,349✔

4955

        code = tlvDecodeBool(pTlv, &pNode->dynTbname);

3,389,349✔

4956

        break;

3,389,349✔

4957

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_UID:

2,166,026✔

4958

        code = tlvDecodeU64(pTlv, &pNode->vtbScan.uid);

2,166,026✔

4959

        break;

2,166,026✔

4960

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_IS_SUPER_TABLE:

2,166,026✔

4961

        code = tlvDecodeBool(pTlv, &pNode->vtbScan.isSuperTable);

2,166,026✔

4962

        break;

2,166,026✔

4963

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_RVERSION:

2,166,026✔

4964

        code = tlvDecodeI32(pTlv, &pNode->vtbScan.rversion);

2,166,026✔

4965

        break;

2,166,026✔

4966

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_ORG_VG_IDS:

1,864,553✔

4967

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->vtbScan.pOrgVgIds);

1,864,553✔

4968

        break;

1,864,553✔

4969

      case PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_WSTART_SLOTID:

518,013✔

4970

        code = tlvDecodeI32(pTlv, &pNode->vtbWindow.wstartSlotId);

518,013✔

4971

        break;

518,013✔

4972

      case PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_WEND_SLOTID:

518,013✔

4973

        code = tlvDecodeI32(pTlv, &pNode->vtbWindow.wendSlotId);

518,013✔

4974

        break;

518,013✔

4975

      case PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_WDURATION_SLOTID:

518,013✔

4976

        code = tlvDecodeI32(pTlv, &pNode->vtbWindow.wdurationSlotId);

518,013✔

4977

        break;

518,013✔

4978

      case PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_TARGETS:

518,013✔

4979

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->vtbWindow.pTargets);

518,013✔

4980

        break;

518,013✔

4981

      case PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_IS_VSTB:

518,013✔

4982

        code = tlvDecodeBool(pTlv, &pNode->vtbWindow.isVstb);

518,013✔

4983

        break;

518,013✔

4984

      case PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_STATE_EXTEND_OPTION:

518,013✔

4985

        code = tlvDecodeI32(pTlv, (int32_t*)&pNode->vtbWindow.extendOption);

518,013✔

4986

        break;

518,013✔

4987

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_BATCH_PROCESS_CHILD:

2,166,026✔

4988

        code = tlvDecodeBool(pTlv, &pNode->vtbScan.batchProcessChild);

2,166,026✔

4989

        break;

2,166,026✔

4990

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_HAS_PARTITION:

2,166,026✔

4991

        code = tlvDecodeBool(pTlv, &pNode->vtbScan.hasPartition);

2,166,026✔

4992

        break;

2,166,026✔

4998

  return code;

3,389,349✔

5005

static int32_t subplanIdInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {

511,185,761✔

5006

  const SSubplanId* pNode = (const SSubplanId*)pObj;

511,185,761✔

5008

  int32_t code = tlvEncodeValueU64(pEncoder, pNode->queryId);

511,185,761✔

5009

  if (TSDB_CODE_SUCCESS == code) {

510,259,587✔

5010

    code = tlvEncodeValueI32(pEncoder, pNode->groupId);

510,313,511✔

5012

  if (TSDB_CODE_SUCCESS == code) {

510,921,901✔

5013

    code = tlvEncodeValueI32(pEncoder, pNode->subplanId);

510,876,099✔

5016

  return code;

511,055,309✔

5033

static int32_t msgToSubplanIdInline(STlvDecoder* pDecoder, void* pObj) {

358,902,476✔

5034

  SSubplanId* pNode = (SSubplanId*)pObj;

358,902,476✔

5036

  int32_t code = tlvDecodeValueU64(pDecoder, &pNode->queryId);

358,902,476✔

5037

  if (TSDB_CODE_SUCCESS == code) {

358,815,572✔

5038

    code = tlvDecodeValueI32(pDecoder, &pNode->groupId);

358,819,638✔

5040

  if (TSDB_CODE_SUCCESS == code) {

358,910,556✔

5041

    code = tlvDecodeValueI32(pDecoder, &pNode->subplanId);

358,910,556✔

5044

  return code;

358,919,265✔

5079

static int32_t subplanInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {

511,195,820✔

5080

  const SSubplan* pNode = (const SSubplan*)pObj;

511,195,820✔

5082

  int32_t code = subplanIdInlineToMsg(&pNode->id, pEncoder);

511,195,820✔

5083

  if (TSDB_CODE_SUCCESS == code) {

511,048,082✔

5084

    code = tlvEncodeValueEnum(pEncoder, pNode->subplanType);

511,055,632✔

5086

  if (TSDB_CODE_SUCCESS == code) {

511,229,613✔

5087

    code = tlvEncodeValueI32(pEncoder, pNode->msgType);

511,203,278✔

5089

  if (TSDB_CODE_SUCCESS == code) {

511,145,113✔

5090

    code = tlvEncodeValueI32(pEncoder, pNode->level);

511,126,466✔

5092

  if (TSDB_CODE_SUCCESS == code) {

511,288,135✔

5093

    code = tlvEncodeValueCStr(pEncoder, pNode->dbFName);

511,270,602✔

5095

  if (TSDB_CODE_SUCCESS == code) {

511,219,736✔

5096

    code = tlvEncodeValueCStr(pEncoder, pNode->user);

511,206,166✔

5098

  if (TSDB_CODE_SUCCESS == code) {

511,320,836✔

5099

    code = queryNodeAddrInlineToMsg(&pNode->execNode, pEncoder);

511,280,606✔

5101

  if (TSDB_CODE_SUCCESS == code) {

511,053,730✔

5102

    code = tlvEncodeValueBool(pEncoder, pNode->showRewrite);

511,013,738✔

5104

  if (TSDB_CODE_SUCCESS == code) {

511,344,763✔

5105

    code = tlvEncodeValueI32(pEncoder, pNode->rowsThreshold);

511,312,921✔

5107

  if (TSDB_CODE_SUCCESS == code) {

511,236,993✔

5108

    code = tlvEncodeValueBool(pEncoder, pNode->dynamicRowThreshold);

511,206,654✔

5110

  if (TSDB_CODE_SUCCESS == code) {

511,242,711✔

5111

    code = tlvEncodeValueBool(pEncoder, pNode->isView);

511,173,914✔

5113

  if (TSDB_CODE_SUCCESS == code) {

511,306,737✔

5114

    code = tlvEncodeValueBool(pEncoder, pNode->isAudit);

511,247,704✔

5116

  if (TSDB_CODE_SUCCESS == code) {

511,399,920✔

5117

    code = tlvEncodeValueBool(pEncoder, pNode->processOneBlock);

511,349,479✔

5119

  if (TSDB_CODE_SUCCESS == code) {

511,309,265✔

5120

    code = tlvEncodeValueBool(pEncoder, pNode->dynTbname);

511,269,149✔

5122

  return code;

511,357,474✔

5125

static int32_t subplanToMsg(const void* pObj, STlvEncoder* pEncoder) {

511,196,517✔

5126

  const SSubplan* pNode = (const SSubplan*)pObj;

511,196,517✔

5128

  int32_t code = tlvEncodeObj(pEncoder, SUBPLAN_CODE_INLINE_ATTRS, subplanInlineToMsg, pNode);

511,196,517✔

5129

  if (TSDB_CODE_SUCCESS == code) {

511,050,768✔

5130

    code = tlvEncodeObj(pEncoder, SUBPLAN_CODE_ROOT_NODE, nodeToMsg, pNode->pNode);

511,063,752✔

5132

  if (TSDB_CODE_SUCCESS == code) {

511,280,182✔

5133

    code = tlvEncodeObj(pEncoder, SUBPLAN_CODE_DATA_SINK, nodeToMsg, pNode->pDataSink);

511,285,959✔

5135

  if (TSDB_CODE_SUCCESS == code) {

511,437,504✔

5136

    code = tlvEncodeObj(pEncoder, SUBPLAN_CODE_TAG_COND, nodeToMsg, pNode->pTagCond);

511,443,887✔

5138

  if (TSDB_CODE_SUCCESS == code) {

511,173,442✔

5139

    code = tlvEncodeObj(pEncoder, SUBPLAN_CODE_TAG_INDEX_COND, nodeToMsg, pNode->pTagIndexCond);

511,178,657✔

5142

  return code;

510,863,284✔

5145

static int32_t msgToSubplanInline(STlvDecoder* pDecoder, void* pObj) {

358,901,710✔

5146

  SSubplan* pNode = (SSubplan*)pObj;

358,901,710✔

5148

  int32_t code = msgToSubplanIdInline(pDecoder, &pNode->id);

358,901,710✔

5149

  if (TSDB_CODE_SUCCESS == code) {

358,918,735✔

5150

    code = tlvDecodeValueEnum(pDecoder, &pNode->subplanType, sizeof(pNode->subplanType));

358,887,255✔

5152

  if (TSDB_CODE_SUCCESS == code) {

358,783,752✔

5153

    code = tlvDecodeValueI32(pDecoder, &pNode->msgType);

358,783,752✔

5155

  if (TSDB_CODE_SUCCESS == code) {

358,897,672✔

5156

    code = tlvDecodeValueI32(pDecoder, &pNode->level);

358,897,672✔

5158

  if (TSDB_CODE_SUCCESS == code) {

358,902,088✔

5159

    code = tlvDecodeValueCStr(pDecoder, pNode->dbFName);

358,902,088✔

5161

  if (TSDB_CODE_SUCCESS == code) {

358,900,201✔

5162

    code = tlvDecodeValueCStr(pDecoder, pNode->user);

358,900,201✔

5164

  if (TSDB_CODE_SUCCESS == code) {

358,934,830✔

5165

    code = msgToQueryNodeAddrInline(pDecoder, &pNode->execNode);

358,934,830✔

5167

  if (TSDB_CODE_SUCCESS == code) {

358,914,243✔

5168

    code = tlvDecodeValueBool(pDecoder, &pNode->showRewrite);

358,914,243✔

5170

  if (TSDB_CODE_SUCCESS == code) {

358,904,546✔

5171

    code = tlvDecodeValueI32(pDecoder, &pNode->rowsThreshold);

358,904,546✔

5173

  if (TSDB_CODE_SUCCESS == code) {

358,926,804✔

5174

    code = tlvDecodeValueBool(pDecoder, &pNode->dynamicRowThreshold);

358,926,804✔

5176

  if (TSDB_CODE_SUCCESS == code) {

358,919,890✔

5177

    code = tlvDecodeValueBool(pDecoder, &pNode->isView);

358,919,890✔

5179

  if (TSDB_CODE_SUCCESS == code) {

358,926,666✔

5180

    code = tlvDecodeValueBool(pDecoder, &pNode->isAudit);

358,926,666✔

5182

  if (TSDB_CODE_SUCCESS == code) {

358,923,120✔

5183

    code = tlvDecodeValueBool(pDecoder, &pNode->processOneBlock);

358,923,120✔

5185

  if (TSDB_CODE_SUCCESS == code) {

358,926,889✔

5186

    code = tlvDecodeValueBool(pDecoder, &pNode->dynTbname);

358,926,889✔

5188

  return code;

358,923,267✔

5191

static int32_t msgToSubplan(STlvDecoder* pDecoder, void* pObj) {

358,894,721✔

5192

  SSubplan* pNode = (SSubplan*)pObj;

358,894,721✔

5194

  int32_t code = TSDB_CODE_SUCCESS;

358,894,721✔

5195

  STlv*   pTlv = NULL;

358,894,721✔

5196

  tlvForEach(pDecoder, pTlv, code) {

1,454,604,570✔

5197

    switch (pTlv->type) {

1,095,758,884✔

5198

      case SUBPLAN_CODE_INLINE_ATTRS:

358,883,903✔

5199

        code = tlvDecodeObjFromTlv(pTlv, msgToSubplanInline, pNode);

358,883,903✔

5200

        break;

358,888,493✔

5201

      case SUBPLAN_CODE_ROOT_NODE:

358,930,688✔

5202

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pNode);

358,930,688✔

5203

        break;

358,910,586✔

5204

      case SUBPLAN_CODE_DATA_SINK:

358,925,994✔

5205

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pDataSink);

358,925,994✔

5206

        break;

358,925,002✔

5207

      case SUBPLAN_CODE_TAG_COND:

14,417,970✔

5208

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pTagCond);

14,417,970✔

5209

        break;

14,415,339✔

5210

      case SUBPLAN_CODE_TAG_INDEX_COND:

4,595,054✔

5211

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pTagIndexCond);

4,595,054✔

5212

        break;

4,550,950✔

5218

  return code;

358,954,208✔

5223

static int32_t queryPlanInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,352✔

5224

  const SQueryPlan* pNode = (const SQueryPlan*)pObj;

2,352✔

5226

  int32_t code = tlvEncodeValueU64(pEncoder, pNode->queryId);

2,352✔

5227

  if (TSDB_CODE_SUCCESS == code) {

2,352✔

5228

    code = tlvEncodeValueI32(pEncoder, pNode->numOfSubplans);

2,352✔

5231

  return code;

2,352✔

5234

static int32_t queryPlanToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,352✔

5235

  const SQueryPlan* pNode = (const SQueryPlan*)pObj;

2,352✔

5237

  int32_t code = tlvEncodeObj(pEncoder, QUERY_PLAN_CODE_INLINE_ATTRS, queryPlanInlineToMsg, pNode);

2,352✔

5238

  if (TSDB_CODE_SUCCESS == code) {

2,352✔

5239

    code = tlvEncodeObj(pEncoder, QUERY_PLAN_CODE_SUBPLANS, nodeListToMsg, pNode->pSubplans);

2,352✔

5242

  return code;

2,352✔

5245

static int32_t msgToQueryPlanInline(STlvDecoder* pDecoder, void* pObj) {

1,176✔

5246

  SQueryPlan* pNode = (SQueryPlan*)pObj;

1,176✔

5248

  int32_t code = tlvDecodeValueU64(pDecoder, &pNode->queryId);

1,176✔

5249

  if (TSDB_CODE_SUCCESS == code) {

1,176✔

5250

    code = tlvDecodeValueI32(pDecoder, &pNode->numOfSubplans);

1,176✔

5253

  return code;

1,176✔

5256

static int32_t msgToQueryPlan(STlvDecoder* pDecoder, void* pObj) {

1,176✔

5257

  SQueryPlan* pNode = (SQueryPlan*)pObj;

1,176✔

5259

  int32_t code = TSDB_CODE_SUCCESS;

1,176✔

5260

  STlv*   pTlv = NULL;

1,176✔

5261

  tlvForEach(pDecoder, pTlv, code) {

3,528✔

5262

    switch (pTlv->type) {

2,352✔

5263

      case QUERY_PLAN_CODE_INLINE_ATTRS:

1,176✔

5264

        code = tlvDecodeObjFromTlv(pTlv, msgToQueryPlanInline, pNode);

1,176✔

5265

        break;

1,176✔

5266

      case QUERY_PLAN_CODE_SUBPLANS:

1,176✔

5267

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pSubplans);

1,176✔

5268

        break;

1,176✔

5274

  return code;

1,176✔

5277

static int32_t specificNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,147,483,647✔

5279

  int32_t code = TSDB_CODE_SUCCESS;

2,147,483,647✔

5280

  switch (nodeType(pObj)) {

2,147,483,647✔

5281

    case QUERY_NODE_COLUMN:

2,147,483,647✔

5282

      code = columnNodeToMsg(pObj, pEncoder);

2,147,483,647✔

5283

      break;

2,147,483,647✔

5284

    case QUERY_NODE_VALUE:

470,488,096✔

5285

      code = valueNodeToMsg(pObj, pEncoder);

470,488,096✔

5286

      break;

470,386,898✔

5287

    case QUERY_NODE_OPERATOR:

321,287,968✔

5288

      code = operatorNodeToMsg(pObj, pEncoder);

321,287,968✔

5289

      break;

321,288,305✔

5290

    case QUERY_NODE_LOGIC_CONDITION:

48,481,324✔

5291

      code = logicConditionNodeToMsg(pObj, pEncoder);

48,481,324✔

5292

      break;

48,495,757✔

5293

    case QUERY_NODE_FUNCTION:

698,286,973✔

5294

      code = functionNodeToMsg(pObj, pEncoder);

698,286,973✔

5295

      break;

698,309,821✔

5296

    case QUERY_NODE_ORDER_BY_EXPR:

92,562,109✔

5297

      code = orderByExprNodeToMsg(pObj, pEncoder);

92,562,109✔

5298

      break;

92,569,314✔

5299

    case QUERY_NODE_LIMIT:

41,238,741✔

5300

      code = limitNodeToMsg(pObj, pEncoder);

41,238,741✔

5301

      break;

41,255,304✔

5302

    case QUERY_NODE_NODE_LIST:

11,096,421✔

5303

      code = nodeListNodeToMsg(pObj, pEncoder);

11,096,421✔

5304

      break;

11,101,192✔

5305

    case QUERY_NODE_TARGET:

2,147,483,647✔

5306

      code = targetNodeToMsg(pObj, pEncoder);

2,147,483,647✔

5307

      break;

2,147,483,647✔

5311

    case QUERY_NODE_DATABLOCK_DESC:

1,588,367,254✔

5312

      code = dataBlockDescNodeToMsg(pObj, pEncoder);

1,588,367,254✔

5313

      break;

1,589,524,026✔

5314

    case QUERY_NODE_SLOT_DESC:

2,147,483,647✔

5315

      code = slotDescNodeToMsg(pObj, pEncoder);

2,147,483,647✔

5316

      break;

2,147,483,647✔

5317

    case QUERY_NODE_DOWNSTREAM_SOURCE:

241,847,351✔

5318

      code = downstreamSourceNodeToMsg(pObj, pEncoder);

241,847,351✔

5319

      break;

241,846,361✔

5320

    case QUERY_NODE_LEFT_VALUE:

7,409,467✔

5321

      break;

7,409,467✔

5322

    case QUERY_NODE_WHEN_THEN:

7,160,446✔

5323

      code = whenThenNodeToMsg(pObj, pEncoder);

7,160,446✔

5324

      break;

7,160,446✔

5325

    case QUERY_NODE_CASE_WHEN:

6,977,851✔

5326

      code = caseWhenNodeToMsg(pObj, pEncoder);

6,977,851✔

5327

      break;

6,978,368✔

5328

    case QUERY_NODE_WINDOW_OFFSET:

325,560✔

5329

      code = windowOffsetNodeToMsg(pObj, pEncoder);

325,560✔

5330

      break;

325,560✔

5331

    case QUERY_NODE_REMOTE_VALUE:

60,192,526✔

5332

      code = remoteValueNodeToMsg(pObj, pEncoder);

60,192,526✔

5333

      break;

60,192,087✔

5334

    case QUERY_NODE_REMOTE_VALUE_LIST:

18,289,614✔

5335

      code = remoteValueListNodeToMsg(pObj, pEncoder);

18,289,614✔

5336

      break;

18,291,830✔

5337

    case QUERY_NODE_REMOTE_ROW:

23,250,529✔

5338

      code = remoteRowNodeToMsg(pObj, pEncoder);

23,250,529✔

5339

      break;

23,250,442✔

5340

    case QUERY_NODE_REMOTE_ZERO_ROWS:

1,310,178✔

5341

      code = remoteZeroRowsNodeToMsg(pObj, pEncoder);

1,310,178✔

5342

      break;

1,309,028✔

5343

    case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN:

14,299,152✔

5344

      code = physiTagScanNodeToMsg(pObj, pEncoder);

14,299,152✔

5345

      break;

14,288,321✔

5346

    case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN:

5,469✔

5347

      code = physiScanNodeToMsg(pObj, pEncoder);

5,469✔

5348

      break;

5,469✔

5349

    case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN:

1,237,141✔

5351

      code = physiLastRowScanNodeToMsg(pObj, pEncoder);

1,237,141✔

5352

      break;

1,237,391✔

5353

    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:

376,501,540✔

5356

      code = physiTableScanNodeToMsg(pObj, pEncoder);

376,501,540✔

5357

      break;

375,636,070✔

5358

    case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN:

31,275,310✔

5359

      code = physiSysTableScanNodeToMsg(pObj, pEncoder);

31,275,310✔

5360

      break;

31,277,450✔

5361

    case QUERY_NODE_PHYSICAL_PLAN_PROJECT:

208,694,566✔

5362

      code = physiProjectNodeToMsg(pObj, pEncoder);

208,694,566✔

5363

      break;

208,774,146✔

5364

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN:

15,872,665✔

5365

      code = physiMergeJoinNodeToMsg(pObj, pEncoder);

15,872,665✔

5366

      break;

15,872,665✔

5367

    case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN:

1,224,398✔

5368

      code = physiHashJoinNodeToMsg(pObj, pEncoder);

1,224,398✔

5369

      break;

1,224,398✔

5370

    case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG:

163,546,706✔

5371

      code = physiAggNodeToMsg(pObj, pEncoder);

163,546,706✔

5372

      break;

163,607,499✔

5373

    case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE:

142,573,067✔

5374

      code = physiExchangeNodeToMsg(pObj, pEncoder);

142,573,067✔

5375

      break;

142,573,204✔

5376

    case QUERY_NODE_PHYSICAL_PLAN_MERGE:

18,263,404✔

5377

      code = physiMergeNodeToMsg(pObj, pEncoder);

18,263,404✔

5378

      break;

18,263,471✔

5379

    case QUERY_NODE_PHYSICAL_PLAN_SORT:

53,429,499✔

5381

      code = physiSortNodeToMsg(pObj, pEncoder);

53,429,499✔

5382

      break;

53,438,807✔

5383

    case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL:

13,332,019✔

5385

      code = physiIntervalNodeToMsg(pObj, pEncoder);

13,332,019✔

5386

      break;

13,332,002✔

5387

    case QUERY_NODE_PHYSICAL_PLAN_FILL:

513,405✔

5388

      code = physiFillNodeToMsg(pObj, pEncoder);

513,405✔

5389

      break;

514,626✔

5390

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION:

2,403,918✔

5391

      code = physiSessionWindowNodeToMsg(pObj, pEncoder);

2,403,918✔

5392

      break;

2,403,511✔

5393

    case QUERY_NODE_PHYSICAL_PLAN_EXTERNAL_WINDOW:

947,585✔

5396

      code = physiExternalWindowNodeToMsg(pObj, pEncoder);

947,585✔

5397

      break;

947,585✔

5398

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE:

2,369,324✔

5399

      code = physiStateWindowNodeToMsg(pObj, pEncoder);

2,369,324✔

5400

      break;

2,370,160✔

5401

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT:

1,765,120✔

5402

      code = physiEventWindowNodeToMsg(pObj, pEncoder);

1,765,120✔

5403

      break;

1,764,805✔

5404

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_COUNT:

1,627,185✔

5405

      code = physiCountWindowNodeToMsg(pObj, pEncoder);

1,627,185✔

5406

      break;

1,627,185✔

5410

    case QUERY_NODE_PHYSICAL_PLAN_PARTITION:

10,564,154✔

5411

      code = physiPartitionNodeToMsg(pObj, pEncoder);

10,564,154✔

5412

      break;

10,570,500✔

5413

    case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC:

3,147,018✔

5414

      code = physiIndefRowsFuncNodeToMsg(pObj, pEncoder);

3,147,018✔

5415

      break;

3,151,403✔

5416

    case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC:

3,451,522✔

5417

      code = physiInterpFuncNodeToMsg(pObj, pEncoder);

3,451,522✔

5418

      break;

3,451,522✔

5423

    case QUERY_NODE_PHYSICAL_PLAN_DISPATCH:

508,823,808✔

5424

      code = physiDispatchNodeToMsg(pObj, pEncoder);

508,823,808✔

5425

      break;

508,969,053✔

5426

    case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT:

286,779✔

5427

      code = physiQueryInsertNodeToMsg(pObj, pEncoder);

286,779✔

5428

      break;

286,779✔

5429

    case QUERY_NODE_PHYSICAL_PLAN_DELETE:

1,803,701✔

5430

      code = physiDeleteNodeToMsg(pObj, pEncoder);

1,803,701✔

5431

      break;

1,803,701✔

5432

    case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE:

1,223,602✔

5433

      code = physiGroupCacheNodeToMsg(pObj, pEncoder);

1,223,602✔

5434

      break;

1,223,602✔

5435

    case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL:

5,262,429✔

5436

      code = physiDynQueryCtrlNodeToMsg(pObj, pEncoder);

5,262,429✔

5437

      break;

5,262,429✔

5438

    case QUERY_NODE_PHYSICAL_PLAN_VIRTUAL_TABLE_SCAN:

4,264,891✔

5439

      code = physiVirtualTableScanNodeToMsg(pObj, pEncoder);

4,264,891✔

5440

      break;

4,264,891✔

5441

    case QUERY_NODE_PHYSICAL_SUBPLAN:

511,278,698✔

5442

      code = subplanToMsg(pObj, pEncoder);

511,278,698✔

5443

      break;

510,941,678✔

5444

    case QUERY_NODE_PHYSICAL_PLAN:

2,570✔

5445

      code = queryPlanToMsg(pObj, pEncoder);

2,570✔

5446

      break;

2,352✔

5450

  if (TSDB_CODE_SUCCESS != code) {

2,147,483,647✔

5454

  return code;

2,147,483,647✔

5457

static int32_t msgToSpecificNode(STlvDecoder* pDecoder, void* pObj) {

2,147,483,647✔

5458

  int32_t code = TSDB_CODE_SUCCESS;

2,147,483,647✔

5459

  switch (nodeType(pObj)) {

2,147,483,647✔

5460

    case QUERY_NODE_COLUMN:

2,147,483,647✔

5461

      code = msgToColumnNode(pDecoder, pObj);

2,147,483,647✔

5462

      break;

2,147,483,647✔

5463

    case QUERY_NODE_VALUE:

390,533,903✔

5464

      code = msgToValueNode(pDecoder, pObj);

390,533,903✔

5465

      break;

390,505,705✔

5466

    case QUERY_NODE_OPERATOR:

262,048,749✔

5467

      code = msgToOperatorNode(pDecoder, pObj);

262,048,749✔

5468

      break;

262,036,015✔

5469

    case QUERY_NODE_LOGIC_CONDITION:

44,505,117✔

5470

      code = msgToLogicConditionNode(pDecoder, pObj);

44,505,117✔

5471

      break;

44,504,061✔

5472

    case QUERY_NODE_FUNCTION:

575,670,972✔

5473

      code = msgToFunctionNode(pDecoder, pObj);

575,670,972✔

5474

      break;

575,650,753✔

5475

    case QUERY_NODE_ORDER_BY_EXPR:

60,725,911✔

5476

      code = msgToOrderByExprNode(pDecoder, pObj);

60,725,911✔

5477

      break;

60,727,290✔

5478

    case QUERY_NODE_LIMIT:

34,884,612✔

5479

      code = msgToLimitNode(pDecoder, pObj);

34,884,612✔

5480

      break;

34,884,830✔

5481

    case QUERY_NODE_NODE_LIST:

7,570,224✔

5482

      code = msgToNodeListNode(pDecoder, pObj);

7,570,224✔

5483

      break;

7,570,224✔

5484

    case QUERY_NODE_TARGET:

2,147,483,647✔

5485

      code = msgToTargetNode(pDecoder, pObj);

2,147,483,647✔

5486

      break;

2,147,483,647✔

5490

    case QUERY_NODE_DATABLOCK_DESC:

1,127,438,033✔

5491

      code = msgToDataBlockDescNode(pDecoder, pObj);

1,127,438,033✔

5492

      break;

1,127,436,458✔

5493

    case QUERY_NODE_SLOT_DESC:

2,147,483,647✔

5494

      code = msgToSlotDescNode(pDecoder, pObj);

2,147,483,647✔

5495

      break;

2,147,483,647✔

5496

    case QUERY_NODE_DOWNSTREAM_SOURCE:

179,582,280✔

5497

      code = msgToDownstreamSourceNode(pDecoder, pObj);

179,582,280✔

5498

    case QUERY_NODE_LEFT_VALUE:

186,976,960✔

5499

      break;

186,976,960✔

5500

    case QUERY_NODE_WHEN_THEN:

1,621,401✔

5501

      code = msgToWhenThenNode(pDecoder, pObj);

1,621,401✔

5502

      break;

1,621,401✔

5503

    case QUERY_NODE_CASE_WHEN:

1,440,469✔

5504

      code = msgToCaseWhenNode(pDecoder, pObj);

1,440,469✔

5505

      break;

1,440,469✔

5506

    case QUERY_NODE_WINDOW_OFFSET:

327,012✔

5507

      code = msgToWindowOffsetNode(pDecoder, pObj);

327,012✔

5508

      break;

327,012✔

5509

    case QUERY_NODE_REMOTE_VALUE:

4,867,410✔

5510

      code = msgToRemoteValueNode(pDecoder, pObj);

4,867,410✔

5511

      break;

4,867,410✔

5512

    case QUERY_NODE_REMOTE_VALUE_LIST:

11,964,692✔

5513

      code = msgToRemoteValueListNode(pDecoder, pObj);

11,964,692✔

5514

      break;

11,964,692✔

5515

    case QUERY_NODE_REMOTE_ROW:

21,728,295✔

5516

      code = msgToRemoteRowNode(pDecoder, pObj);

21,728,295✔

5517

      break;

21,728,295✔

5518

    case QUERY_NODE_REMOTE_ZERO_ROWS:

380,395✔

5519

      code = msgToRemoteZeroRowsNode(pDecoder, pObj);

380,395✔

5520

      break;

380,395✔

5521

    case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN:

7,983,207✔

5522

      code = msgToPhysiTagScanNode(pDecoder, pObj);

7,983,207✔

5523

      break;

7,984,115✔

5524

    case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN:

5,470✔

5525

      code = msgToPhysiScanNode(pDecoder, pObj);

5,470✔

5526

      break;

5,470✔

5527

    case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN:

1,232,936✔

5529

      code = msgToPhysiLastRowScanNode(pDecoder, pObj);

1,232,936✔

5530

      break;

1,232,936✔

5531

    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:

271,170,147✔

5534

      code = msgToPhysiTableScanNode(pDecoder, pObj);

271,170,147✔

5535

      break;

271,148,992✔

5536

    case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN:

16,222,738✔

5537

      code = msgToPhysiSysTableScanNode(pDecoder, pObj);

16,222,738✔

5538

      break;

16,223,432✔

5539

    case QUERY_NODE_PHYSICAL_PLAN_PROJECT:

146,171,714✔

5540

      code = msgToPhysiProjectNode(pDecoder, pObj);

146,171,714✔

5541

      break;

146,180,308✔

5542

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN:

12,977,992✔

5543

      code = msgToPhysiMergeJoinNode(pDecoder, pObj);

12,977,992✔

5544

      break;

12,977,992✔

5545

    case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN:

1,224,119✔

5546

      code = msgToPhysiHashJoinNode(pDecoder, pObj);

1,224,119✔

5547

      break;

1,224,119✔

5548

    case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG:

127,390,906✔

5549

      code = msgToPhysiAggNode(pDecoder, pObj);

127,390,906✔

5550

      break;

127,396,165✔

5551

    case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE:

110,468,754✔

5552

      code = msgToPhysiExchangeNode(pDecoder, pObj);

110,468,754✔

5553

      break;

110,468,745✔

5554

    case QUERY_NODE_PHYSICAL_PLAN_MERGE:

13,819,489✔

5555

      code = msgToPhysiMergeNode(pDecoder, pObj);

13,819,489✔

5556

      break;

13,819,489✔

5557

    case QUERY_NODE_PHYSICAL_PLAN_SORT:

32,793,931✔

5559

      code = msgToPhysiSortNode(pDecoder, pObj);

32,793,931✔

5560

      break;

32,794,065✔

5561

    case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL:

5,454,816✔

5563

      code = msgToPhysiIntervalNode(pDecoder, pObj);

5,454,816✔

5564

      break;

5,455,211✔

5565

    case QUERY_NODE_PHYSICAL_PLAN_FILL:

509,283✔

5566

      code = msgToPhysiFillNode(pDecoder, pObj);

509,283✔

5567

      break;

509,283✔

5568

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION:

560,937✔

5569

      code = msgToPhysiSessionWindowNode(pDecoder, pObj);

560,937✔

5570

      break;

560,937✔

5571

    case QUERY_NODE_PHYSICAL_PLAN_EXTERNAL_WINDOW:

937,134✔

5574

      code = msgToPhysiExternalWindowNode(pDecoder, pObj);

937,134✔

5575

      break;

937,134✔

5576

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE:

977,597✔

5577

      code = msgToPhysiStateWindowNode(pDecoder, pObj);

977,597✔

5578

      break;

977,597✔

5579

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT:

312,591✔

5580

      code = msgToPhysiEventWindowNode(pDecoder, pObj);

312,591✔

5581

      break;

312,591✔

5582

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_COUNT:

250,928✔

5583

      code = msgToPhysiCountWindowNode(pDecoder, pObj);

250,928✔

5584

      break;

250,928✔

5588

    case QUERY_NODE_PHYSICAL_PLAN_PARTITION:

2,980,072✔

5589

      code = msgToPhysiPartitionNode(pDecoder, pObj);

2,980,072✔

5590

      break;

2,980,626✔

5591

    case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC:

3,122,754✔

5592

      code = msgToPhysiIndefRowsFuncNode(pDecoder, pObj);

3,122,754✔

5593

      break;

3,123,284✔

5594

    case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC:

3,443,288✔

5595

      code = msgToPhysiInterpFuncNode(pDecoder, pObj);

3,443,288✔

5596

      break;

3,443,288✔

5601

    case QUERY_NODE_PHYSICAL_PLAN_DISPATCH:

356,811,118✔

5602

      code = msgToPhysiDispatchNode(pDecoder, pObj);

356,811,118✔

5603

      break;

356,822,869✔

5604

    case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT:

286,373✔

5605

      code = msgToPhysiQueryInsertNode(pDecoder, pObj);

286,373✔

5606

      break;

286,373✔

5607

    case QUERY_NODE_PHYSICAL_PLAN_DELETE:

1,799,574✔

5608

      code = msgToPhysiDeleteNode(pDecoder, pObj);

1,799,574✔

5609

      break;

1,799,574✔

5610

    case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE:

1,223,323✔

5611

      code = msgToPhysiGroupCacheNode(pDecoder, pObj);

1,223,323✔

5612

      break;

1,223,323✔

5613

    case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL:

3,389,349✔

5614

      code = msgToPhysiDynQueryCtrlNode(pDecoder, pObj);

3,389,349✔

5615

      break;

3,389,349✔

5616

    case QUERY_NODE_PHYSICAL_PLAN_VIRTUAL_TABLE_SCAN:

3,874,185✔

5617

      code = msgToPhysiVirtualTableScanNode(pDecoder, pObj);

3,874,185✔

5618

      break;

3,874,185✔

5619

    case QUERY_NODE_PHYSICAL_SUBPLAN:

358,899,907✔

5620

      code = msgToSubplan(pDecoder, pObj);

358,899,907✔

5621

      break;

358,917,432✔

5622

    case QUERY_NODE_PHYSICAL_PLAN:

1,176✔

5623

      code = msgToQueryPlan(pDecoder, pObj);

1,176✔

5624

      break;

1,176✔

5628

  if (TSDB_CODE_SUCCESS != code) {

2,147,483,647✔

5631

  return code;

2,147,483,647✔

5634

static int32_t nodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,147,483,647✔

5635

  return tlvEncodeObj(pEncoder, nodeType(pObj), specificNodeToMsg, pObj);

2,147,483,647✔

5638

static int32_t msgToNode(STlvDecoder* pDecoder, void** pObj) {

2,147,483,647✔

5639

  return tlvDecodeDynObj(pDecoder, (FMakeObject)nodesMakeNode, msgToSpecificNode, pObj);

2,147,483,647✔

5642

static int32_t msgToNodeFromTlv(STlv* pTlv, void** pObj) {

2,147,483,647✔

5643

  STlvDecoder decoder = {.bufSize = pTlv->len, .offset = 0, .pBuf = pTlv->value};

2,147,483,647✔

5644

  return msgToNode(&decoder, pObj);

2,147,483,647✔

5647

static int32_t nodeListToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,147,483,647✔

5648

  const SNodeList* pList = (const SNodeList*)pObj;

2,147,483,647✔

5650

  SNode* pNode = NULL;

2,147,483,647✔

5651

  FOREACH(pNode, pList) {

2,147,483,647✔

5652

    int32_t code = nodeToMsg(pNode, pEncoder);

2,147,483,647✔

5653

    if (TSDB_CODE_SUCCESS != code) {

2,147,483,647✔

5658

  return TSDB_CODE_SUCCESS;

2,147,483,647✔

5667

static int32_t SArrayToMsg(const void* pObj, STlvEncoder* pEncoder) {

142,572,804✔

5668

  const SArray* pArray = (const SArray*)pObj;

142,572,804✔

5669

  int32_t code = TSDB_CODE_SUCCESS;

142,572,804✔

5670

  if (TSDB_CODE_SUCCESS == code) {

142,572,804✔

5671

    code = tlvEncodeI32(pEncoder, SARRAY_CODE_CAPACITY, pArray->capacity);

142,574,292✔

5673

  if (TSDB_CODE_SUCCESS == code) {

142,574,397✔

5674

    code = tlvEncodeI32(pEncoder, SARRAY_CODE_ELEMSIZE, pArray->elemSize);

142,574,888✔

5676

  if (TSDB_CODE_SUCCESS == code) {

142,572,322✔

5677

    code = tlvEncodeI32(pEncoder, SARRAY_CODE_SIZE, pArray->size);

142,572,947✔

5679

  if (TSDB_CODE_SUCCESS == code && pArray->capacity * pArray->elemSize > 0 && pArray->pData != NULL) {

142,574,282✔

5680

    code = tlvEncodeBinary(pEncoder, SARRAY_CODE_PDATA, pArray->pData, pArray->capacity * pArray->elemSize);

142,573,910✔

5682

  return code;

142,574,455✔

5686

static int32_t msgToNodeList(STlvDecoder* pDecoder, void** pObj) {

2,147,483,647✔

5687

  SNodeList* pList = NULL;

2,147,483,647✔

5688

  int32_t code = TSDB_CODE_SUCCESS;

2,147,483,647✔

5689

  code = nodesMakeList(&pList);

2,147,483,647✔

5691

  while (TSDB_CODE_SUCCESS == code && !tlvDecodeEnd(pDecoder)) {

2,147,483,647✔

5692

    SNode* pNode = NULL;

2,147,483,647✔

5693

    code = msgToNode(pDecoder, (void**)&pNode);

2,147,483,647✔

5694

    if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

5695

      code = nodesListAppend(pList, pNode);

2,147,483,647✔

5698

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

5699

    *pObj = pList;

2,147,483,647✔

5703

  return code;

2,147,483,647✔

5706

static int32_t msgToSArray(STlv* pTlv, void** pObj){

110,467,711✔

5707

  SArray* pArray = NULL;

110,467,711✔

5708

  uint32_t capacity = 0;

110,467,711✔

5709

  uint32_t elemSize = 0;

110,468,216✔

5710

  uint32_t actualSize;

110,467,081✔

5711

  int32_t decodeFieldNum = 0;;

110,468,240✔

5712

  int32_t code = TSDB_CODE_SUCCESS;

110,468,240✔

5713

  STlvDecoder decoder = {.bufSize = pTlv->len, .offset = 0, .pBuf = pTlv->value};

110,468,240✔

5714

  STlv*   pTlvTemp = NULL;

110,468,216✔

5715

  STlv*   pDataTlv = NULL;

110,468,216✔

5717

  tlvForEach(&decoder, pTlvTemp, code) {

552,341,741✔

5718

    switch (pTlvTemp->type) {

441,876,603✔

5719

      case SARRAY_CODE_CAPACITY:

110,468,229✔

5720

        code = tlvDecodeI32(pTlvTemp, &capacity);

110,468,229✔

5721

        break;

110,468,216✔

5722

      case SARRAY_CODE_ELEMSIZE:

110,469,283✔

5723

        code = tlvDecodeI32(pTlvTemp, &elemSize);

110,469,283✔

5724

        break;

110,469,283✔

5725

      case SARRAY_CODE_SIZE:

110,470,337✔

5726

        code = tlvDecodeI32(pTlvTemp, &actualSize);

110,470,337✔

5727

        break;

110,469,283✔

5728

      case SARRAY_CODE_PDATA:

110,469,283✔

5729

        if (decodeFieldNum < 3) {

110,469,283✔

5733

        pArray = taosArrayInit(capacity, elemSize);

110,469,283✔

5734

        if (NULL == pArray) {

110,467,308✔

5737

        pArray->size = actualSize;

110,467,308✔

5738

        if (TSDB_CODE_SUCCESS != code || pTlvTemp == NULL) {

110,468,216✔

5742

        code = tlvDecodeBinary(pTlvTemp, pArray->pData);

110,469,283✔

5743

        break;

110,466,743✔

5747

    decodeFieldNum++;

441,873,525✔

5750

  if (pDataTlv != NULL) {

110,469,036✔

5762

  *pObj = pArray;

110,469,036✔

5763

  return code;

110,468,216✔

5767

static int32_t msgToNodeListFromTlv(STlv* pTlv, void** pObj) {

2,147,483,647✔

5768

  STlvDecoder decoder = {.bufSize = pTlv->len, .offset = 0, .pBuf = pTlv->value};

2,147,483,647✔

5769

  return msgToNodeList(&decoder, pObj);

2,147,483,647✔

5772

int32_t nodesNodeToMsg(const SNode* pNode, char** pMsg, int32_t* pLen) {

511,280,781✔

5773

  if (NULL == pNode || NULL == pMsg || NULL == pLen) {

511,280,781✔

5774

    terrno = TSDB_CODE_FAILED;

43,870✔

5778

  STlvEncoder encoder;

386,134,550✔

5779

  int32_t     code = initTlvEncoder(&encoder);

511,398,029✔

5780

  if (TSDB_CODE_SUCCESS == code) {

510,631,892✔

5781

    code = nodeToMsg(pNode, &encoder);

510,669,719✔

5783

  if (TSDB_CODE_SUCCESS == code) {

511,271,358✔

5784

    endTlvEncode(&encoder, pMsg, pLen);

511,334,148✔

5786

  clearTlvEncoder(&encoder);

510,511,480✔

5788

  terrno = code;

510,887,401✔

5789

  return code;

511,029,513✔

5792

int32_t nodesMsgToNode(const char* pMsg, int32_t len, SNode** pNode) {

358,971,617✔

5793

  if (NULL == pMsg || NULL == pNode) {

358,971,617✔

5797

  STlvDecoder decoder = {.bufSize = len, .offset = 0, .pBuf = pMsg};

358,985,468✔

5798

  int32_t     code = msgToNode(&decoder, (void**)pNode);

358,986,150✔

5799

  if (TSDB_CODE_SUCCESS != code) {

358,954,463✔

5804

  terrno = code;

358,954,463✔

5805

  return code;

358,942,040✔

taosdata / TDengine / #5006

Source File
Press 'n' to go to next uncovered line, 'b' for previous

taosdata / TDengine / #5006

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