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

77

static int32_t initTlvEncoder(STlvEncoder* pEncoder) {

541,157,972✔

78

  pEncoder->allocSize = NODES_MSG_DEFAULT_LEN;

541,157,972✔

79

  pEncoder->offset = 0;

541,278,654✔

80

  pEncoder->tlvCount = 0;

541,280,609✔

81

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

541,254,512✔

82

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

540,242,683✔

85

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

540,757,419✔

87

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

540,857,223✔

88

  *pMsg = pEncoder->pBuf;

540,857,223✔

89

  pEncoder->pBuf = NULL;

540,991,139✔

90

  *pLen = pEncoder->offset;

541,034,881✔

91

540,897,521✔

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);

247,777,058✔

97

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

247,888,870✔

98

    if (NULL == pNewBuf) {

247,728,837✔

101

    pEncoder->pBuf = pNewBuf;

247,728,837✔

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);

248,611,063✔

115

    if (NULL == pNewBuf) {

248,483,173✔

118

    pEncoder->pBuf = pNewBuf;

248,483,173✔

119

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

248,415,892✔

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✔

134

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

573,756,523✔

135

  value = htons(value);

573,756,523✔

136

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

573,756,523✔

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) {

516,156,956✔

155

  value = htonll(value);

516,156,956✔

156

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

516,156,956✔

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) {

84,601,486✔

173

  value = htons(value);

84,601,486✔

174

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

84,601,486✔

177

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

726,325,655✔

178

  value = htons(value);

726,325,655✔

179

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

726,325,655✔

182

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

919,141,380✔

183

  value = htonll(value);

919,141,380✔

184

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

919,141,380✔

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) {

27,370,598✔

193

  int64_t temp = *(int64_t*)&value;

27,370,598✔

194

  temp = htonll(temp);

27,372,784✔

195

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

27,372,784✔

198

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

393,058,958✔

199

  int64_t temp = *(int64_t*)&value;

393,058,958✔

200

  temp = htonll(temp);

393,094,236✔

201

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

393,094,236✔

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;

254,690,266✔

226

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

1,991,227,552✔

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) {

221,135,574✔

239

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

221,135,574✔

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));

132,070,603✔

249

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

132,084,344✔

250

    if (NULL == pNewBuf) {

131,996,683✔

253

    pEncoder->pBuf = pNewBuf;

131,996,683✔

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,

44,428,523✔

270

  int32_t code = TSDB_CODE_SUCCESS;

44,428,523✔

271

  if (num > 0) {

44,428,523✔

272

    int32_t start = pEncoder->offset;

44,435,512✔

273

    pEncoder->offset += sizeof(STlv);

44,442,180✔

274

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

89,400,354✔

275

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

44,977,811✔

277

    if (TSDB_CODE_SUCCESS == code) {

44,422,543✔

278

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

44,440,242✔

279

      pTlv->type = htons(type);

44,433,965✔

280

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

44,421,593✔

283

  return code;

44,389,821✔

286

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

802,840,430✔

288

  int32_t code = tlvEncodeValueI32(pEncoder, num);

802,840,430✔

289

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

1,529,038,038✔

290

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

726,070,881✔

292

  return code;

802,967,157✔

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✔

341

static int32_t tlvDecodeI16(STlv* pTlv, int16_t* pValue) {

433,643,159✔

342

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

433,643,159✔

343

  if (TSDB_CODE_SUCCESS == code) {

433,669,181✔

344

    *pValue = ntohs(*pValue);

433,665,911✔

346

  return code;

433,639,929✔

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) {

422,815,770✔

374

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

422,815,770✔

375

  if (TSDB_CODE_SUCCESS == code) {

422,828,290✔

376

    *pValue = ntohll(*pValue);

422,825,401✔

378

  return code;

422,836,077✔

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) {

49,472,578✔

401

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

49,472,578✔

402

  if (TSDB_CODE_SUCCESS == code) {

49,470,787✔

403

    *pValue = ntohs(*pValue);

49,470,787✔

405

  return code;

49,472,678✔

408

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

519,109,199✔

409

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

519,109,199✔

410

  if (TSDB_CODE_SUCCESS == code) {

519,181,645✔

411

    *pValue = ntohs(*pValue);

519,182,193✔

413

  return code;

519,157,469✔

416

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

649,122,568✔

417

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

649,122,568✔

418

  if (TSDB_CODE_SUCCESS == code) {

649,195,714✔

419

    *pValue = ntohll(*pValue);

649,197,017✔

421

  return code;

649,183,890✔

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) {

27,284,439✔

433

  volatile int64_t temp = 0;

27,284,439✔

434

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

27,286,476✔

435

  if (TSDB_CODE_SUCCESS == code) {

27,280,105✔

436

    *pValue = *(double*)&temp;

27,283,407✔

438

  return code;

27,282,151✔

441

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

283,746,733✔

442

  volatile int64_t temp = 0;

283,746,733✔

443

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

283,767,642✔

444

  if (TSDB_CODE_SUCCESS == code) {

283,795,505✔

445

    *pValue = *(double*)&temp;

283,796,057✔

447

  return code;

283,763,601✔

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✔

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,253,169,532✔

504

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

1,253,169,532✔

507

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

1,253,192,435✔

508

  return TSDB_CODE_SUCCESS;

1,253,173,903✔

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) {

252,644,465✔

521

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

252,644,465✔

522

  return NULL == *pValue ? terrno : TSDB_CODE_SUCCESS;

252,606,558✔

525

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

1,503✔

526

  *pValue = taosMemoryMalloc(pTlv->len);

1,503✔

527

  if (NULL == *pValue) {

1,503✔

530

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

1,503✔

531

  return TSDB_CODE_SUCCESS;

1,503✔

534

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

172,875,903✔

535

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

172,875,903✔

536

  return TSDB_CODE_SUCCESS;

172,874,264✔

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) {

25,933,527✔

554

  int32_t code = TSDB_CODE_SUCCESS;

25,933,527✔

555

  int32_t i = 0;

25,933,527✔

556

  STlv*   pTlv = NULL;

25,933,527✔

557

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

52,208,602✔

558

  return code;

25,938,168✔

561

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

576,455,710✔

563

  int32_t code = tlvDecodeValueI32(pDecoder, pNum);

576,455,710✔

564

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

1,095,665,175✔

565

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

519,215,762✔

567

  return code;

576,476,844✔

570

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

25,934,757✔

571

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

25,934,757✔

572

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

25,936,530✔

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,708,504,119✔

612

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

1,708,504,119✔

614

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

1,708,504,119✔

615

  if (TSDB_CODE_SUCCESS == code) {

1,708,949,065✔

616

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

1,708,972,312✔

618

  if (TSDB_CODE_SUCCESS == code) {

1,709,657,297✔

619

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

1,709,667,146✔

621

  if (TSDB_CODE_SUCCESS == code) {

1,709,737,903✔

622

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

1,709,748,047✔

625

  return code;

1,709,706,294✔

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,355,032,497✔

646

  SDataType* pNode = (SDataType*)pObj;

1,355,032,497✔

648

  int32_t code = TSDB_CODE_SUCCESS;

1,355,032,497✔

649

  STlv*   pTlv = NULL;

1,355,032,497✔

650

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

651

    switch (pTlv->type) {

2,147,483,647✔

652

      case DATA_TYPE_CODE_TYPE:

1,355,087,435✔

653

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

1,355,087,435✔

654

        break;

1,355,032,363✔

655

      case DATA_TYPE_CODE_PRECISION:

1,355,122,268✔

656

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

1,355,122,268✔

657

        break;

1,355,092,866✔

658

      case DATA_TYPE_CODE_SCALE:

1,355,128,274✔

659

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

1,355,128,274✔

660

        break;

1,355,115,275✔

661

      case DATA_TYPE_CODE_BYTES:

1,354,945,908✔

662

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

1,354,945,908✔

663

        break;

1,355,090,095✔

669

  return code;

1,354,842,533✔

674

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

1,708,579,097✔

675

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

1,708,579,097✔

676

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

1,708,579,097✔

677

  if (TSDB_CODE_SUCCESS == code) {

1,709,614,194✔

678

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

1,709,617,278✔

680

  if (TSDB_CODE_SUCCESS == code) {

1,709,685,756✔

681

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

1,709,662,070✔

683

  if (TSDB_CODE_SUCCESS == code) {

1,709,730,667✔

684

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

1,709,708,925✔

686

  return code;

1,709,757,066✔

689

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

1,354,995,756✔

690

  SExprNode* pNode = (SExprNode*)pObj;

1,354,995,756✔

692

  int32_t code = TSDB_CODE_SUCCESS;

1,354,995,756✔

693

  STlv*   pTlv = NULL;

1,354,995,756✔

694

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

695

    switch (pTlv->type) {

2,147,483,647✔

696

      case EXPR_CODE_RES_TYPE:

1,355,099,341✔

697

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

1,355,099,341✔

698

        break;

1,355,046,628✔

699

      case EXPR_CODE_BIND_TUPLE_FUNC_IDX:

1,355,114,509✔

700

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

1,355,114,509✔

701

        break;

1,355,101,508✔

702

      case EXPR_CODE_TUPLE_FUNC_IDX:

1,355,124,323✔

703

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

1,355,124,323✔

704

        break;

1,355,110,430✔

705

      case EXPR_CODE_HAS_NULL:

1,354,929,785✔

706

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

1,354,929,785✔

707

        break;

1,355,048,858✔

713

  return code;

1,355,296,009✔

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✔

891

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

479,638,196✔

892

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

479,638,196✔

894

  int32_t code = TSDB_CODE_SUCCESS;

479,638,196✔

895

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

479,638,196✔

898

    case TSDB_DATA_TYPE_BOOL:

18,685,351✔

899

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

18,685,351✔

900

      break;

18,700,821✔

901

    case TSDB_DATA_TYPE_TINYINT:

360,068,454✔

906

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

360,068,454✔

907

      break;

360,430,383✔

908

    case TSDB_DATA_TYPE_UTINYINT:

16,472✔

912

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

16,472✔

913

      break;

17,000✔

914

    case TSDB_DATA_TYPE_FLOAT:

27,314,545✔

916

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

27,314,545✔

917

      break;

27,383,598✔

918

    case TSDB_DATA_TYPE_VARCHAR:

72,930,539✔

922

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

72,930,539✔

923

      break;

73,121,946✔

924

    case TSDB_DATA_TYPE_JSON:

1,503✔

925

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

1,503✔

926

      break;

8,816✔

927

    case TSDB_DATA_TYPE_DECIMAL:

2,512✔

928

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

2,512✔

929

      break;

2,512✔

930

    case TSDB_DATA_TYPE_DECIMAL64:

196✔

931

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

196✔

932

      break;

196✔

941

  return code;

479,642,380✔

944

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

573,743,087✔

945

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

573,743,087✔

947

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

573,743,087✔

948

  if (TSDB_CODE_SUCCESS == code) {

574,035,621✔

949

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

574,037,071✔

951

  if (TSDB_CODE_SUCCESS == code) {

573,875,330✔

952

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

573,856,232✔

954

  if (TSDB_CODE_SUCCESS == code) {

574,024,635✔

955

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

574,007,812✔

957

  if (TSDB_CODE_SUCCESS == code) {

573,867,312✔

958

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

573,851,545✔

960

  if (TSDB_CODE_SUCCESS == code) {

574,064,363✔

961

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

574,049,017✔

963

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

573,866,596✔

964

    code = datumToMsg(pNode, pEncoder);

479,581,870✔

966

  if (TSDB_CODE_SUCCESS == code) {

573,897,948✔

967

    code = tlvEncodeI16(pEncoder, VALUE_CODE_PLACEHOLDER_NO, pNode->placeholderNo);

573,798,138✔

970

  return code;

574,027,503✔

973

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

402,771,165✔

974

  SValueNode* pNode = (SValueNode*)pObj;

402,771,165✔

976

  int32_t code = TSDB_CODE_SUCCESS;

402,771,165✔

977

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

402,771,165✔

980

    case TSDB_DATA_TYPE_BOOL:

18,633,685✔

981

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

18,633,685✔

982

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

18,634,604✔

983

      break;

18,634,628✔

984

    case TSDB_DATA_TYPE_TINYINT:

153,710,984✔

985

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

153,710,984✔

986

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

153,727,316✔

987

      break;

153,727,993✔

988

    case TSDB_DATA_TYPE_SMALLINT:

8,813,227✔

989

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

8,813,227✔

990

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

8,815,017✔

991

      break;

8,814,463✔

992

    case TSDB_DATA_TYPE_INT:

20,118,510✔

993

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

20,118,510✔

994

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

20,122,289✔

995

      break;

20,120,403✔

996

    case TSDB_DATA_TYPE_BIGINT:

104,942,369✔

997

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

104,942,369✔

998

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

104,952,270✔

999

      break;

104,949,529✔

1000

    case TSDB_DATA_TYPE_TIMESTAMP:

10,573,213✔

1001

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

10,573,213✔

1002

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

10,573,690✔

1003

      break;

10,573,690✔

1004

    case TSDB_DATA_TYPE_UTINYINT:

6,592✔

1005

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

6,592✔

1006

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

6,592✔

1007

      break;

6,592✔

1008

    case TSDB_DATA_TYPE_USMALLINT:

1,332✔

1009

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

1,332✔

1010

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

1,332✔

1011

      break;

1,332✔

1012

    case TSDB_DATA_TYPE_UINT:

2,368✔

1013

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

2,368✔

1014

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

2,368✔

1015

      break;

2,368✔

1016

    case TSDB_DATA_TYPE_UBIGINT:

6,672✔

1017

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

6,672✔

1018

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

6,672✔

1019

      break;

6,672✔

1020

    case TSDB_DATA_TYPE_FLOAT:

1,424,528✔

1021

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

1,424,528✔

1022

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

1,424,528✔

1023

      break;

1,424,528✔

1024

    case TSDB_DATA_TYPE_DOUBLE:

25,857,691✔

1025

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

25,857,691✔

1026

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

25,852,781✔

1027

      break;

25,859,270✔

1028

    case TSDB_DATA_TYPE_NCHAR:

58,629,553✔

1032

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

58,629,553✔

1036

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

58,624,697✔

1037

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

58,627,435✔

1041

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

58,616,422✔

1042

      if (TSDB_CODE_SUCCESS == code) {

58,615,780✔

1043

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

58,616,178✔

1045

      break;

58,624,366✔

1047

    case TSDB_DATA_TYPE_JSON: {

1,503✔

1048

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

1,503✔

1052

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

1,503✔

1053

      break;

1,503✔

1055

    case TSDB_DATA_TYPE_DECIMAL:

2,307✔

1056

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

2,307✔

1057

      if (!pNode->datum.p) {

2,307✔

1061

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

2,307✔

1062

      break;

2,307✔

1075

        break;

811✔

1087

  return code;

402,750,455✔

1090

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

433,651,135✔

1091

  SValueNode* pNode = (SValueNode*)pObj;

433,651,135✔

1093

  int32_t code = TSDB_CODE_SUCCESS;

433,651,135✔

1094

  STlv*   pTlv = NULL;

433,651,135✔

1095

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

1096

    switch (pTlv->type) {

2,147,483,647✔

1097

      case VALUE_CODE_EXPR_BASE:

433,633,517✔

1098

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

433,633,517✔

1099

        break;

433,671,680✔

1100

      case VALUE_CODE_LITERAL:

252,665,784✔

1101

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

252,665,784✔

1102

        break;

252,633,637✔

1103

      case VALUE_CODE_FLAG:

433,676,419✔

1104

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

433,676,419✔

1105

        break;

433,665,650✔

1106

      case VALUE_CODE_TRANSLATE:

433,677,964✔

1107

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

433,677,964✔

1108

        break;

433,636,762✔

1109

      case VALUE_CODE_NOT_RESERVED:

433,678,280✔

1110

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

433,678,280✔

1111

        break;

433,671,712✔

1112

      case VALUE_CODE_IS_NULL:

433,648,897✔

1113

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

433,648,897✔

1114

        break;

433,668,151✔

1115

      case VALUE_CODE_DATUM:

402,807,011✔

1116

        code = msgToDatum(pTlv, pNode);

402,807,011✔

1117

        break;

402,752,791✔

1118

      case VALUE_CODE_PLACEHOLDER_NO:

433,670,279✔

1119

        code = tlvDecodeI16(pTlv, &pNode->placeholderNo);

433,670,279✔

1120

        break;

433,652,961✔

1126

  return code;

433,858,580✔

1135

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

62,888,359✔

1136

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

62,888,359✔

1138

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

62,888,359✔

1144

  if (TSDB_CODE_SUCCESS == code) {

62,929,090✔

1145

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

62,929,080✔

1148

  return code;

62,920,953✔

1152

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

5,418,273✔

1153

  SRemoteValueNode* pNode = (SRemoteValueNode*)pObj;

5,418,273✔

1155

  int32_t code = TSDB_CODE_SUCCESS;

5,418,273✔

1156

  STlv*   pTlv = NULL;

5,418,273✔

1157

  tlvForEach(pDecoder, pTlv, code) {

16,254,819✔

1158

    switch (pTlv->type) {

10,837,114✔

1159

      case REMOTE_VALUE_CODE_VAL:

5,417,137✔

1160

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

5,417,137✔

1161

        break;

5,418,273✔

1167

      case REMOTE_VALUE_CODE_SUBQ_IDX:

5,418,841✔

1168

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

5,418,841✔

1169

        break;

5,418,841✔

1175

  return code;

5,418,273✔

1184

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

18,934,428✔

1185

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

18,934,428✔

1187

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

18,934,428✔

1188

  if (TSDB_CODE_SUCCESS == code) {

18,944,540✔

1189

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

18,944,540✔

1191

  if (TSDB_CODE_SUCCESS == code) {

18,941,807✔

1192

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

18,941,881✔

1195

  return code;

18,944,140✔

1199

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

12,489,018✔

1200

  SRemoteValueListNode* pNode = (SRemoteValueListNode*)pObj;

12,489,018✔

1202

  int32_t code = TSDB_CODE_SUCCESS;

12,489,018✔

1203

  STlv*   pTlv = NULL;

12,489,018✔

1204

  tlvForEach(pDecoder, pTlv, code) {

49,956,072✔

1205

    switch (pTlv->type) {

37,467,054✔

1206

      case REMOTE_VALUELIST_CODE_EXPR:

12,489,018✔

1207

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

12,489,018✔

1208

        break;

12,489,018✔

1209

      case REMOTE_VALUELIST_CODE_FLAG:

12,489,018✔

1210

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

12,489,018✔

1211

        break;

12,489,018✔

1212

      case REMOTE_VALUELIST_CODE_SUBQ_IDX:

12,489,018✔

1213

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

12,489,018✔

1214

        break;

12,489,018✔

1220

  return code;

12,489,018✔

1232

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

24,210,913✔

1233

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

24,210,913✔

1235

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

24,210,913✔

1236

  if (TSDB_CODE_SUCCESS == code) {

24,213,840✔

1237

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

24,213,840✔

1239

  if (TSDB_CODE_SUCCESS == code) {

24,213,524✔

1240

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

24,213,434✔

1242

  if (TSDB_CODE_SUCCESS == code) {

24,214,000✔

1243

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

24,213,910✔

1245

  if (TSDB_CODE_SUCCESS == code) {

24,213,440✔

1246

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

24,212,570✔

1248

  if (TSDB_CODE_SUCCESS == code) {

24,214,530✔

1249

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

24,213,660✔

1252

  return code;

24,213,566✔

1256

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

22,686,476✔

1257

  SRemoteRowNode* pNode = (SRemoteRowNode*)pObj;

22,686,476✔

1259

  int32_t code = TSDB_CODE_SUCCESS;

22,686,476✔

1260

  STlv*   pTlv = NULL;

22,686,476✔

1261

  tlvForEach(pDecoder, pTlv, code) {

158,808,162✔

1262

    switch (pTlv->type) {

136,122,252✔

1263

      case REMOTE_ROW_CODE_VAL:

22,687,042✔

1264

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

22,687,042✔

1265

        break;

22,687,042✔

1266

      case REMOTE_ROW_CODE_IS_MIN:

22,687,042✔

1267

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

22,687,042✔

1268

        break;

22,686,476✔

1269

      case REMOTE_ROW_CODE_VAL_SET:

22,687,042✔

1270

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

22,687,042✔

1271

        break;

22,687,042✔

1272

      case REMOTE_ROW_CODE_HAS_VALUE:

22,687,042✔

1273

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

22,687,042✔

1274

        break;

22,687,042✔

1275

      case REMOTE_ROW_CODE_HAS_NULL:

22,687,042✔

1276

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

22,687,042✔

1277

        break;

22,687,042✔

1278

      case REMOTE_ROW_CODE_SUBQ_IDX:

22,687,042✔

1279

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

22,687,042✔

1280

        break;

22,687,042✔

1286

  return code;

22,686,476✔

1289

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

1,327,512✔

1290

  return remoteValueNodeToMsg(pObj, pEncoder);

1,327,512✔

1294

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

395,288✔

1295

  return msgToRemoteValueNode(pDecoder, pObj);

395,288✔

1304

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

495,062✔

1305

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

495,062✔

1307

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

495,062✔

1308

  if (TSDB_CODE_SUCCESS == code) {

495,062✔

1309

    code = tlvEncodeI32(pEncoder, REMOTE_TABLE_CODE_RES_COLS, pNode->resCols);

495,062✔

1311

  if (TSDB_CODE_SUCCESS == code) {

495,062✔

1312

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

495,062✔

1315

  return code;

495,062✔

1320

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

491,026✔

1321

  SRemoteTableNode* pNode = (SRemoteTableNode*)pObj;

491,026✔

1323

  int32_t code = TSDB_CODE_SUCCESS;

491,026✔

1324

  STlv*   pTlv = NULL;

491,026✔

1325

  tlvForEach(pDecoder, pTlv, code) {

1,964,104✔

1326

    switch (pTlv->type) {

1,473,078✔

1327

      case REMOTE_TABLE_CODE_FLAG:

491,026✔

1328

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

491,026✔

1329

        break;

491,026✔

1330

      case REMOTE_TABLE_CODE_RES_COLS:

491,026✔

1331

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

491,026✔

1332

        break;

491,026✔

1333

      case REMOTE_TABLE_CODE_SUBQ_IDX:

491,026✔

1334

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

491,026✔

1335

        break;

491,026✔

1341

  return code;

491,026✔

1348

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

333,594,990✔

1349

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

333,594,990✔

1351

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

333,594,990✔

1352

  if (TSDB_CODE_SUCCESS == code) {

333,782,948✔

1353

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

333,781,147✔

1355

  if (TSDB_CODE_SUCCESS == code) {

333,745,667✔

1356

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

333,746,058✔

1358

  if (TSDB_CODE_SUCCESS == code) {

333,760,292✔

1359

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

333,760,753✔

1361

  if (TSDB_CODE_SUCCESS == code) {

333,710,695✔

1362

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

333,697,183✔

1365

  return code;

333,738,210✔

1368

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

274,895,746✔

1369

  SOperatorNode* pNode = (SOperatorNode*)pObj;

274,895,746✔

1371

  int32_t code = TSDB_CODE_SUCCESS;

274,895,746✔

1372

  STlv*   pTlv = NULL;

274,895,746✔

1373

  tlvForEach(pDecoder, pTlv, code) {

1,611,673,430✔

1374

    switch (pTlv->type) {

1,336,799,969✔

1375

      case OPERATOR_CODE_EXPR_BASE:

274,883,121✔

1376

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

274,883,121✔

1377

        break;

274,912,337✔

1378

      case OPERATOR_CODE_OP_TYPE:

274,915,563✔

1379

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

274,915,563✔

1380

        break;

274,911,871✔

1381

      case OPERATOR_CODE_FLAG:

274,916,264✔

1382

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

274,916,264✔

1383

        break;

274,913,707✔

1384

      case OPERATOR_CODE_LEFT:

274,915,526✔

1385

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

274,915,526✔

1386

        break;

274,895,070✔

1387

      case OPERATOR_CODE_RIGHT:

237,167,607✔

1388

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

237,167,607✔

1389

        break;

237,141,075✔

1395

  return code;

274,966,339✔

1400

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

50,174,427✔

1401

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

50,174,427✔

1403

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

50,174,427✔

1404

  if (TSDB_CODE_SUCCESS == code) {

50,208,360✔

1405

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

50,208,326✔

1407

  if (TSDB_CODE_SUCCESS == code) {

50,173,254✔

1408

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

50,173,349✔

1411

  return code;

50,210,354✔

1414

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

46,744,170✔

1415

  SLogicConditionNode* pNode = (SLogicConditionNode*)pObj;

46,744,170✔

1417

  int32_t code = TSDB_CODE_SUCCESS;

46,744,170✔

1418

  STlv*   pTlv = NULL;

46,744,170✔

1419

  tlvForEach(pDecoder, pTlv, code) {

186,996,296✔

1420

    switch (pTlv->type) {

140,253,047✔

1421

      case LOGIC_COND_CODE_EXPR_BASE:

46,741,477✔

1422

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

46,741,477✔

1423

        break;

46,749,766✔

1424

      case LOGIC_COND_CODE_COND_TYPE:

46,751,561✔

1425

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

46,751,561✔

1426

        break;

46,749,534✔

1427

      case LOGIC_COND_CODE_PARAMETERS:

46,759,611✔

1428

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

46,759,611✔

1429

        break;

46,750,621✔

1435

  return code;

46,756,162✔

1453

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

706,316,309✔

1454

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

706,316,309✔

1456

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

706,316,309✔

1457

  if (TSDB_CODE_SUCCESS == code) {

706,835,062✔

1458

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

706,841,630✔

1460

  if (TSDB_CODE_SUCCESS == code) {

706,785,616✔

1461

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

706,775,047✔

1463

  if (TSDB_CODE_SUCCESS == code) {

706,913,504✔

1464

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

706,903,314✔

1466

  if (TSDB_CODE_SUCCESS == code) {

706,892,422✔

1467

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

706,882,545✔

1469

  if (TSDB_CODE_SUCCESS == code) {

706,554,380✔

1470

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

706,544,647✔

1472

  if (TSDB_CODE_SUCCESS == code) {

706,886,952✔

1473

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

706,868,898✔

1475

  if (TSDB_CODE_SUCCESS == code) {

706,904,052✔

1476

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

706,886,970✔

1478

  if (TSDB_CODE_SUCCESS == code) {

706,901,584✔

1479

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

706,884,408✔

1481

  if (TSDB_CODE_SUCCESS == code) {

706,938,105✔

1482

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

706,921,095✔

1484

  if (TSDB_CODE_SUCCESS == code) {

706,921,452✔

1485

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

706,899,180✔

1487

  if (TSDB_CODE_SUCCESS == code) {

706,911,389✔

1488

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

706,890,045✔

1491

  return code;

706,608,371✔

1494

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

576,352,507✔

1495

  SFunctionNode* pNode = (SFunctionNode*)pObj;

576,352,507✔

1497

  int32_t code = TSDB_CODE_SUCCESS;

576,352,507✔

1498

  STlv*   pTlv = NULL;

576,352,507✔

1499

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

1500

    switch (pTlv->type) {

2,147,483,647✔

1501

      case FUNCTION_CODE_EXPR_BASE:

576,367,674✔

1502

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

576,367,674✔

1503

        break;

576,357,272✔

1504

      case FUNCTION_CODE_FUNCTION_NAME:

576,338,554✔

1505

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

576,338,554✔

1506

        break;

576,359,155✔

1507

      case FUNCTION_CODE_FUNCTION_ID:

576,387,293✔

1508

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

576,387,293✔

1509

        break;

576,373,919✔

1510

      case FUNCTION_CODE_FUNCTION_TYPE:

576,392,031✔

1511

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

576,392,031✔

1512

        break;

576,386,568✔

1513

      case FUNCTION_CODE_PARAMETERS:

475,803,423✔

1514

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

475,803,423✔

1515

        break;

475,772,371✔

1516

      case FUNCTION_CODE_UDF_BUF_SIZE:

576,375,718✔

1517

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

576,375,718✔

1518

        break;

576,369,144✔

1519

      case FUNCTION_NODE_HAS_PK:

576,390,523✔

1520

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

576,390,523✔

1521

        break;

576,374,639✔

1522

      case FUNCTION_NODE_PK_BYTES:

576,388,862✔

1523

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

576,388,862✔

1524

        break;

576,385,006✔

1525

      case FUNCTION_CODE_IS_MERGE_FUNC:

576,399,097✔

1526

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

576,399,097✔

1527

        break;

576,369,617✔

1528

      case FUNCTION_CODE_MERGE_FUNC_OF:

576,381,060✔

1529

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

576,381,060✔

1530

        break;

576,389,708✔

1531

      case FUNCTION_CODE_TRIM_TYPE:

576,393,809✔

1532

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

576,393,809✔

1533

        break;

576,373,214✔

1534

      case FUNCTION_SRC_FUNC_INPUT_TYPE:

576,396,072✔

1535

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

576,396,072✔

1536

      default:

576,370,784✔

1537

        break;

576,370,784✔

1541

  return code;

579,054,548✔

1546

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

97,015,646✔

1547

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

97,015,646✔

1549

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

97,015,646✔

1550

  if (TSDB_CODE_SUCCESS == code) {

97,033,681✔

1551

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

97,033,895✔

1553

  if (TSDB_CODE_SUCCESS == code) {

97,040,104✔

1554

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

97,039,354✔

1557

  return code;

97,039,144✔

1560

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

63,986,972✔

1561

  SOrderByExprNode* pNode = (SOrderByExprNode*)pObj;

63,986,972✔

1563

  int32_t code = TSDB_CODE_SUCCESS;

63,986,972✔

1564

  STlv*   pTlv = NULL;

63,986,972✔

1565

  tlvForEach(pDecoder, pTlv, code) {

255,957,954✔

1566

    switch (pTlv->type) {

191,968,946✔

1567

      case ORDER_BY_EXPR_CODE_EXPR:

63,987,621✔

1568

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

63,987,621✔

1569

        break;

63,988,667✔

1570

      case ORDER_BY_EXPR_CODE_ORDER:

63,989,795✔

1571

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

63,989,795✔

1572

        break;

63,990,344✔

1573

      case ORDER_BY_EXPR_CODE_NULL_ORDER:

63,991,530✔

1574

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

63,991,530✔

1575

        break;

63,990,344✔

1581

  return code;

63,996,919✔

1586

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

41,736,590✔

1587

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

41,736,590✔

1589

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

41,736,590✔

1590

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

41,754,615✔

1591

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

10,883,259✔

1594

  return code;

41,746,332✔

1597

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

34,954,117✔

1598

  SLimitNode* pNode = (SLimitNode*)pObj;

34,954,117✔

1600

  int32_t code = TSDB_CODE_SUCCESS;

34,954,117✔

1601

  STlv*   pTlv = NULL;

34,954,117✔

1602

  tlvForEach(pDecoder, pTlv, code) {

80,664,449✔

1603

    switch (pTlv->type) {

45,711,587✔

1604

      case LIMIT_CODE_LIMIT:

34,952,609✔

1605

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

34,952,609✔

1606

        break;

34,953,020✔

1607

      case LIMIT_CODE_OFFSET:

10,758,817✔

1608

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

10,758,817✔

1609

        break;

10,757,312✔

1615

  return code;

34,955,809✔

1620

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

453,728,597✔

1621

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

453,728,597✔

1623

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

453,728,597✔

1624

  if (TSDB_CODE_SUCCESS == code) {

454,172,516✔

1625

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

454,171,293✔

1627

  if (TSDB_CODE_SUCCESS == code) {

454,206,129✔

1628

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

454,140,934✔

1630

  if (TSDB_CODE_SUCCESS == code) {

453,986,142✔

1631

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

453,924,904✔

1634

  return code;

454,246,052✔

1637

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

320,856,317✔

1638

  SName* pNode = (SName*)pObj;

320,856,317✔

1640

  int32_t code = TSDB_CODE_SUCCESS;

320,856,317✔

1641

  STlv*   pTlv = NULL;

320,856,317✔

1642

  tlvForEach(pDecoder, pTlv, code) {

1,604,437,368✔

1643

    switch (pTlv->type) {

1,283,651,494✔

1644

      case NAME_CODE_TYPE:

320,858,020✔

1645

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

320,858,020✔

1646

        break;

320,897,032✔

1647

      case NAME_CODE_ACCT_ID:

320,913,519✔

1648

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

320,913,519✔

1649

        break;

320,904,037✔

1650

      case NAME_CODE_DB_NAME:

320,918,089✔

1651

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

320,918,089✔

1652

        break;

320,845,821✔

1653

      case NAME_CODE_TABLE_NAME:

320,959,116✔

1654

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

320,959,116✔

1655

        break;

320,911,490✔

1661

  return code;

320,911,810✔

1666

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

24,113,187✔

1667

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

24,113,187✔

1669

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

24,113,187✔

1670

  if (TSDB_CODE_SUCCESS == code) {

24,126,083✔

1671

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

24,126,133✔

1674

  return code;

24,127,692✔

1677

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

15,978,064✔

1678

  STimeWindow* pNode = (STimeWindow*)pObj;

15,978,064✔

1680

  int32_t code = TSDB_CODE_SUCCESS;

15,978,064✔

1681

  STlv*   pTlv = NULL;

15,978,064✔

1682

  tlvForEach(pDecoder, pTlv, code) {

47,934,946✔

1683

    switch (pTlv->type) {

31,958,080✔

1684

      case TIME_WINDOW_CODE_START_KEY:

15,979,040✔

1685

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

15,979,040✔

1686

        break;

15,977,842✔

1687

      case TIME_WINDOW_CODE_END_KEY:

15,979,040✔

1688

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

15,979,040✔

1689

        break;

15,979,040✔

1695

  return code;

15,979,572✔

1700

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

11,621,013✔

1701

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

11,621,013✔

1703

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

11,621,013✔

1704

  if (TSDB_CODE_SUCCESS == code) {

11,635,969✔

1705

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

11,635,969✔

1708

  return code;

11,636,088✔

1711

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

7,871,488✔

1712

  SNodeListNode* pNode = (SNodeListNode*)pObj;

7,871,488✔

1714

  int32_t code = TSDB_CODE_SUCCESS;

7,871,488✔

1715

  STlv*   pTlv = NULL;

7,871,488✔

1716

  tlvForEach(pDecoder, pTlv, code) {

23,615,088✔

1717

    switch (pTlv->type) {

15,743,209✔

1718

      case NODE_LIST_CODE_EXPR_BASE:

7,871,097✔

1719

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

7,871,097✔

1720

        break;

7,871,330✔

1721

      case NODE_LIST_CODE_NODE_LIST:

7,872,112✔

1722

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

7,872,112✔

1723

        break;

7,871,879✔

1729

  return code;

7,872,270✔

1734

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

2,147,483,647✔

1735

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

2,147,483,647✔

1737

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

2,147,483,647✔

1738

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1739

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

2,147,483,647✔

1742

  return code;

2,147,483,647✔

1745

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

2,147,483,647✔

1746

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

2,147,483,647✔

1748

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

2,147,483,647✔

1749

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1750

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

2,147,483,647✔

1753

  return code;

2,147,483,647✔

1756

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

2,147,483,647✔

1757

  STargetNode* pNode = (STargetNode*)pObj;

2,147,483,647✔

1759

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

2,147,483,647✔

1760

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1761

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

2,147,483,647✔

1764

  return code;

2,147,483,647✔

1767

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

2,147,483,647✔

1768

  STargetNode* pNode = (STargetNode*)pObj;

2,147,483,647✔

1770

  int32_t code = TSDB_CODE_SUCCESS;

2,147,483,647✔

1771

  STlv*   pTlv = NULL;

2,147,483,647✔

1772

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

1773

    switch (pTlv->type) {

2,147,483,647✔

1774

      case TARGET_CODE_INLINE_ATTRS:

2,147,483,647✔

1775

        code = tlvDecodeObjFromTlv(pTlv, msgToTargetNodeInline, pNode);

2,147,483,647✔

1776

        break;

2,147,483,647✔

1777

      case TARGET_CODE_EXPR:

2,147,483,647✔

1778

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

2,147,483,647✔

1779

        break;

2,147,483,647✔

1785

  return code;

2,147,483,647✔

1832

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

1,668,128,336✔

1833

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

1,668,128,336✔

1835

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

1,668,128,336✔

1836

  if (TSDB_CODE_SUCCESS == code) {

1,667,237,646✔

1837

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

1,667,256,151✔

1839

  if (TSDB_CODE_SUCCESS == code) {

1,669,348,534✔

1840

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

1,669,361,962✔

1842

  if (TSDB_CODE_SUCCESS == code) {

1,669,488,915✔

1843

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

1,669,511,044✔

1846

  return code;

1,669,615,140✔

1849

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

1,668,332,051✔

1850

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

1,668,332,051✔

1852

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

1,668,332,051✔

1853

  if (TSDB_CODE_SUCCESS == code) {

1,669,627,716✔

1854

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

1,669,629,002✔

1857

  return code;

1,669,760,592✔

1860

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

1,188,395,417✔

1861

  SDataBlockDescNode* pNode = (SDataBlockDescNode*)pObj;

1,188,395,417✔

1863

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

1,188,395,417✔

1864

  if (TSDB_CODE_SUCCESS == code) {

1,188,303,811✔

1865

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

1,188,357,104✔

1867

  if (TSDB_CODE_SUCCESS == code) {

1,188,431,107✔

1868

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

1,188,431,107✔

1870

  if (TSDB_CODE_SUCCESS == code) {

1,188,447,620✔

1871

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

1,188,447,620✔

1874

  return code;

1,188,413,418✔

1877

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

1,188,355,976✔

1878

  SDataBlockDescNode* pNode = (SDataBlockDescNode*)pObj;

1,188,355,976✔

1880

  int32_t code = TSDB_CODE_SUCCESS;

1,188,355,976✔

1881

  STlv*   pTlv = NULL;

1,188,355,976✔

1882

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

1883

    switch (pTlv->type) {

2,147,483,647✔

1884

      case DATA_BLOCK_DESC_CODE_INLINE_ATTRS:

1,188,437,003✔

1885

        code = tlvDecodeObjFromTlv(pTlv, msgToDataBlockDescNodeInline, pNode);

1,188,437,003✔

1886

        break;

1,188,416,560✔

1887

      case DATA_BLOCK_DESC_CODE_SLOTS:

1,188,510,365✔

1888

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

1,188,510,365✔

1889

        break;

1,188,397,137✔

1895

  return code;

1,188,467,262✔

1900

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

2,147,483,647✔

1901

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

2,147,483,647✔

1903

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

2,147,483,647✔

1904

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1905

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

2,147,483,647✔

1907

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1908

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

2,147,483,647✔

1910

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1911

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

2,147,483,647✔

1913

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1914

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

2,147,483,647✔

1917

  return code;

2,147,483,647✔

1920

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

2,147,483,647✔

1921

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

2,147,483,647✔

1924

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

2,147,483,647✔

1925

  SSlotDescNode* pNode = (SSlotDescNode*)pObj;

2,147,483,647✔

1927

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

2,147,483,647✔

1928

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1929

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

2,147,483,647✔

1931

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1932

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

2,147,483,647✔

1934

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1935

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

2,147,483,647✔

1937

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

1938

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

2,147,483,647✔

1941

  return code;

2,147,483,647✔

1944

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

2,147,483,647✔

1945

  SSlotDescNode* pNode = (SSlotDescNode*)pObj;

2,147,483,647✔

1947

  int32_t code = TSDB_CODE_SUCCESS;

2,147,483,647✔

1948

  STlv*   pTlv = NULL;

2,147,483,647✔

1949

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

1950

    switch (pTlv->type) {

2,147,483,647✔

1951

      case SLOT_DESC_CODE_INLINE_ATTRS:

2,147,483,647✔

1952

        code = tlvDecodeObjFromTlv(pTlv, msgToSlotDescNodeInline, pNode);

2,147,483,647✔

1953

        break;

2,147,483,647✔

1959

  return code;

2,147,483,647✔

1964

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

726,109,094✔

1965

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

726,109,094✔

1967

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

726,109,094✔

1968

  if (TSDB_CODE_SUCCESS == code) {

726,399,835✔

1969

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

726,403,969✔

1972

  return code;

726,371,852✔

1975

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

44,968,432✔

1976

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

44,968,432✔

1978

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

44,968,432✔

1979

  if (TSDB_CODE_SUCCESS == code) {

44,992,420✔

1980

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

44,992,420✔

1983

  return code;

44,988,733✔

1986

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

519,114,132✔

1987

  SEp* pNode = (SEp*)pObj;

519,114,132✔

1989

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

519,114,132✔

1990

  if (TSDB_CODE_SUCCESS == code) {

519,187,928✔

1991

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

519,187,928✔

1994

  return code;

519,140,683✔

1997

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

26,270,862✔

1998

  SEp* pNode = (SEp*)pObj;

26,270,862✔

2000

  int32_t code = TSDB_CODE_SUCCESS;

26,270,862✔

2001

  STlv*   pTlv = NULL;

26,270,862✔

2002

  tlvForEach(pDecoder, pTlv, code) {

78,824,833✔

2003

    switch (pTlv->type) {

52,556,170✔

2004

      case EP_CODE_FQDN:

26,278,085✔

2005

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

26,278,085✔

2006

        break;

26,273,880✔

2007

      case EP_CODE_port:

26,278,085✔

2008

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

26,278,085✔

2009

        break;

26,276,376✔

2015

  return code;

26,279,996✔

2020

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

802,871,343✔

2021

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

802,871,343✔

2023

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

802,871,343✔

2024

  if (TSDB_CODE_SUCCESS == code) {

802,956,442✔

2025

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

802,965,513✔

2028

  return code;

802,986,249✔

2031

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

44,432,771✔

2032

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

44,432,771✔

2034

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

44,432,771✔

2035

  if (TSDB_CODE_SUCCESS == code) {

44,444,076✔

2036

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

44,444,076✔

2038

  if (TSDB_CODE_SUCCESS == code) {

44,447,029✔

2039

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

44,447,029✔

2042

  return code;

44,360,434✔

2045

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

576,456,151✔

2046

  SEpSet* pNode = (SEpSet*)pObj;

576,456,151✔

2048

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

576,456,151✔

2049

  if (TSDB_CODE_SUCCESS == code) {

576,514,055✔

2050

    int32_t numOfEps = 0;

576,514,685✔

2051

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

576,452,691✔

2052

    pNode->numOfEps = numOfEps;

576,479,845✔

2055

  return code;

576,458,571✔

2058

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

25,935,236✔

2059

  SEpSet* pNode = (SEpSet*)pObj;

25,935,236✔

2061

  int32_t code = TSDB_CODE_SUCCESS;

25,935,236✔

2062

  STlv*   pTlv = NULL;

25,935,236✔

2063

  tlvForEach(pDecoder, pTlv, code) {

103,749,080✔

2064

    switch (pTlv->type) {

77,813,253✔

2065

      case EP_SET_CODE_IN_USE:

25,937,555✔

2066

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

25,937,555✔

2067

        break;

25,937,538✔

2068

      case EP_SET_CODE_NUM_OF_EPS:

25,938,168✔

2069

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

25,938,168✔

2070

        break;

25,938,168✔

2071

      case EP_SET_CODE_EPS:

25,938,143✔

2072

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

25,938,143✔

2073

        break;

25,936,436✔

2079

  return code;

25,941,338✔

2084

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

802,873,484✔

2085

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

802,873,484✔

2087

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

802,873,484✔

2088

  if (TSDB_CODE_SUCCESS == code) {

802,733,795✔

2089

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

802,737,054✔

2092

  return code;

802,981,411✔

2106

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

576,458,023✔

2107

  SQueryNodeAddr* pNode = (SQueryNodeAddr*)pObj;

576,458,023✔

2109

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

576,458,023✔

2110

  if (TSDB_CODE_SUCCESS == code) {

576,517,113✔

2111

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

576,518,423✔

2114

  return code;

576,425,800✔

2138

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

261,806,294✔

2139

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

261,806,294✔

2141

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

261,806,294✔

2142

  if (TSDB_CODE_SUCCESS == code) {

261,809,011✔

2143

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

261,807,847✔

2145

  if (TSDB_CODE_SUCCESS == code) {

261,808,066✔

2146

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

261,808,066✔

2148

  if (TSDB_CODE_SUCCESS == code) {

261,808,045✔

2149

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

261,808,199✔

2151

  if (TSDB_CODE_SUCCESS == code) {

261,808,636✔

2152

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

261,807,629✔

2154

  if (TSDB_CODE_SUCCESS == code) {

261,809,313✔

2155

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

261,808,400✔

2158

  return code;

261,807,495✔

2161

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

261,806,810✔

2162

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

261,806,810✔

2165

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

194,650,912✔

2166

  SDownstreamSourceNode* pNode = (SDownstreamSourceNode*)pObj;

194,650,912✔

2168

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

194,650,912✔

2169

  if (TSDB_CODE_SUCCESS == code) {

194,653,470✔

2170

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

194,653,470✔

2172

  if (TSDB_CODE_SUCCESS == code) {

194,652,924✔

2173

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

194,652,924✔

2175

  if (TSDB_CODE_SUCCESS == code) {

194,653,470✔

2176

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

194,653,470✔

2178

  if (TSDB_CODE_SUCCESS == code) {

194,653,470✔

2179

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

194,653,470✔

2181

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

194,653,470✔

2182

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

194,653,470✔

2185

  return code;

194,653,470✔

2188

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

194,650,906✔

2189

  SDownstreamSourceNode* pNode = (SDownstreamSourceNode*)pObj;

194,650,906✔

2191

  int32_t code = TSDB_CODE_SUCCESS;

194,650,906✔

2192

  STlv*   pTlv = NULL;

194,650,906✔

2193

  tlvForEach(pDecoder, pTlv, code) {

389,305,866✔

2194

    switch (pTlv->type) {

194,651,434✔

2195

      case DOWNSTREAM_SOURCE_CODE_INLINE_ATTRS:

194,652,529✔

2196

        code = tlvDecodeObjFromTlv(pTlv, msgToDownstreamSourceNodeInlineToMsg, pNode);

194,652,529✔

2197

        break;

194,653,470✔

2203

  return code;

194,655,546✔

2208

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

7,227,372✔

2209

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

7,227,372✔

2211

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

7,227,372✔

2212

  if (TSDB_CODE_SUCCESS == code) {

7,227,637✔

2213

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

7,227,637✔

2215

  if (TSDB_CODE_SUCCESS == code) {

7,227,543✔

2216

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

7,227,543✔

2219

  return code;

7,227,543✔

2222

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

1,598,878✔

2223

  SWhenThenNode* pNode = (SWhenThenNode*)pObj;

1,598,878✔

2225

  int32_t code = TSDB_CODE_SUCCESS;

1,598,878✔

2226

  STlv*   pTlv = NULL;

1,598,878✔

2227

  tlvForEach(pDecoder, pTlv, code) {

6,395,512✔

2228

    switch (pTlv->type) {

4,796,634✔

2229

      case WHEN_THEN_CODE_EXPR_BASE:

1,598,878✔

2230

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

1,598,878✔

2231

        break;

1,598,878✔

2232

      case WHEN_THEN_CODE_WHEN:

1,598,878✔

2233

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

1,598,878✔

2234

        break;

1,598,878✔

2235

      case WHEN_THEN_CODE_THEN:

1,598,878✔

2236

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

1,598,878✔

2237

        break;

1,598,878✔

2243

  return code;

1,598,878✔

2248

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

7,074,535✔

2249

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

7,074,535✔

2251

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

7,074,535✔

2252

  if (TSDB_CODE_SUCCESS == code) {

7,075,112✔

2253

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

7,075,112✔

2255

  if (TSDB_CODE_SUCCESS == code) {

7,074,630✔

2256

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

7,074,630✔

2258

  if (TSDB_CODE_SUCCESS == code) {

7,075,112✔

2259

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

7,075,112✔

2262

  return code;

7,075,018✔

2265

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

1,446,983✔

2266

  SCaseWhenNode* pNode = (SCaseWhenNode*)pObj;

1,446,983✔

2268

  int32_t code = TSDB_CODE_SUCCESS;

1,446,983✔

2269

  STlv*   pTlv = NULL;

1,446,983✔

2270

  tlvForEach(pDecoder, pTlv, code) {

5,830,137✔

2271

    switch (pTlv->type) {

4,383,154✔

2272

      case CASE_WHEN_CODE_EXPR_BASE:

1,446,983✔

2273

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

1,446,983✔

2274

        break;

1,446,983✔

2275

      case CASE_WHEN_CODE_CASE:

134,187✔

2276

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

134,187✔

2277

        break;

134,187✔

2278

      case CASE_WHEN_CODE_ELSE:

1,355,001✔

2279

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

1,355,001✔

2280

        break;

1,355,001✔

2281

      case CASE_WHEN_CODE_WHEN_THEN_LIST:

1,446,983✔

2282

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

1,446,983✔

2283

        break;

1,446,983✔

2289

  return code;

1,446,983✔

2294

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

337,784✔

2295

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

337,784✔

2297

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

337,784✔

2298

  if (TSDB_CODE_SUCCESS == code) {

337,784✔

2299

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

337,784✔

2302

  return code;

337,784✔

2305

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

338,570✔

2306

  SWindowOffsetNode* pNode = (SWindowOffsetNode*)pObj;

338,570✔

2308

  int32_t code = TSDB_CODE_SUCCESS;

338,570✔

2309

  STlv*   pTlv = NULL;

338,570✔

2310

  tlvForEach(pDecoder, pTlv, code) {

1,015,710✔

2311

    switch (pTlv->type) {

677,140✔

2312

      case WINDOW_OFFSET_CODE_START_OFFSET:

338,570✔

2313

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

338,570✔

2314

        break;

338,570✔

2315

      case WINDOW_OFFSET_CODE_END_OFFSET:

338,570✔

2316

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

338,570✔

2317

        break;

338,570✔

2323

  return code;

338,570✔

2339

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

1,127,748,812✔

2340

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

1,127,748,812✔

2342

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

1,127,748,812✔

2343

  if (TSDB_CODE_SUCCESS == code) {

1,128,619,300✔

2344

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

1,128,451,690✔

2346

  if (TSDB_CODE_SUCCESS == code) {

1,128,594,405✔

2347

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

1,128,604,652✔

2349

  if (TSDB_CODE_SUCCESS == code) {

1,128,235,703✔

2350

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

1,128,257,491✔

2352

  if (TSDB_CODE_SUCCESS == code) {

1,127,917,289✔

2353

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

1,127,915,921✔

2355

  if (TSDB_CODE_SUCCESS == code) {

1,127,769,124✔

2356

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

1,127,776,401✔

2358

  if (TSDB_CODE_SUCCESS == code) {

1,127,435,960✔

2359

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

1,127,448,865✔

2361

  if (TSDB_CODE_SUCCESS == code) {

1,128,506,440✔

2362

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

1,128,521,380✔

2364

  if (TSDB_CODE_SUCCESS == code) {

1,128,697,218✔

2365

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

1,128,680,014✔

2368

  return code;

1,128,747,424✔

2371

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

806,436,859✔

2372

  SPhysiNode* pNode = (SPhysiNode*)pObj;

806,436,859✔

2374

  int32_t code = TSDB_CODE_SUCCESS;

806,436,859✔

2375

  STlv*   pTlv = NULL;

806,436,859✔

2376

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

2377

    switch (pTlv->type) {

2,147,483,647✔

2378

      case PHY_NODE_CODE_OUTPUT_DESC:

806,490,110✔

2379

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

806,490,110✔

2380

        break;

806,527,650✔

2381

      case PHY_NODE_CODE_CONDITIONS:

103,765,587✔

2382

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

103,765,587✔

2383

        break;

103,755,324✔

2384

      case PHY_NODE_CODE_CHILDREN:

373,512,844✔

2385

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

373,512,844✔

2386

        break;

373,518,051✔

2387

      case PHY_NODE_CODE_LIMIT:

32,023,546✔

2388

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

32,023,546✔

2389

        break;

32,022,627✔

2390

      case PHY_NODE_CODE_SLIMIT:

2,765,196✔

2391

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

2,765,196✔

2392

        break;

2,765,196✔

2393

      case PHY_NODE_CODE_INPUT_TS_ORDER:

806,570,404✔

2394

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

806,570,404✔

2395

        break;

806,584,173✔

2396

      case PHY_NODE_CODE_OUTPUT_TS_ORDER:

806,607,814✔

2397

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

806,607,814✔

2398

        break;

806,601,385✔

2399

      case PHY_NODE_CODE_DYNAMIC_OP:

806,608,387✔

2400

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

806,608,387✔

2401

        break;

806,596,571✔

2402

      case PHY_NODE_CODE_FORCE_NONBLOCKING_OPTR:

806,709,829✔

2403

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

806,709,829✔

2404

        break;

806,595,938✔

2410

  return code;

806,589,713✔

2425

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

453,741,560✔

2426

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

453,741,560✔

2428

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

453,741,560✔

2429

  if (TSDB_CODE_SUCCESS == code) {

454,167,208✔

2430

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

454,166,677✔

2432

  if (TSDB_CODE_SUCCESS == code) {

454,153,111✔

2433

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

454,110,238✔

2435

  if (TSDB_CODE_SUCCESS == code) {

454,177,484✔

2436

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

454,150,280✔

2438

  if (TSDB_CODE_SUCCESS == code) {

453,984,069✔

2439

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

453,957,920✔

2441

  if (TSDB_CODE_SUCCESS == code) {

454,238,697✔

2442

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

454,214,268✔

2444

  if (TSDB_CODE_SUCCESS == code) {

454,198,131✔

2445

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

454,115,454✔

2447

  if (TSDB_CODE_SUCCESS == code) {

454,313,537✔

2448

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

454,231,454✔

2450

  if (TSDB_CODE_SUCCESS == code) {

454,316,304✔

2451

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

454,235,029✔

2454

  return code;

454,251,861✔

2457

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

320,830,784✔

2458

  SScanPhysiNode* pNode = (SScanPhysiNode*)pObj;

320,830,784✔

2460

  int32_t code = TSDB_CODE_SUCCESS;

320,830,784✔

2461

  STlv*   pTlv = NULL;

320,830,784✔

2462

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

2463

    switch (pTlv->type) {

2,147,483,647✔

2464

      case PHY_SCAN_CODE_BASE_NODE:

320,849,706✔

2465

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

320,849,706✔

2466

        break;

320,892,821✔

2467

      case PHY_SCAN_CODE_SCAN_COLS:

312,679,703✔

2468

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

312,679,703✔

2469

        break;

312,649,890✔

2470

      case PHY_SCAN_CODE_SCAN_PSEUDO_COLS:

80,422,591✔

2471

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

80,422,591✔

2472

        break;

80,419,889✔

2473

      case PHY_SCAN_CODE_BASE_UID:

320,897,851✔

2474

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

320,897,851✔

2475

        break;

320,874,962✔

2476

      case PHY_SCAN_CODE_BASE_SUID:

320,915,880✔

2477

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

320,915,880✔

2478

        break;

320,915,343✔

2479

      case PHY_SCAN_CODE_BASE_TABLE_TYPE:

320,917,204✔

2480

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

320,917,204✔

2481

        break;

320,916,878✔

2482

      case PHY_SCAN_CODE_BASE_TABLE_NAME:

320,918,219✔

2483

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

320,918,219✔

2484

        break;

320,909,798✔

2485

      case PHY_SCAN_CODE_BASE_GROUP_ORDER_SCAN:

320,915,037✔

2486

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

320,915,037✔

2487

        break;

320,910,280✔

2488

      case PHY_SCAN_CODE_BASE_VIRTUAL_STABLE_SCAN:

320,915,997✔

2489

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

320,915,997✔

2490

      default:

320,915,589✔

2491

        break;

320,915,589✔

2495

  return code;

321,037,064✔

2510

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

4,502,099✔

2511

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

4,502,099✔

2513

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

4,502,099✔

2515

  if (TSDB_CODE_SUCCESS == code) {

4,502,099✔

2516

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

4,502,099✔

2519

  if (TSDB_CODE_SUCCESS == code) {

4,502,099✔

2520

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

4,502,099✔

2523

  if (TSDB_CODE_SUCCESS == code) {

4,502,099✔

2524

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

4,502,099✔

2527

  if (TSDB_CODE_SUCCESS == code) {

4,502,099✔

2528

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

4,502,099✔

2531

  if (TSDB_CODE_SUCCESS == code) {

4,502,099✔

2532

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

4,502,099✔

2535

  if (TSDB_CODE_SUCCESS == code) {

4,502,099✔

2536

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

4,502,099✔

2539

  if (TSDB_CODE_SUCCESS == code) {

4,502,099✔

2540

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

4,502,099✔

2543

  if (TSDB_CODE_SUCCESS == code) {

4,502,099✔

2544

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

4,502,099✔

2547

  return code;

4,502,099✔

2550

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

4,037,211✔

2551

  SVirtualScanPhysiNode* pNode = (SVirtualScanPhysiNode*)pObj;

4,037,211✔

2553

  int32_t code = TSDB_CODE_SUCCESS;

4,037,211✔

2554

  STlv*   pTlv = NULL;

4,037,211✔

2555

  tlvForEach(pDecoder, pTlv, code) {

28,256,631✔

2556

    switch (pTlv->type) {

24,219,420✔

2557

      case PHY_VIRTUAL_TABLE_SCAN_CODE_SCAN:

4,037,211✔

2558

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

4,037,211✔

2559

        break;

4,037,211✔

2563

      case PHY_VIRTUAL_TABLE_SCAN_CODE_GROUP_SORT:

4,037,211✔

2564

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

4,037,211✔

2565

        break;

4,037,211✔

2566

      case PHY_VIRTUAL_TABLE_SCAN_CODE_ONLY_TS:

4,037,211✔

2567

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

4,037,211✔

2568

        break;

4,037,211✔

2569

      case PHY_VIRTUAL_TABLE_SCAN_CODE_TARGETS:

4,033,365✔

2570

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

4,033,365✔

2571

        break;

4,033,365✔

2578

      case PHY_VIRTUAL_TABLE_SCAN_CODE_IGNORE_EXPIRED:

4,037,211✔

2579

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

4,037,211✔

2580

        break;

4,037,211✔

2581

      case PHY_VIRTUAL_TABLE_SCAN_CODE_IGNORE_CHECK_UPDATE:

4,037,211✔

2582

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

4,037,211✔

2583

        break;

4,037,211✔

2589

  return code;

4,037,211✔

2597

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

14,928,610✔

2598

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

14,928,610✔

2600

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

14,928,610✔

2602

  if (TSDB_CODE_SUCCESS == code) {

14,952,376✔

2603

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

14,952,378✔

2605

  return code;

14,953,680✔

2608

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

8,287,652✔

2609

  STagScanPhysiNode* pNode = (STagScanPhysiNode*)pObj;

8,287,652✔

2611

  int32_t code = TSDB_CODE_SUCCESS;

8,287,652✔

2612

  STlv*   pTlv = NULL;

8,287,652✔

2613

  tlvForEach(pDecoder, pTlv, code) {

24,865,562✔

2614

    switch (pTlv->type) {

16,578,164✔

2615

      case PHY_TAG_SCAN_CODE_SCAN:

8,286,709✔

2616

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

8,286,709✔

2617

        break;

8,288,480✔

2618

      case PHY_TAG_SCAN_CODE_ONLY_META_CTB_IDX:

8,290,925✔

2619

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

8,290,925✔

2620

        break;

8,288,878✔

2626

  return code;

8,290,096✔

2638

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

1,580,884✔

2639

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

1,580,884✔

2641

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

1,580,884✔

2642

  if (TSDB_CODE_SUCCESS == code) {

1,580,364✔

2643

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

1,580,809✔

2645

  if (TSDB_CODE_SUCCESS == code) {

1,579,437✔

2646

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

1,579,474✔

2648

  if (TSDB_CODE_SUCCESS == code) {

1,580,780✔

2649

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

1,580,817✔

2651

  if (TSDB_CODE_SUCCESS == code) {

1,580,743✔

2652

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

1,580,780✔

2654

  if (TSDB_CODE_SUCCESS == code) {

1,580,261✔

2655

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

1,580,298✔

2658

  return code;

1,580,472✔

2661

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

1,573,768✔

2662

  SLastRowScanPhysiNode* pNode = (SLastRowScanPhysiNode*)pObj;

1,573,768✔

2664

  int32_t code = TSDB_CODE_SUCCESS;

1,573,768✔

2665

  STlv*   pTlv = NULL;

1,573,768✔

2666

  tlvForEach(pDecoder, pTlv, code) {

8,037,925✔

2667

    switch (pTlv->type) {

6,463,489✔

2668

      case PHY_LAST_ROW_SCAN_CODE_SCAN:

1,574,420✔

2669

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

1,574,420✔

2670

        break;

1,574,436✔

2671

      case PHY_LAST_ROW_SCAN_CODE_GROUP_TAGS:

196,906✔

2672

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

196,906✔

2673

        break;

196,906✔

2674

      case PHY_LAST_ROW_SCAN_CODE_GROUP_SORT:

1,574,436✔

2675

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

1,574,436✔

2676

        break;

1,574,436✔

2677

      case PHY_LAST_ROW_SCAN_CODE_IGNULL:

1,574,436✔

2678

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

1,574,436✔

2679

        break;

1,574,436✔

2680

      case PHY_LAST_ROW_SCAN_CODE_TARGETS:

1,543,275✔

2681

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

1,543,275✔

2682

        break;

1,543,275✔

2683

      case PHY_LAST_ROW_SCAN_CODE_FUNCTYPES:

16✔

2684

        code = msgToSArray(pTlv, (void**)&pNode->pFuncTypes);

16✔

2692

  return code;

1,575,104✔

2708

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

393,055,489✔

2709

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

393,055,489✔

2711

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

393,055,489✔

2712

  if (TSDB_CODE_SUCCESS == code) {

393,333,969✔

2713

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

392,991,380✔

2715

  if (TSDB_CODE_SUCCESS == code) {

393,310,339✔

2716

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

393,260,648✔

2718

  if (TSDB_CODE_SUCCESS == code) {

393,317,831✔

2719

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

393,271,883✔

2721

  if (TSDB_CODE_SUCCESS == code) {

393,338,150✔

2722

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

393,293,614✔

2724

  if (TSDB_CODE_SUCCESS == code) {

392,117,048✔

2725

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

392,079,220✔

2727

  if (TSDB_CODE_SUCCESS == code) {

393,396,709✔

2728

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

393,275,727✔

2730

  if (TSDB_CODE_SUCCESS == code) {

393,470,831✔

2731

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

393,356,570✔

2733

  if (TSDB_CODE_SUCCESS == code) {

393,466,621✔

2734

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

393,356,038✔

2736

  if (TSDB_CODE_SUCCESS == code) {

393,568,344✔

2737

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

393,460,300✔

2739

  if (TSDB_CODE_SUCCESS == code) {

393,506,779✔

2740

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

393,325,662✔

2742

  if (TSDB_CODE_SUCCESS == code) {

393,590,821✔

2743

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

393,413,753✔

2745

  if (TSDB_CODE_SUCCESS == code) {

393,539,322✔

2746

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

393,370,845✔

2748

  if (TSDB_CODE_SUCCESS == code) {

393,587,422✔

2749

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

393,422,820✔

2751

  if (TSDB_CODE_SUCCESS == code) {

393,591,606✔

2752

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

393,339,792✔

2754

  if (TSDB_CODE_SUCCESS == code) {

393,608,175✔

2755

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

393,361,387✔

2757

  if (TSDB_CODE_SUCCESS == code) {

393,577,547✔

2758

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

393,333,981✔

2760

  if (TSDB_CODE_SUCCESS == code) {

393,614,836✔

2761

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

393,370,767✔

2763

  if (TSDB_CODE_SUCCESS == code) {

393,587,002✔

2764

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

393,249,674✔

2766

  if (TSDB_CODE_SUCCESS == code) {

393,780,560✔

2767

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

393,456,653✔

2769

  if (TSDB_CODE_SUCCESS == code) {

393,724,284✔

2770

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

393,405,915✔

2772

  return code;

393,488,681✔

2775

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

393,131,427✔

2776

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

393,131,427✔

2778

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

393,131,427✔

2779

  if (TSDB_CODE_SUCCESS == code) {

393,536,731✔

2780

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

393,548,307✔

2782

  if (TSDB_CODE_SUCCESS == code) {

393,474,440✔

2783

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

393,484,202✔

2785

  if (TSDB_CODE_SUCCESS == code) {

393,227,062✔

2786

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

393,235,298✔

2788

  if (TSDB_CODE_SUCCESS == code) {

392,993,895✔

2789

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

392,875,595✔

2791

  if (TSDB_CODE_SUCCESS == code) {

393,039,245✔

2792

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

392,956,979✔

2794

  if (TSDB_CODE_SUCCESS == code) {

392,678,211✔

2795

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

392,600,514✔

2797

  if (TSDB_CODE_SUCCESS == code) {

392,730,716✔

2798

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

392,656,973✔

2800

  if (TSDB_CODE_SUCCESS == code) {

392,394,844✔

2801

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

392,323,384✔

2803

  if (TSDB_CODE_SUCCESS == code) {

392,509,669✔

2804

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

392,443,756✔

2807

  return code;

392,206,358✔

2810

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

283,746,664✔

2811

  STableScanPhysiNode* pNode = (STableScanPhysiNode*)pObj;

283,746,664✔

2813

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

283,746,664✔

2814

  if (TSDB_CODE_SUCCESS == code) {

283,806,697✔

2815

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

283,806,129✔

2817

  if (TSDB_CODE_SUCCESS == code) {

283,764,878✔

2818

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

283,764,878✔

2820

  if (TSDB_CODE_SUCCESS == code) {

283,810,632✔

2821

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

283,810,632✔

2823

  if (TSDB_CODE_SUCCESS == code) {

283,764,467✔

2824

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

283,764,467✔

2826

  if (TSDB_CODE_SUCCESS == code) {

283,749,439✔

2827

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

283,749,439✔

2829

  if (TSDB_CODE_SUCCESS == code) {

283,753,794✔

2830

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

283,753,794✔

2832

  if (TSDB_CODE_SUCCESS == code) {

283,807,704✔

2833

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

283,807,704✔

2835

  if (TSDB_CODE_SUCCESS == code) {

283,768,345✔

2836

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

283,768,345✔

2838

  if (TSDB_CODE_SUCCESS == code) {

283,800,372✔

2839

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

283,800,372✔

2841

  if (TSDB_CODE_SUCCESS == code) {

283,754,506✔

2842

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

283,754,506✔

2844

  if (TSDB_CODE_SUCCESS == code) {

283,807,325✔

2845

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

283,807,325✔

2847

  if (TSDB_CODE_SUCCESS == code) {

283,758,697✔

2848

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

283,758,697✔

2850

  if (TSDB_CODE_SUCCESS == code) {

283,806,561✔

2851

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

283,806,561✔

2853

  if (TSDB_CODE_SUCCESS == code) {

283,757,249✔

2854

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

283,757,249✔

2856

  if (TSDB_CODE_SUCCESS == code) {

283,807,351✔

2857

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

283,807,351✔

2859

  if (TSDB_CODE_SUCCESS == code) {

283,755,077✔

2860

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

283,755,077✔

2862

  if (TSDB_CODE_SUCCESS == code) {

283,811,158✔

2863

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

283,811,158✔

2865

  if (TSDB_CODE_SUCCESS == code) {

283,755,127✔

2866

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

283,755,127✔

2868

  if (TSDB_CODE_SUCCESS == code) {

283,809,132✔

2869

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

283,809,132✔

2871

  if (TSDB_CODE_SUCCESS == code) {

283,752,771✔

2872

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

283,752,771✔

2874

  return code;

283,807,701✔

2877

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

283,755,720✔

2878

  STableScanPhysiNode* pNode = (STableScanPhysiNode*)pObj;

283,755,720✔

2880

  int32_t code = TSDB_CODE_SUCCESS;

283,755,720✔

2881

  STlv*   pTlv = NULL;

283,755,720✔

2882

  tlvForEach(pDecoder, pTlv, code) {

896,854,576✔

2883

    switch (pTlv->type) {

613,108,518✔

2884

      case PHY_TABLE_SCAN_CODE_SCAN:

283,731,607✔

2885

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

283,731,607✔

2886

        break;

283,783,975✔

2887

      case PHY_TABLE_SCAN_CODE_INLINE_ATTRS:

283,806,180✔

2888

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiTableScanNodeInline, pNode);

283,806,180✔

2889

        break;

283,805,948✔

2893

      case PHY_TABLE_SCAN_CODE_GROUP_TAGS:

40,823,586✔

2894

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

40,823,586✔

2895

        break;

40,821,919✔

2905

      case PHY_TABLE_SCAN_CODE_EXT_SCAN_RANGE:

3,982,128✔

2906

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

3,982,128✔

2907

        if (NULL == pNode->pExtScanRange) {

3,981,684✔

2911

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

3,982,128✔

2912

        break;

3,983,104✔

2916

      case PHY_TABLE_SCAN_CODE_PRIM_COND_EXPR:

759,124✔

2917

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

759,124✔

2918

        break;

678,660✔

2924

  return code;

283,844,658✔

2936

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

39,621,011✔

2937

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

39,621,011✔

2939

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

39,621,011✔

2940

  if (TSDB_CODE_SUCCESS == code) {

39,648,877✔

2941

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

39,650,408✔

2943

  if (TSDB_CODE_SUCCESS == code) {

39,570,517✔

2944

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

39,570,517✔

2946

  if (TSDB_CODE_SUCCESS == code) {

39,646,995✔

2947

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

39,646,995✔

2949

  if (TSDB_CODE_SUCCESS == code) {

39,645,802✔

2950

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

39,645,802✔

2952

  if (TSDB_CODE_SUCCESS == code) {

39,651,248✔

2953

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

39,651,248✔

2956

  return code;

39,650,069✔

2959

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

23,194,464✔

2960

  SSystemTableScanPhysiNode* pNode = (SSystemTableScanPhysiNode*)pObj;

23,194,464✔

2962

  int32_t code = TSDB_CODE_SUCCESS;

23,194,464✔

2963

  STlv*   pTlv = NULL;

23,194,464✔

2964

  tlvForEach(pDecoder, pTlv, code) {

162,373,695✔

2965

    switch (pTlv->type) {

139,179,614✔

2966

      case PHY_SYSTABLE_SCAN_CODE_SCAN:

23,195,562✔

2967

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

23,195,562✔

2968

        break;

23,195,616✔

2969

      case PHY_SYSTABLE_SCAN_CODE_MGMT_EP_SET:

23,196,225✔

2970

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

23,196,225✔

2971

        break;

23,197,388✔

2972

      case PHY_SYSTABLE_SCAN_CODE_SHOW_REWRITE:

23,196,107✔

2973

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

23,196,107✔

2974

        break;

23,193,957✔

2975

      case PHY_SYSTABLE_SCAN_CODE_ACCOUNT_ID:

23,196,845✔

2976

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

23,196,845✔

2977

        break;

23,196,845✔

2978

      case PHY_SYSTABLE_SCAN_CODE_SYS_INFO:

23,196,845✔

2979

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

23,196,845✔

2980

        break;

23,196,845✔

2981

      case PHY_SYSTABLE_SCAN_CODE_PRIV_INFO:

23,197,388✔

2982

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

23,197,388✔

2983

      default:

23,196,845✔

2984

        break;

23,196,845✔

2988

  return code;

23,200,082✔

2999

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

215,308,215✔

3000

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

215,308,215✔

3002

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

215,308,215✔

3003

  if (TSDB_CODE_SUCCESS == code) {

215,435,494✔

3004

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

215,436,321✔

3006

  if (TSDB_CODE_SUCCESS == code) {

215,434,148✔

3007

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

215,435,889✔

3009

  if (TSDB_CODE_SUCCESS == code) {

215,438,686✔

3010

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

215,441,602✔

3012

  if (TSDB_CODE_SUCCESS == code) {

215,435,913✔

3013

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

215,409,326✔

3016

  return code;

215,430,197✔

3019

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

151,970,700✔

3020

  SProjectPhysiNode* pNode = (SProjectPhysiNode*)pObj;

151,970,700✔

3022

  int32_t code = TSDB_CODE_SUCCESS;

151,970,700✔

3023

  STlv*   pTlv = NULL;

151,970,700✔

3024

  tlvForEach(pDecoder, pTlv, code) {

911,884,746✔

3025

    switch (pTlv->type) {

759,917,655✔

3026

      case PHY_PROJECT_CODE_BASE_NODE:

151,970,870✔

3027

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

151,970,870✔

3028

        break;

151,969,355✔

3029

      case PHY_PROJECT_CODE_PROJECTIONS:

151,982,282✔

3030

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

151,982,282✔

3031

        break;

151,984,717✔

3032

      case PHY_PROJECT_CODE_MERGE_DATA_BLOCK:

151,985,269✔

3033

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

151,985,269✔

3034

        break;

151,983,484✔

3035

      case PHY_PROJECT_CODE_IGNORE_GROUP_ID:

151,985,269✔

3036

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

151,985,269✔

3037

        break;

151,985,269✔

3038

      case PHY_PROJECT_CODE_INPUT_IGNORE_GROUP:

151,990,868✔

3039

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

151,990,868✔

3040

        break;

151,984,720✔

3046

  return code;

151,991,667✔

3073

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

16,402,890✔

3074

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

16,402,890✔

3076

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

16,402,890✔

3077

  if (TSDB_CODE_SUCCESS == code) {

16,403,955✔

3078

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

16,403,955✔

3080

  if (TSDB_CODE_SUCCESS == code) {

16,403,955✔

3081

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

16,403,955✔

3083

  if (TSDB_CODE_SUCCESS == code) {

16,403,955✔

3084

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

16,403,955✔

3086

  if (TSDB_CODE_SUCCESS == code) {

16,403,433✔

3087

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

16,403,433✔

3089

  if (TSDB_CODE_SUCCESS == code) {

16,403,955✔

3090

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

16,403,955✔

3092

  if (TSDB_CODE_SUCCESS == code) {

16,403,955✔

3093

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

16,403,955✔

3095

  if (TSDB_CODE_SUCCESS == code) {

16,403,955✔

3096

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

16,403,955✔

3098

  if (TSDB_CODE_SUCCESS == code) {

16,403,955✔

3099

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

16,403,955✔

3101

  if (TSDB_CODE_SUCCESS == code) {

16,403,955✔

3102

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

16,403,955✔

3104

  if (TSDB_CODE_SUCCESS == code) {

16,403,955✔

3105

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

16,403,955✔

3107

  if (TSDB_CODE_SUCCESS == code) {

16,403,955✔

3108

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

16,403,955✔

3110

  if (TSDB_CODE_SUCCESS == code) {

16,403,955✔

3111

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

16,403,955✔

3113

  if (TSDB_CODE_SUCCESS == code) {

16,403,955✔

3114

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

16,403,955✔

3116

  if (TSDB_CODE_SUCCESS == code) {

16,402,368✔

3117

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

16,402,368✔

3119

  if (TSDB_CODE_SUCCESS == code) {

16,403,955✔

3120

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

16,403,955✔

3122

  if (TSDB_CODE_SUCCESS == code) {

16,403,955✔

3123

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

16,403,955✔

3125

  if (TSDB_CODE_SUCCESS == code) {

16,403,955✔

3126

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

16,403,955✔

3128

  if (TSDB_CODE_SUCCESS == code) {

16,403,955✔

3129

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

16,403,955✔

3131

  if (TSDB_CODE_SUCCESS == code) {

16,403,955✔

3132

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

16,403,955✔

3134

  if (TSDB_CODE_SUCCESS == code) {

16,403,955✔

3135

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

16,403,955✔

3138

  return code;

16,403,955✔

3141

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

13,456,946✔

3142

  SSortMergeJoinPhysiNode* pNode = (SSortMergeJoinPhysiNode*)pObj;

13,456,946✔

3144

  int32_t code = TSDB_CODE_SUCCESS;

13,456,946✔

3145

  STlv*   pTlv = NULL;

13,456,946✔

3146

  tlvForEach(pDecoder, pTlv, code) {

198,035,285✔

3147

    switch (pTlv->type) {

184,577,379✔

3148

      case PHY_SORT_MERGE_JOIN_CODE_BASE_NODE:

13,457,359✔

3149

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

13,457,359✔

3150

        break;

13,457,881✔

3151

      case PHY_SORT_MERGE_JOIN_CODE_JOIN_TYPE:

13,457,881✔

3152

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

13,457,881✔

3153

        break;

13,457,881✔

3154

      case PHY_SORT_MERGE_JOIN_CODE_SUB_TYPE:

13,457,881✔

3155

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

13,457,881✔

3156

        break;

13,457,881✔

3157

      case PHY_SORT_MERGE_JOIN_CODE_WINDOW_OFFSET:

338,570✔

3158

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

338,570✔

3159

        break;

338,570✔

3160

      case PHY_SORT_MERGE_JOIN_CODE_JOIN_LIMIT:

166,315✔

3161

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

166,315✔

3162

        break;

166,315✔

3163

      case PHY_SORT_MERGE_JOIN_CODE_ASOF_OP:

13,457,359✔

3164

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

13,457,359✔

3165

        break;

13,457,881✔

3166

      case PHY_SORT_MERGE_JOIN_CODE_LEFT_PRIM_EXPR:

323,015✔

3167

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

323,015✔

3168

        break;

323,015✔

3169

      case PHY_SORT_MERGE_JOIN_CODE_RIGHT_PRIM_EXPR:

286,070✔

3170

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

286,070✔

3171

        break;

286,070✔

3172

      case PHY_SORT_MERGE_JOIN_CODE_LEFT_PRIM_SLOT_ID:

13,457,359✔

3173

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

13,457,359✔

3174

        break;

13,457,359✔

3175

      case PHY_SORT_MERGE_JOIN_CODE_RIGHT_PRIM_SLOT_ID:

13,457,881✔

3176

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

13,457,881✔

3177

        break;

13,457,881✔

3178

      case PHY_SORT_MERGE_JOIN_CODE_LEFT_EQ_COLS:

105,273✔

3179

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

105,273✔

3180

        break;

105,273✔

3181

      case PHY_SORT_MERGE_JOIN_CODE_RIGHT_EQ_COLS:

105,273✔

3182

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

105,273✔

3183

        break;

105,273✔

3184

      case PHY_SORT_MERGE_JOIN_CODE_COL_ON_CONDITIONS:

4,117,807✔

3185

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

4,117,807✔

3186

        break;

4,117,807✔

3187

      case PHY_SORT_MERGE_JOIN_CODE_FULL_ON_CONDITIONS:

4,183,672✔

3188

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

4,183,672✔

3189

        break;

4,183,672✔

3190

      case PHY_SORT_MERGE_JOIN_CODE_TARGETS:

13,457,359✔

3191

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

13,457,359✔

3192

        break;

13,457,881✔

3193

      case PHY_SORT_MERGE_JOIN_CODE_INPUT_ROW_NUM0:

13,457,881✔

3194

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

13,457,881✔

3195

        break;

13,457,881✔

3196

      case PHY_SORT_MERGE_JOIN_CODE_INPUT_ROW_NUM1:

13,457,881✔

3197

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

13,457,881✔

3198

        break;

13,457,359✔

3199

      case PHY_SORT_MERGE_JOIN_CODE_INPUT_ROW_SIZE0:

13,457,881✔

3200

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

13,457,881✔

3201

        break;

13,457,881✔

3202

      case PHY_SORT_MERGE_JOIN_CODE_INPUT_ROW_SIZE1:

13,457,881✔

3203

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

13,457,881✔

3204

        break;

13,457,881✔

3205

      case PHY_SORT_MERGE_JOIN_CODE_SEQ_WIN_GROUP:

13,457,359✔

3206

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

13,457,359✔

3207

        break;

13,457,881✔

3208

      case PHY_SORT_MERGE_JOIN_CODE_GROUP_JOIN:

13,459,422✔

3209

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

13,459,422✔

3210

        break;

13,457,881✔

3216

  return code;

13,461,476✔

3243

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

1,274,535✔

3244

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

1,274,535✔

3246

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

1,274,535✔

3247

  if (TSDB_CODE_SUCCESS == code) {

1,274,535✔

3248

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

1,274,535✔

3250

  if (TSDB_CODE_SUCCESS == code) {

1,274,535✔

3251

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

1,274,535✔

3253

  if (TSDB_CODE_SUCCESS == code) {

1,274,535✔

3254

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

1,274,535✔

3256

  if (TSDB_CODE_SUCCESS == code) {

1,274,535✔

3257

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

1,274,535✔

3259

  if (TSDB_CODE_SUCCESS == code) {

1,274,535✔

3260

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

1,274,535✔

3262

  if (TSDB_CODE_SUCCESS == code) {

1,274,535✔

3263

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

1,274,535✔

3265

  if (TSDB_CODE_SUCCESS == code) {

1,274,535✔

3266

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

1,274,535✔

3268

  if (TSDB_CODE_SUCCESS == code) {

1,274,535✔

3269

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

1,274,535✔

3271

  if (TSDB_CODE_SUCCESS == code) {

1,274,535✔

3272

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

1,274,535✔

3274

  if (TSDB_CODE_SUCCESS == code) {

1,274,535✔

3275

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

1,274,535✔

3277

  if (TSDB_CODE_SUCCESS == code) {

1,274,535✔

3278

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

1,274,535✔

3280

  if (TSDB_CODE_SUCCESS == code) {

1,274,535✔

3281

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

1,274,535✔

3283

  if (TSDB_CODE_SUCCESS == code) {

1,274,535✔

3284

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

1,274,535✔

3286

  if (TSDB_CODE_SUCCESS == code) {

1,274,535✔

3287

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

1,274,535✔

3289

  if (TSDB_CODE_SUCCESS == code) {

1,274,535✔

3290

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

1,274,535✔

3292

  if (TSDB_CODE_SUCCESS == code) {

1,274,535✔

3293

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

1,274,535✔

3295

  if (TSDB_CODE_SUCCESS == code) {

1,274,535✔

3296

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

1,274,535✔

3298

  if (TSDB_CODE_SUCCESS == code) {

1,274,535✔

3299

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

1,274,535✔

3301

  if (TSDB_CODE_SUCCESS == code) {

1,274,535✔

3302

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

1,274,535✔

3305

  return code;

1,274,535✔

3309

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

1,274,495✔

3310

  SHashJoinPhysiNode* pNode = (SHashJoinPhysiNode*)pObj;

1,274,495✔

3312

  int32_t code = TSDB_CODE_SUCCESS;

1,274,495✔

3313

  STlv*   pTlv = NULL;

1,274,495✔

3314

  tlvForEach(pDecoder, pTlv, code) {

20,391,920✔

3315

    switch (pTlv->type) {

19,117,425✔

3316

      case PHY_HASH_JOIN_CODE_BASE_NODE:

1,274,495✔

3317

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

1,274,495✔

3318

        break;

1,274,495✔

3319

      case PHY_HASH_JOIN_CODE_JOIN_TYPE:

1,274,495✔

3320

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

1,274,495✔

3321

        break;

1,274,495✔

3322

      case PHY_HASH_JOIN_CODE_JOIN_STYPE:

1,274,495✔

3323

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

1,274,495✔

3324

        break;

1,274,495✔

3325

      case PHY_HASH_JOIN_CODE_ON_LEFT_COLUMN:

1,274,495✔

3326

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

1,274,495✔

3327

        break;

1,274,495✔

3328

      case PHY_HASH_JOIN_CODE_ON_RIGHT_COLUMN:

1,274,495✔

3329

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

1,274,495✔

3330

        break;

1,274,495✔

3337

      case PHY_HASH_JOIN_CODE_LEFT_PRIM_SLOTID:

1,274,495✔

3338

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

1,274,495✔

3339

        break;

1,274,495✔

3340

      case PHY_HASH_JOIN_CODE_RIGHT_PRIM_SLOTID:

1,274,495✔

3341

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

1,274,495✔

3342

        break;

1,274,495✔

3343

      case PHY_HASH_JOIN_CODE_TIME_RANGE_TARGET:

1,274,495✔

3344

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

1,274,495✔

3345

        break;

1,274,495✔

3349

      case PHY_HASH_JOIN_CODE_TARGETS:

1,274,495✔

3350

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

1,274,495✔

3351

        break;

1,274,495✔

3352

      case PHY_HASH_JOIN_CODE_INPUT_ROW_NUM0:

1,274,495✔

3353

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

1,274,495✔

3354

        break;

1,274,495✔

3355

      case PHY_HASH_JOIN_CODE_INPUT_ROW_NUM1:

1,274,495✔

3356

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

1,274,495✔

3357

        break;

1,274,495✔

3358

      case PHY_HASH_JOIN_CODE_INPUT_ROW_SIZE0:

1,274,495✔

3359

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

1,274,495✔

3360

        break;

1,274,495✔

3361

      case PHY_HASH_JOIN_CODE_INPUT_ROW_SIZE1:

1,274,495✔

3362

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

1,274,495✔

3363

        break;

1,274,495✔

3370

      case PHY_HASH_JOIN_CODE_TIME_RANGE_SKEY:

1,274,495✔

3371

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

1,274,495✔

3372

        break;

1,274,495✔

3373

      case PHY_HASH_JOIN_CODE_TIME_RANGE_EKEY:

1,274,495✔

3374

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

1,274,495✔

3375

        break;

1,274,495✔

3381

  return code;

1,274,495✔

3395

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

168,952,343✔

3396

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

168,952,343✔

3398

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

168,952,343✔

3399

  if (TSDB_CODE_SUCCESS == code) {

169,071,118✔

3400

    code = tlvEncodeObj(pEncoder, PHY_AGG_CODE_EXPR, nodeListToMsg, pNode->pExprs);

169,074,070✔

3402

  if (TSDB_CODE_SUCCESS == code) {

168,977,203✔

3403

    code = tlvEncodeObj(pEncoder, PHY_AGG_CODE_GROUP_KEYS, nodeListToMsg, pNode->pGroupKeys);

168,962,414✔

3405

  if (TSDB_CODE_SUCCESS == code) {

168,939,524✔

3406

    code = tlvEncodeObj(pEncoder, PHY_AGG_CODE_AGG_FUNCS, nodeListToMsg, pNode->pAggFuncs);

168,927,182✔

3408

  if (TSDB_CODE_SUCCESS == code) {

169,081,057✔

3409

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

169,068,641✔

3411

  if (TSDB_CODE_SUCCESS == code) {

169,097,391✔

3412

    code = tlvEncodeBool(pEncoder, PHY_AGG_CODE_GROUP_KEY_OPTIMIZE, pNode->groupKeyOptimized);

169,085,144✔

3414

  if (TSDB_CODE_SUCCESS == code) {

169,089,296✔

3415

    code = tlvEncodeBool(pEncoder, PHY_AGG_CODE_HAS_COUNT_LIKE_FUNCS, pNode->hasCountLikeFunc);

169,073,402✔

3418

  return code;

169,080,538✔

3421

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

130,624,895✔

3422

  SAggPhysiNode* pNode = (SAggPhysiNode*)pObj;

130,624,895✔

3424

  int32_t code = TSDB_CODE_SUCCESS;

130,624,895✔

3425

  STlv*   pTlv = NULL;

130,624,895✔

3426

  tlvForEach(pDecoder, pTlv, code) {

822,758,243✔

3427

    switch (pTlv->type) {

692,123,941✔

3428

      case PHY_AGG_CODE_BASE_NODE:

130,627,583✔

3429

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

130,627,583✔

3430

        break;

130,643,394✔

3431

      case PHY_AGG_CODE_EXPR:

34,721,267✔

3432

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

34,721,267✔

3433

        break;

34,719,587✔

3434

      case PHY_AGG_CODE_GROUP_KEYS:

33,069,281✔

3435

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

33,069,281✔

3436

        break;

33,068,262✔

3437

      case PHY_AGG_CODE_AGG_FUNCS:

101,735,391✔

3438

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

101,735,391✔

3439

        break;

101,747,662✔

3440

      case PHY_AGG_CODE_MERGE_DATA_BLOCK:

130,647,067✔

3441

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

130,647,067✔

3442

        break;

130,648,086✔

3443

      case PHY_AGG_CODE_GROUP_KEY_OPTIMIZE:

130,648,094✔

3444

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

130,648,094✔

3445

        break;

130,648,654✔

3446

      case PHY_AGG_CODE_HAS_COUNT_LIKE_FUNCS:

130,673,000✔

3447

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

130,673,000✔

3448

        break;

130,648,654✔

3454

  return code;

130,672,511✔

3469

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

148,110,501✔

3470

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

148,110,501✔

3472

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

148,110,501✔

3473

  if (TSDB_CODE_SUCCESS == code) {

148,112,941✔

3474

    code = tlvEncodeI32(pEncoder, PHY_EXCHANGE_CODE_SRC_START_GROUP_ID, pNode->srcStartGroupId);

148,112,475✔

3476

  if (TSDB_CODE_SUCCESS == code) {

148,112,645✔

3477

    code = tlvEncodeI32(pEncoder, PHY_EXCHANGE_CODE_SRC_END_GROUP_ID, pNode->srcEndGroupId);

148,112,079✔

3479

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

148,113,577✔

3480

    code = tlvEncodeObj(pEncoder, PHY_EXCHANGE_CODE_CHILDREN_VGIDS, SArrayToMsg, pNode->childrenVgIds);

148,112,545✔

3482

  if (TSDB_CODE_SUCCESS == code) {

148,113,313✔

3483

    code = tlvEncodeBool(pEncoder, PHY_EXCHANGE_CODE_SINGLE_CHANNEL, pNode->grpSingleChannel);

148,112,915✔

3485

  if (TSDB_CODE_SUCCESS == code) {

148,114,077✔

3486

    code = tlvEncodeObj(pEncoder, PHY_EXCHANGE_CODE_SRC_ENDPOINTS, nodeListToMsg, pNode->pSrcEndPoints);

148,113,679✔

3488

  if (TSDB_CODE_SUCCESS == code) {

148,112,817✔

3489

    code = tlvEncodeBool(pEncoder, PHY_EXCHANGE_CODE_SEQ_RECV_DATA, pNode->seqRecvData);

148,112,935✔

3491

  if (TSDB_CODE_SUCCESS == code) {

148,113,307✔

3492

    code = tlvEncodeBool(pEncoder, PHY_EXCHANGE_CODE_DYN_TBNAME, pNode->dynTbname);

148,113,519✔

3494

  if (TSDB_CODE_SUCCESS == code) {

148,112,157✔

3495

    code = tlvEncodeBool(pEncoder, PHY_EXCHANGE_CODE_SINGLE_SOURCE, pNode->singleSrc);

148,112,369✔

3498

  return code;

148,113,439✔

3501

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

114,248,087✔

3502

  SExchangePhysiNode* pNode = (SExchangePhysiNode*)pObj;

114,248,087✔

3504

  int32_t code = TSDB_CODE_SUCCESS;

114,248,087✔

3505

  STlv*   pTlv = NULL;

114,248,087✔

3506

  tlvForEach(pDecoder, pTlv, code) {

1,142,490,157✔

3507

    switch (pTlv->type) {

1,028,245,143✔

3508

      case PHY_EXCHANGE_CODE_BASE_NODE:

114,249,137✔

3509

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

114,249,137✔

3510

        break;

114,248,615✔

3511

      case PHY_EXCHANGE_CODE_SRC_START_GROUP_ID:

114,248,766✔

3512

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

114,248,766✔

3513

        break;

114,249,288✔

3514

      case PHY_EXCHANGE_CODE_SRC_END_GROUP_ID:

114,249,686✔

3515

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

114,249,686✔

3516

        break;

114,249,686✔

3517

      case PHY_EXCHANGE_CODE_CHILDREN_VGIDS:

114,249,686✔

3518

        code = msgToSArray(pTlv, (void**)&pNode->childrenVgIds);

114,249,686✔

3519

        break;

114,247,383✔

3520

      case PHY_EXCHANGE_CODE_SINGLE_CHANNEL:

114,249,686✔

3521

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

114,249,686✔

3522

        break;

114,249,295✔

3523

      case PHY_EXCHANGE_CODE_SRC_ENDPOINTS:

114,249,686✔

3524

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

114,249,686✔

3525

        break;

114,249,158✔

3526

      case PHY_EXCHANGE_CODE_SEQ_RECV_DATA:

114,249,686✔

3527

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

114,249,686✔

3528

        break;

114,249,686✔

3529

      case PHY_EXCHANGE_CODE_DYN_TBNAME:

114,249,686✔

3530

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

114,249,686✔

3531

        break;

114,249,686✔

3532

      case PHY_EXCHANGE_CODE_SINGLE_SOURCE:

114,249,124✔

3533

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

114,249,124✔

3534

        break;

114,249,273✔

3540

  return code;

114,253,335✔

3555

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

19,189,230✔

3556

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

19,189,230✔

3558

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

19,189,230✔

3559

  if (TSDB_CODE_SUCCESS == code) {

19,189,404✔

3560

    code = tlvEncodeObj(pEncoder, PHY_MERGE_CODE_MERGE_KEYS, nodeListToMsg, pNode->pMergeKeys);

19,189,404✔

3562

  if (TSDB_CODE_SUCCESS == code) {

19,189,404✔

3563

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

19,189,404✔

3565

  if (TSDB_CODE_SUCCESS == code) {

19,189,478✔

3566

    code = tlvEncodeI32(pEncoder, PHY_MERGE_CODE_NUM_OF_CHANNELS, pNode->numOfChannels);

19,189,478✔

3568

  if (TSDB_CODE_SUCCESS == code) {

19,189,404✔

3569

    code = tlvEncodeI32(pEncoder, PHY_MERGE_CODE_SRC_GROUP_ID, pNode->srcGroupId);

19,189,330✔

3571

  if (TSDB_CODE_SUCCESS == code) {

19,189,404✔

3572

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

19,189,330✔

3574

  if (TSDB_CODE_SUCCESS == code) {

19,189,552✔

3575

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

19,189,478✔

3577

  if (TSDB_CODE_SUCCESS == code) {

19,189,478✔

3578

    code = tlvEncodeBool(pEncoder, PHY_MERGE_CODE_INPUT_WITH_GROUP_ID, pNode->inputWithGroupId);

19,189,404✔

3580

  if (TSDB_CODE_SUCCESS == code) {

19,189,552✔

3581

    code = tlvEncodeI32(pEncoder, PHY_MERGE_CODE_TYPE, pNode->type);

19,189,478✔

3584

  return code;

19,189,398✔

3587

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

14,494,921✔

3588

  SMergePhysiNode* pNode = (SMergePhysiNode*)pObj;

14,494,921✔

3590

  int32_t code = TSDB_CODE_SUCCESS;

14,494,921✔

3591

  STlv*   pTlv = NULL;

14,494,921✔

3592

  tlvForEach(pDecoder, pTlv, code) {

144,323,602✔

3593

    switch (pTlv->type) {

129,828,681✔

3594

      case PHY_MERGE_CODE_BASE_NODE:

14,494,921✔

3595

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

14,494,921✔

3596

        break;

14,495,470✔

3597

      case PHY_MERGE_CODE_MERGE_KEYS:

13,860,169✔

3598

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

13,860,169✔

3599

        break;

13,860,697✔

3600

      case PHY_MERGE_CODE_TARGETS:

14,495,057✔

3601

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

14,495,057✔

3602

        break;

14,495,998✔

3603

      case PHY_MERGE_CODE_NUM_OF_CHANNELS:

14,495,998✔

3604

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

14,495,998✔

3605

        break;

14,495,998✔

3606

      case PHY_MERGE_CODE_SRC_GROUP_ID:

14,495,998✔

3607

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

14,495,998✔

3608

        break;

14,495,998✔

3609

      case PHY_MERGE_CODE_GROUP_SORT:

14,495,998✔

3610

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

14,495,998✔

3611

        break;

14,495,998✔

3612

      case PHY_MERGE_CODE_IGNORE_GROUP_ID:

14,495,998✔

3613

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

14,495,998✔

3614

        break;

14,495,998✔

3615

      case PHY_MERGE_CODE_INPUT_WITH_GROUP_ID:

14,495,998✔

3616

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

14,495,998✔

3617

        break;

14,495,998✔

3618

      case PHY_MERGE_CODE_TYPE:

14,498,544✔

3619

        code = tlvDecodeI32(pTlv, (int32_t*)&pNode->type);

14,498,544✔

3620

        break;

14,495,998✔

3626

  return code;

14,495,998✔

3638

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

55,795,064✔

3639

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

55,795,064✔

3641

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

55,795,064✔

3642

  if (TSDB_CODE_SUCCESS == code) {

55,815,834✔

3643

    code = tlvEncodeObj(pEncoder, PHY_SORT_CODE_EXPR, nodeListToMsg, pNode->pExprs);

55,815,998✔

3645

  if (TSDB_CODE_SUCCESS == code) {

55,803,479✔

3646

    code = tlvEncodeObj(pEncoder, PHY_SORT_CODE_SORT_KEYS, nodeListToMsg, pNode->pSortKeys);

55,793,124✔

3648

  if (TSDB_CODE_SUCCESS == code) {

55,826,016✔

3649

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

55,815,897✔

3651

  if (TSDB_CODE_SUCCESS == code) {

55,826,150✔

3652

    code = tlvEncodeBool(pEncoder, PHY_SORT_CODE_CALC_GROUPID, pNode->calcGroupId);

55,816,105✔

3654

  if (TSDB_CODE_SUCCESS == code) {

55,826,801✔

3655

    code = tlvEncodeBool(pEncoder, PHY_SORT_CODE_EXCLUDE_PK_COL, pNode->excludePkCol);

55,816,682✔

3658

  return code;

55,817,323✔

3661

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

34,589,737✔

3662

  SSortPhysiNode* pNode = (SSortPhysiNode*)pObj;

34,589,737✔

3664

  int32_t code = TSDB_CODE_SUCCESS;

34,589,737✔

3665

  STlv*   pTlv = NULL;

34,589,737✔

3666

  tlvForEach(pDecoder, pTlv, code) {

208,393,583✔

3667

    switch (pTlv->type) {

173,803,120✔

3668

      case PHY_SORT_CODE_BASE_NODE:

34,588,591✔

3669

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

34,588,591✔

3670

        break;

34,591,924✔

3671

      case PHY_SORT_CODE_EXPR:

845,720✔

3672

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

845,720✔

3673

        break;

845,720✔

3674

      case PHY_SORT_CODE_SORT_KEYS:

34,590,807✔

3675

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

34,590,807✔

3676

        break;

34,591,256✔

3677

      case PHY_SORT_CODE_TARGETS:

34,589,971✔

3678

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

34,589,971✔

3679

        break;

34,590,707✔

3680

      case PHY_SORT_CODE_CALC_GROUPID:

34,591,924✔

3681

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

34,591,924✔

3682

        break;

34,591,924✔

3683

      case PHY_SORT_CODE_EXCLUDE_PK_COL:

34,591,924✔

3684

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

34,591,924✔

3685

      default:

34,591,924✔

3686

        break;

34,591,924✔

3690

  return code;

34,591,805✔

3710

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

23,935,622✔

3711

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

23,935,622✔

3713

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

23,935,622✔

3714

  if (TSDB_CODE_SUCCESS == code) {

23,951,941✔

3715

    code = tlvEncodeObj(pEncoder, PHY_WINDOW_CODE_EXPR, nodeListToMsg, pNode->pExprs);

23,952,367✔

3717

  if (TSDB_CODE_SUCCESS == code) {

23,949,901✔

3718

    code = tlvEncodeObj(pEncoder, PHY_WINDOW_CODE_FUNCS, nodeListToMsg, pNode->pFuncs);

23,949,903✔

3720

  if (TSDB_CODE_SUCCESS == code) {

23,953,587✔

3721

    code = tlvEncodeObj(pEncoder, PHY_WINDOW_CODE_TS_PK, nodeToMsg, pNode->pTspk);

23,953,589✔

3723

  if (TSDB_CODE_SUCCESS == code) {

23,954,102✔

3724

    code = tlvEncodeObj(pEncoder, PHY_WINDOW_CODE_TS_END, nodeToMsg, pNode->pTsEnd);

23,953,232✔

3726

  if (TSDB_CODE_SUCCESS == code) {

23,953,021✔

3727

    code = tlvEncodeI8(pEncoder, PHY_WINDOW_CODE_TRIGGER_TYPE, pNode->unusedParam1);

23,952,405✔

3729

  if (TSDB_CODE_SUCCESS == code) {

23,955,969✔

3730

    code = tlvEncodeI64(pEncoder, PHY_WINDOW_CODE_WATERMARK, pNode->unusedParam2);

23,955,425✔

3732

  if (TSDB_CODE_SUCCESS == code) {

23,954,605✔

3733

    code = tlvEncodeI64(pEncoder, PHY_WINDOW_CODE_DELETE_MARK, pNode->unusedParam3);

23,954,061✔

3735

  if (TSDB_CODE_SUCCESS == code) {

23,955,459✔

3736

    code = tlvEncodeI8(pEncoder, PHY_WINDOW_CODE_IG_EXPIRED, pNode->unusedParam4);

23,954,033✔

3738

  if (TSDB_CODE_SUCCESS == code) {

23,956,782✔

3739

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

23,955,356✔

3741

  if (TSDB_CODE_SUCCESS == code) {

23,956,736✔

3742

    code = tlvEncodeI8(pEncoder, PHY_WINDOW_CODE_INDEF_ROWS_FUNC, pNode->indefRowsFunc);

23,955,310✔

3744

  if (TSDB_CODE_SUCCESS == code) {

23,956,397✔

3745

    code = tlvEncodeObj(pEncoder, PHY_WINDOW_CODE_PROJS, nodeListToMsg, pNode->pProjs);

23,954,971✔

3748

  return code;

23,950,010✔

3751

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

9,636,584✔

3752

  SWindowPhysiNode* pNode = (SWindowPhysiNode*)pObj;

9,636,584✔

3754

  int32_t code = TSDB_CODE_SUCCESS;

9,636,584✔

3755

  STlv*   pTlv = NULL;

9,636,584✔

3756

  tlvForEach(pDecoder, pTlv, code) {

97,807,007✔

3757

    switch (pTlv->type) {

88,168,644✔

3758

      case PHY_WINDOW_CODE_BASE_NODE:

9,635,436✔

3759

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

9,635,436✔

3760

        break;

9,637,009✔

3761

      case PHY_WINDOW_CODE_EXPR:

916,494✔

3762

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

916,494✔

3763

        break;

916,494✔

3764

      case PHY_WINDOW_CODE_FUNCS:

9,506,682✔

3765

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

9,506,682✔

3766

        break;

9,506,682✔

3767

      case PHY_WINDOW_CODE_TS_PK:

9,637,009✔

3768

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

9,637,009✔

3769

        break;

9,637,009✔

3770

      case PHY_WINDOW_CODE_TS_END:

597,979✔

3771

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

597,979✔

3772

        break;

597,979✔

3773

      case PHY_WINDOW_CODE_TRIGGER_TYPE:

9,637,009✔

3774

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

9,637,009✔

3775

        break;

9,637,009✔

3776

      case PHY_WINDOW_CODE_WATERMARK:

9,637,009✔

3777

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

9,637,009✔

3778

        break;

9,637,009✔

3779

      case PHY_WINDOW_CODE_DELETE_MARK:

9,637,009✔

3780

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

9,637,009✔

3781

        break;

9,637,009✔

3782

      case PHY_WINDOW_CODE_IG_EXPIRED:

9,637,009✔

3783

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

9,637,009✔

3784

        break;

9,637,009✔

3785

      case PHY_WINDOW_CODE_MERGE_DATA_BLOCK:

9,637,009✔

3786

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

9,637,009✔

3787

        break;

9,637,009✔

3788

      case PHY_WINDOW_CODE_INDEF_ROWS_FUNC:

9,637,009✔

3789

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

9,637,009✔

3790

        break;

9,637,009✔

3791

      case PHY_WINDOW_CODE_PROJS:

52,995✔

3792

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

52,995✔

3793

        break;

53,764✔

3799

  return code;

9,641,563✔

3804

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

14,041,060✔

3805

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

14,041,060✔

3807

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

14,041,060✔

3808

  if (TSDB_CODE_SUCCESS == code) {

14,049,155✔

3809

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

14,049,803✔

3811

  if (TSDB_CODE_SUCCESS == code) {

14,051,242✔

3812

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

14,048,910✔

3814

  if (TSDB_CODE_SUCCESS == code) {

14,053,017✔

3815

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

14,050,883✔

3817

  if (TSDB_CODE_SUCCESS == code) {

14,053,395✔

3818

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

14,050,957✔

3821

  return code;

14,051,269✔

3824

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

14,036,430✔

3825

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

14,036,430✔

3827

  int32_t code = tlvEncodeObj(pEncoder, PHY_INTERVAL_CODE_WINDOW, physiWindowNodeToMsg, &pNode->window);

14,036,430✔

3828

  if (TSDB_CODE_SUCCESS == code) {

14,050,009✔

3829

    code = tlvEncodeObj(pEncoder, PHY_INTERVAL_CODE_INLINE_ATTRS, physiIntervalNodeInlineToMsg, pNode);

14,051,327✔

3831

  if (TSDB_CODE_SUCCESS == code) {

14,050,814✔

3832

    code = tlvEncodeObj(pEncoder, PHY_INTERVAL_CODE_TIME_RANGE, timeWindowToMsg, &pNode->timeRange);

14,052,132✔

3835

  return code;

14,042,672✔

3838

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

5,927,874✔

3839

  SIntervalPhysiNode* pNode = (SIntervalPhysiNode*)pObj;

5,927,874✔

3841

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

5,927,874✔

3842

  if (TSDB_CODE_SUCCESS == code) {

5,927,874✔

3843

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

5,927,874✔

3845

  if (TSDB_CODE_SUCCESS == code) {

5,927,874✔

3846

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

5,927,874✔

3848

  if (TSDB_CODE_SUCCESS == code) {

5,927,874✔

3849

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

5,927,874✔

3851

  if (TSDB_CODE_SUCCESS == code) {

5,927,874✔

3852

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

5,927,874✔

3855

  return code;

5,927,874✔

3858

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

5,927,874✔

3859

  SIntervalPhysiNode* pNode = (SIntervalPhysiNode*)pObj;

5,927,874✔

3861

  int32_t code = TSDB_CODE_SUCCESS;

5,927,874✔

3862

  STlv*   pTlv = NULL;

5,927,874✔

3863

  tlvForEach(pDecoder, pTlv, code) {

23,711,496✔

3864

    switch (pTlv->type) {

17,783,622✔

3865

      case PHY_INTERVAL_CODE_WINDOW:

5,927,874✔

3866

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiWindowNode, &pNode->window);

5,927,874✔

3867

        break;

5,927,874✔

3868

      case PHY_INTERVAL_CODE_INLINE_ATTRS:

5,927,874✔

3869

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiIntervalNodeInline, pNode);

5,927,874✔

3870

        break;

5,927,874✔

3871

      case PHY_INTERVAL_CODE_TIME_RANGE:

5,927,874✔

3872

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

5,927,874✔

3873

      default:

5,927,874✔

3874

        break;

5,927,874✔

3878

  return code;

5,927,885✔

3896

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

600,177✔

3897

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

600,177✔

3899

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

600,177✔

3900

  if (TSDB_CODE_SUCCESS == code) {

600,603✔

3901

    code = tlvEncodeEnum(pEncoder, PHY_FILL_CODE_MODE, pNode->mode);

600,603✔

3903

  if (TSDB_CODE_SUCCESS == code) {

600,603✔

3904

    code = tlvEncodeObj(pEncoder, PHY_FILL_CODE_FILL_EXPRS, nodeListToMsg, pNode->pFillExprs);

600,603✔

3906

  if (TSDB_CODE_SUCCESS == code) {

600,603✔

3907

    code = tlvEncodeObj(pEncoder, PHY_FILL_CODE_NOT_FILL_EXPRS, nodeListToMsg, pNode->pNotFillExprs);

600,603✔

3909

  if (TSDB_CODE_SUCCESS == code) {

600,603✔

3910

    code = tlvEncodeObj(pEncoder, PHY_FILL_CODE_WSTART, nodeToMsg, pNode->pWStartTs);

600,603✔

3912

  if (TSDB_CODE_SUCCESS == code) {

600,603✔

3913

    code = tlvEncodeObj(pEncoder, PHY_FILL_CODE_VALUES, nodeToMsg, pNode->pValues);

600,603✔

3915

  if (TSDB_CODE_SUCCESS == code) {

600,603✔

3916

    code = tlvEncodeObj(pEncoder, PHY_FILL_CODE_TIME_RANGE, timeWindowToMsg, &pNode->timeRange);

600,603✔

3918

  if (TSDB_CODE_SUCCESS == code) {

600,158✔

3919

    code = tlvEncodeObj(pEncoder, PHY_FILL_CODE_FILL_NULL_EXPRS, nodeListToMsg, pNode->pFillNullExprs);

600,158✔

3921

  if (TSDB_CODE_SUCCESS == code) {

600,158✔

3922

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

600,158✔

3924

  if (TSDB_CODE_SUCCESS == code) {

600,158✔

3925

    code = tlvEncodeObj(pEncoder, PHY_FILL_CODE_SURROUNDING_TIME, nodeToMsg,

600,158✔

3926

                        pNode->pSurroundingTime);

600,158✔

3928

  if (TSDB_CODE_SUCCESS == code) {

600,603✔

3929

    code = tlvEncodeBool(pEncoder, PHY_FILL_CODE_INDEF_ROWS_MODE, pNode->indefRowsMode);

600,603✔

3931

  return code;

600,603✔

3934

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

594,893✔

3935

  SFillPhysiNode* pNode = (SFillPhysiNode*)pObj;

594,893✔

3937

  int32_t code = TSDB_CODE_SUCCESS;

594,893✔

3938

  STlv*   pTlv = NULL;

594,893✔

3939

  tlvForEach(pDecoder, pTlv, code) {

4,813,582✔

3940

    switch (pTlv->type) {

4,218,689✔

3941

      case PHY_FILL_CODE_BASE_NODE:

594,893✔

3942

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

594,893✔

3943

        break;

594,893✔

3944

      case PHY_FILL_CODE_MODE:

594,893✔

3945

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

594,893✔

3946

        break;

594,893✔

3947

      case PHY_FILL_CODE_FILL_EXPRS:

594,095✔

3948

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

594,095✔

3949

        break;

594,095✔

3950

      case PHY_FILL_CODE_NOT_FILL_EXPRS:

518,029✔

3951

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

518,029✔

3952

        break;

518,029✔

3953

      case PHY_FILL_CODE_WSTART:

594,893✔

3954

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

594,893✔

3955

        break;

594,893✔

3956

      case PHY_FILL_CODE_VALUES:

106,948✔

3957

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

106,948✔

3958

        break;

106,948✔

3959

      case PHY_FILL_CODE_TIME_RANGE:

594,893✔

3960

        code = tlvDecodeObjFromTlv(pTlv, msgToTimeWindow, (void**)&pNode->timeRange);

594,893✔

3961

        break;

594,893✔

3962

      case PHY_FILL_CODE_FILL_NULL_EXPRS:

19,167✔

3963

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

19,167✔

3964

        break;

19,167✔

3968

      case PHY_FILL_CODE_SURROUNDING_TIME:

5,985✔

3969

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

5,985✔

3970

        break;

5,985✔

3971

      case PHY_FILL_CODE_INDEF_ROWS_MODE:

594,893✔

3972

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

594,893✔

3973

        break;

594,893✔

3979

  return code;

594,893✔

3984

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

2,477,426✔

3985

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

2,477,426✔

3987

  int32_t code = tlvEncodeObj(pEncoder, PHY_SESSION_CODE_WINDOW, physiWindowNodeToMsg, &pNode->window);

2,477,426✔

3988

  if (TSDB_CODE_SUCCESS == code) {

2,477,682✔

3989

    code = tlvEncodeI64(pEncoder, PHY_SESSION_CODE_GAP, pNode->gap);

2,477,682✔

3992

  return code;

2,477,682✔

3995

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

597,979✔

3996

  SSessionWinodwPhysiNode* pNode = (SSessionWinodwPhysiNode*)pObj;

597,979✔

3998

  int32_t code = TSDB_CODE_SUCCESS;

597,979✔

3999

  STlv*   pTlv = NULL;

597,979✔

4000

  tlvForEach(pDecoder, pTlv, code) {

1,793,937✔

4001

    switch (pTlv->type) {

1,195,958✔

4002

      case PHY_SESSION_CODE_WINDOW:

597,979✔

4003

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiWindowNode, &pNode->window);

597,979✔

4004

        break;

597,979✔

4005

      case PHY_SESSION_CODE_GAP:

597,979✔

4006

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

597,979✔

4007

        break;

597,979✔

4013

  return code;

597,979✔

4034

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

1,484,891✔

4035

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

1,484,891✔

4036

  int32_t code = tlvEncodeObj(pEncoder, PHY_EXT_CODE_WINDOW, physiWindowNodeToMsg, &pNode->window);

1,484,891✔

4037

  if (TSDB_CODE_SUCCESS == code) {

1,485,309✔

4038

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

1,485,309✔

4040

  if (TSDB_CODE_SUCCESS == code) {

1,485,309✔

4041

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

1,485,309✔

4043

  if (TSDB_CODE_SUCCESS == code) {

1,485,309✔

4044

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

1,485,309✔

4046

  if (TSDB_CODE_SUCCESS == code) {

1,485,309✔

4047

    code = tlvEncodeBool(pEncoder, PHY_EXT_CODE_IS_SINGLE_TABLE, pNode->isSingleTable);

1,485,309✔

4049

  if (TSDB_CODE_SUCCESS == code) {

1,485,309✔

4050

    code = tlvEncodeBool(pEncoder, PHY_EXT_CODE_INPUT_HAS_ORDER, pNode->inputHasOrder);

1,485,309✔

4052

  if (TSDB_CODE_SUCCESS == code) {

1,485,309✔

4053

    code = tlvEncodeI64(pEncoder, PHY_EXT_CODE_ORG_TABLE_UID, pNode->orgTableUid);

1,485,309✔

4055

  if (TSDB_CODE_SUCCESS == code) {

1,485,309✔

4056

    code = tlvEncodeI32(pEncoder, PHY_EXT_CODE_ORG_TABLE_VGID, pNode->orgTableVgId);

1,485,309✔

4058

  if (TSDB_CODE_SUCCESS == code) {

1,485,309✔

4059

    code = tlvEncodeBool(pEncoder, PHY_EXT_CODE_NEED_GROUP_SORT, pNode->needGroupSort);

1,485,309✔

4061

  if (TSDB_CODE_SUCCESS == code) {

1,485,309✔

4062

    code = tlvEncodeBool(pEncoder, PHY_EXT_CODE_CALC_WITH_PARTITION, pNode->calcWithPartition);

1,485,309✔

4064

  if (TSDB_CODE_SUCCESS == code) {

1,485,309✔

4065

    code = tlvEncodeBool(pEncoder, PHY_EXT_CODE_EXT_WIN_SPLIT, pNode->extWinSplit);

1,485,309✔

4067

  if (TSDB_CODE_SUCCESS == code) {

1,485,309✔

4068

    code = tlvEncodeEnum(pEncoder, PHY_EXT_CODE_FILL_MODE, pNode->extFill.mode);

1,485,309✔

4070

  if (TSDB_CODE_SUCCESS == code) {

1,485,309✔

4071

    code = tlvEncodeObj(pEncoder, PHY_EXT_CODE_FILL_EXPRS, nodeListToMsg, pNode->extFill.pFillExprs);

1,485,309✔

4073

  if (TSDB_CODE_SUCCESS == code) {

1,485,309✔

4074

    code = tlvEncodeObj(pEncoder, PHY_EXT_CODE_FILL_VALUES, nodeToMsg, pNode->extFill.pFillValues);

1,485,309✔

4076

  if (TSDB_CODE_SUCCESS == code) {

1,484,489✔

4077

    code = tlvEncodeObj(pEncoder, PHY_EXT_CODE_SUB_QUERY, nodeToMsg, pNode->pSubquery);

1,484,489✔

4080

  return code;

1,485,309✔

4083

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

1,470,374✔

4084

  SExternalWindowPhysiNode* pNode = (SExternalWindowPhysiNode*)pObj;

1,470,374✔

4086

  int32_t code = TSDB_CODE_SUCCESS;

1,470,374✔

4087

  STlv*   pTlv = NULL;

1,470,374✔

4088

  tlvForEach(pDecoder, pTlv, code) {

18,173,882✔

4089

    switch (pTlv->type) {

16,703,508✔

4090

      case PHY_EXT_CODE_WINDOW:

1,470,374✔

4091

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiWindowNode, &pNode->window);

1,470,374✔

4092

        break;

1,470,374✔

4093

      case PHY_EXT_CODE_SKEY:

1,470,374✔

4094

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

1,470,374✔

4095

        break;

1,470,374✔

4096

      case PHY_EXT_CODE_EKEY:

1,470,374✔

4097

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

1,470,374✔

4098

        break;

1,470,374✔

4102

      case PHY_EXT_CODE_IS_SINGLE_TABLE:

1,470,374✔

4103

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

1,470,374✔

4104

        break;

1,470,374✔

4105

      case PHY_EXT_CODE_INPUT_HAS_ORDER:

1,470,374✔

4106

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

1,470,374✔

4107

        break;

1,470,374✔

4108

      case PHY_EXT_CODE_ORG_TABLE_UID:

1,470,374✔

4109

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

1,470,374✔

4110

        break;

1,470,374✔

4111

      case PHY_EXT_CODE_ORG_TABLE_VGID:

1,470,374✔

4112

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

1,470,374✔

4113

        break;

1,470,374✔

4114

      case PHY_EXT_CODE_NEED_GROUP_SORT:

1,470,374✔

4115

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

1,470,374✔

4116

        break;

1,470,374✔

4117

      case PHY_EXT_CODE_CALC_WITH_PARTITION:

1,470,374✔

4118

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

1,470,374✔

4119

        break;

1,470,374✔

4120

      case PHY_EXT_CODE_EXT_WIN_SPLIT:

1,470,374✔

4121

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

1,470,374✔

4122

        break;

1,470,374✔

4123

      case PHY_EXT_CODE_FILL_MODE:

1,470,374✔

4124

        code = tlvDecodeEnum(pTlv, &pNode->extFill.mode, sizeof(pNode->extFill.mode));

1,470,374✔

4125

        break;

1,470,374✔

4126

      case PHY_EXT_CODE_FILL_EXPRS:

19,184✔

4127

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->extFill.pFillExprs);

19,184✔

4128

        break;

19,184✔

4129

      case PHY_EXT_CODE_FILL_VALUES:

19,184✔

4130

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->extFill.pFillValues);

19,184✔

4131

        break;

19,184✔

4132

      case PHY_EXT_CODE_SUB_QUERY:

491,026✔

4133

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

491,026✔

4134

        break;

491,026✔

4139

  return code;

1,470,374✔

4144

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

2,447,671✔

4145

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

2,447,671✔

4147

  int32_t code = tlvEncodeObj(pEncoder, PHY_STATE_CODE_WINDOW, physiWindowNodeToMsg, &pNode->window);

2,447,671✔

4148

  if (TSDB_CODE_SUCCESS == code) {

2,447,766✔

4149

    code = tlvEncodeObj(pEncoder, PHY_STATE_CODE_KEY, nodeToMsg, pNode->pStateKey);

2,447,766✔

4151

  if (TSDB_CODE_SUCCESS == code) {

2,448,193✔

4152

    code = tlvEncodeI32(pEncoder, PHY_STATE_CODE_TRUE_FOR_TYPE, pNode->trueForType);

2,448,193✔

4154

  if (TSDB_CODE_SUCCESS == code) {

2,448,193✔

4155

    code = tlvEncodeI32(pEncoder, PHY_STATE_CODE_TRUE_FOR_COUNT, pNode->trueForCount);

2,448,193✔

4157

  if (TSDB_CODE_SUCCESS == code) {

2,448,193✔

4158

    code = tlvEncodeI64(pEncoder, PHY_STATE_CODE_TRUE_FOR_DURATION, pNode->trueForDuration);

2,448,193✔

4160

  if (TSDB_CODE_SUCCESS == code) {

2,448,193✔

4161

    code = tlvEncodeI32(pEncoder, PHY_STATE_CODE_EXTEND_OPTION, pNode->extendOption);

2,448,193✔

4164

  return code;

2,448,193✔

4167

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

1,027,780✔

4168

  SStateWindowPhysiNode* pNode = (SStateWindowPhysiNode*)pObj;

1,027,780✔

4170

  int32_t code = TSDB_CODE_SUCCESS;

1,027,780✔

4171

  STlv*   pTlv = NULL;

1,027,780✔

4172

  tlvForEach(pDecoder, pTlv, code) {

7,194,460✔

4173

    switch (pTlv->type) {

6,166,680✔

4174

      case PHY_STATE_CODE_WINDOW:

1,027,780✔

4175

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiWindowNode, &pNode->window);

1,027,780✔

4176

        break;

1,027,780✔

4177

      case PHY_STATE_CODE_KEY:

1,027,780✔

4178

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

1,027,780✔

4179

        break;

1,027,780✔

4180

      case PHY_STATE_CODE_TRUE_FOR_TYPE:

1,027,780✔

4181

        code = tlvDecodeI32(pTlv, (int32_t*)&pNode->trueForType);

1,027,780✔

4182

        break;

1,027,780✔

4183

      case PHY_STATE_CODE_TRUE_FOR_COUNT:

1,027,780✔

4184

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

1,027,780✔

4185

        break;

1,027,780✔

4186

      case PHY_STATE_CODE_TRUE_FOR_DURATION:

1,027,780✔

4187

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

1,027,780✔

4188

        break;

1,027,780✔

4189

      case PHY_STATE_CODE_EXTEND_OPTION:

1,027,780✔

4190

        code = tlvDecodeI32(pTlv, (int32_t*)&pNode->extendOption);

1,027,780✔

4191

      default:

1,027,780✔

4192

        break;

1,027,780✔

4196

  return code;

1,027,780✔

4201

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

1,814,294✔

4202

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

1,814,294✔

4204

  int32_t code = tlvEncodeObj(pEncoder, PHY_EVENT_CODE_WINDOW, physiWindowNodeToMsg, &pNode->window);

1,814,294✔

4205

  if (TSDB_CODE_SUCCESS == code) {

1,815,337✔

4206

    code = tlvEncodeObj(pEncoder, PHY_EVENT_CODE_START_COND, nodeToMsg, pNode->pStartCond);

1,815,337✔

4208

  if (TSDB_CODE_SUCCESS == code) {

1,815,337✔

4209

    code = tlvEncodeObj(pEncoder, PHY_EVENT_CODE_END_COND, nodeToMsg, pNode->pEndCond);

1,815,337✔

4211

  if (TSDB_CODE_SUCCESS == code) {

1,815,337✔

4212

    code = tlvEncodeI32(pEncoder, PHY_EVENT_CODE_TRUE_FOR_TYPE, pNode->trueForType);

1,815,337✔

4214

  if (TSDB_CODE_SUCCESS == code) {

1,815,263✔

4215

    code = tlvEncodeI32(pEncoder, PHY_EVENT_CODE_TRUE_FOR_COUNT, pNode->trueForCount);

1,815,263✔

4217

  if (TSDB_CODE_SUCCESS == code) {

1,815,337✔

4218

    code = tlvEncodeI64(pEncoder, PHY_EVENT_CODE_TRUE_FOR_DURATION, pNode->trueForDuration);

1,815,337✔

4221

  return code;

1,815,263✔

4224

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

337,781✔

4225

  SEventWinodwPhysiNode* pNode = (SEventWinodwPhysiNode*)pObj;

337,781✔

4227

  int32_t code = TSDB_CODE_SUCCESS;

337,781✔

4228

  STlv*   pTlv = NULL;

337,781✔

4229

  tlvForEach(pDecoder, pTlv, code) {

2,364,467✔

4230

    switch (pTlv->type) {

2,026,686✔

4231

      case PHY_EVENT_CODE_WINDOW:

337,781✔

4232

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiWindowNode, &pNode->window);

337,781✔

4233

        break;

337,781✔

4234

      case PHY_EVENT_CODE_START_COND:

337,781✔

4235

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

337,781✔

4236

        break;

337,781✔

4237

      case PHY_EVENT_CODE_END_COND:

337,781✔

4238

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

337,781✔

4239

        break;

337,781✔

4240

      case PHY_EVENT_CODE_TRUE_FOR_TYPE:

337,781✔

4241

        code = tlvDecodeI32(pTlv, (int32_t *)&pNode->trueForType);

337,781✔

4242

        break;

337,781✔

4243

      case PHY_EVENT_CODE_TRUE_FOR_COUNT:

337,781✔

4244

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

337,781✔

4245

        break;

337,781✔

4246

      case PHY_EVENT_CODE_TRUE_FOR_DURATION:

337,781✔

4247

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

337,781✔

4248

        break;

337,781✔

4254

  return code;

337,781✔

4259

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

1,674,792✔

4260

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

1,674,792✔

4262

  int32_t code = tlvEncodeObj(pEncoder, PHY_COUNT_CODE_WINDOW, physiWindowNodeToMsg, &pNode->window);

1,674,792✔

4263

  if (TSDB_CODE_SUCCESS == code) {

1,674,792✔

4264

    code = tlvEncodeI64(pEncoder, PHY_COUNT_CODE_WINDOW_COUNT, pNode->windowCount);

1,674,792✔

4266

  if (TSDB_CODE_SUCCESS == code) {

1,674,792✔

4267

    code = tlvEncodeI64(pEncoder, PHY_COUNT_CODE_WINDOW_SLIDING, pNode->windowSliding);

1,674,792✔

4270

  return code;

1,674,792✔

4273

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

275,221✔

4274

  SCountWindowPhysiNode* pNode = (SCountWindowPhysiNode*)pObj;

275,221✔

4276

  int32_t code = TSDB_CODE_SUCCESS;

275,221✔

4277

  STlv*   pTlv = NULL;

275,221✔

4278

  tlvForEach(pDecoder, pTlv, code) {

1,100,884✔

4279

    switch (pTlv->type) {

825,663✔

4280

      case PHY_COUNT_CODE_WINDOW:

275,221✔

4281

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiWindowNode, &pNode->window);

275,221✔

4282

        break;

275,221✔

4283

      case PHY_COUNT_CODE_WINDOW_COUNT:

275,221✔

4284

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

275,221✔

4285

        break;

275,221✔

4286

      case PHY_COUNT_CODE_WINDOW_SLIDING:

275,221✔

4287

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

275,221✔

4288

        break;

275,221✔

4294

  return code;

275,221✔

4346

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

10,965,882✔

4347

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

10,965,882✔

4349

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

10,965,882✔

4350

  if (TSDB_CODE_SUCCESS == code) {

10,974,079✔

4351

    code = tlvEncodeObj(pEncoder, PHY_PARTITION_CODE_EXPR, nodeListToMsg, pNode->pExprs);

10,974,079✔

4353

  if (TSDB_CODE_SUCCESS == code) {

10,973,928✔

4354

    code = tlvEncodeObj(pEncoder, PHY_PARTITION_CODE_KEYS, nodeListToMsg, pNode->pPartitionKeys);

10,973,908✔

4356

  if (TSDB_CODE_SUCCESS == code) {

10,975,378✔

4357

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

10,975,358✔

4359

  if (TSDB_CODE_SUCCESS == code) {

10,973,968✔

4360

    code = tlvEncodeBool(pEncoder, PHY_PARTITION_CODE_HAS_OUTPUT_TS_ORDER, pNode->needBlockOutputTsOrder);

10,973,640✔

4362

  if (TSDB_CODE_SUCCESS == code) {

10,975,320✔

4363

    code = tlvEncodeI32(pEncoder, PHY_PARTITION_CODE_TS_SLOTID, pNode->tsSlotId);

10,974,992✔

4366

  return code;

10,974,761✔

4369

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

3,105,656✔

4370

  SPartitionPhysiNode* pNode = (SPartitionPhysiNode*)pObj;

3,105,656✔

4372

  int32_t code = TSDB_CODE_SUCCESS;

3,105,656✔

4373

  STlv*   pTlv = NULL;

3,105,656✔

4374

  tlvForEach(pDecoder, pTlv, code) {

18,724,028✔

4375

    switch (pTlv->type) {

15,620,014✔

4376

      case PHY_PARTITION_CODE_BASE_NODE:

3,106,059✔

4377

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

3,106,059✔

4378

        break;

3,106,059✔

4379

      case PHY_PARTITION_CODE_EXPR:

85,614✔

4380

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

85,614✔

4381

        break;

85,614✔

4382

      case PHY_PARTITION_CODE_KEYS:

3,106,467✔

4383

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

3,106,467✔

4384

        break;

3,106,880✔

4385

      case PHY_PARTITION_CODE_TARGETS:

3,106,880✔

4386

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

3,106,880✔

4387

        break;

3,106,880✔

4388

      case PHY_PARTITION_CODE_HAS_OUTPUT_TS_ORDER:

3,106,880✔

4389

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

3,106,880✔

4390

        break;

3,106,472✔

4391

      case PHY_PARTITION_CODE_TS_SLOTID:

3,106,885✔

4392

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

3,106,885✔

4393

        break;

3,106,472✔

4399

  return code;

3,108,115✔

4404

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

3,304,007✔

4405

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

3,304,007✔

4407

  int32_t code = tlvEncodeObj(pEncoder, PHY_INDEF_ROWS_FUNC_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

3,304,007✔

4408

  if (TSDB_CODE_SUCCESS == code) {

3,304,007✔

4409

    code = tlvEncodeObj(pEncoder, PHY_INDEF_ROWS_FUNC_CODE_EXPRS, nodeListToMsg, pNode->pExprs);

3,304,007✔

4411

  if (TSDB_CODE_SUCCESS == code) {

3,302,354✔

4412

    code = tlvEncodeObj(pEncoder, PHY_INDEF_ROWS_FUNC_CODE_FUNCS, nodeListToMsg, pNode->pFuncs);

3,302,354✔

4415

  return code;

3,303,479✔

4418

static int32_t msgToPhysiIndefRowsFuncNode(STlvDecoder* pDecoder, void* pObj) {

3,274,962✔

4419

  SIndefRowsFuncPhysiNode* pNode = (SIndefRowsFuncPhysiNode*)pObj;

3,274,962✔

4421

  int32_t code = TSDB_CODE_SUCCESS;

3,274,962✔

4422

  STlv*   pTlv = NULL;

3,274,962✔

4423

  tlvForEach(pDecoder, pTlv, code) {

9,850,065✔

4424

    switch (pTlv->type) {

6,575,103✔

4425

      case PHY_INDEF_ROWS_FUNC_CODE_BASE_NODE:

3,275,490✔

4426

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

3,275,490✔

4427

        break;

3,275,490✔

4428

      case PHY_INDEF_ROWS_FUNC_CODE_EXPRS:

24,123✔

4429

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pExprs);

24,123✔

4430

        break;

24,123✔

4431

      case PHY_INDEF_ROWS_FUNC_CODE_FUNCS:

3,275,490✔

4432

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pFuncs);

3,275,490✔

4433

        break;

3,275,490✔

4439

  return code;

3,275,490✔

4456

static int32_t physiInterpFuncNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

3,595,784✔

4457

  const SInterpFuncPhysiNode* pNode = (const SInterpFuncPhysiNode*)pObj;

3,595,784✔

4459

  int32_t code = tlvEncodeObj(pEncoder, PHY_INERP_FUNC_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

3,595,784✔

4460

  if (TSDB_CODE_SUCCESS == code) {

3,595,784✔

4461

    code = tlvEncodeObj(pEncoder, PHY_INERP_FUNC_CODE_EXPR, nodeListToMsg, pNode->pExprs);

3,595,784✔

4463

  if (TSDB_CODE_SUCCESS == code) {

3,595,784✔

4464

    code = tlvEncodeObj(pEncoder, PHY_INERP_FUNC_CODE_FUNCS, nodeListToMsg, pNode->pFuncs);

3,595,784✔

4466

  if (TSDB_CODE_SUCCESS == code) {

3,595,784✔

4467

    code = tlvEncodeObj(pEncoder, PHY_INERP_FUNC_CODE_TIME_RANGE, timeWindowToMsg, &pNode->timeRange);

3,595,784✔

4469

  if (TSDB_CODE_SUCCESS == code) {

3,595,784✔

4470

    code = tlvEncodeObj(pEncoder, PHY_INERP_FUNC_CODE_TIME_RANGE_EXPR, nodeToMsg, pNode->pTimeRange);

3,595,784✔

4472

  if (TSDB_CODE_SUCCESS == code) {

3,595,784✔

4473

    code = tlvEncodeI64(pEncoder, PHY_INERP_FUNC_CODE_INTERVAL, pNode->interval);

3,595,784✔

4475

  if (TSDB_CODE_SUCCESS == code) {

3,595,784✔

4476

    code = tlvEncodeI8(pEncoder, PHY_INERP_FUNC_CODE_INTERVAL_UNIT, pNode->intervalUnit);

3,595,784✔

4478

  if (TSDB_CODE_SUCCESS == code) {

3,595,784✔

4479

    code = tlvEncodeEnum(pEncoder, PHY_INERP_FUNC_CODE_FILL_MODE, pNode->fillMode);

3,595,784✔

4481

  if (TSDB_CODE_SUCCESS == code) {

3,595,784✔

4482

    code = tlvEncodeObj(pEncoder, PHY_INERP_FUNC_CODE_FILL_VALUES, nodeToMsg, pNode->pFillValues);

3,595,784✔

4484

  if (TSDB_CODE_SUCCESS == code) {

3,595,784✔

4485

    code = tlvEncodeObj(pEncoder, PHY_INERP_FUNC_CODE_TIME_SERIES, nodeToMsg, pNode->pTimeSeries);

3,595,784✔

4487

  if (TSDB_CODE_SUCCESS == code) {

3,595,784✔

4488

    code = tlvEncodeI64(pEncoder, PHY_INTERP_FUNC_CODE_SURROUNDING_TIME, pNode->surroundingTime);

3,595,784✔

4491

  return code;

3,595,784✔

4494

static int32_t msgToPhysiInterpFuncNode(STlvDecoder* pDecoder, void* pObj) {

3,586,340✔

4495

  SInterpFuncPhysiNode* pNode = (SInterpFuncPhysiNode*)pObj;

3,586,340✔

4497

  int32_t code = TSDB_CODE_SUCCESS;

3,586,340✔

4498

  STlv*   pTlv = NULL;

3,586,340✔

4499

  tlvForEach(pDecoder, pTlv, code) {

34,099,478✔

4500

    switch (pTlv->type) {

30,512,606✔

4501

      case PHY_INERP_FUNC_CODE_BASE_NODE:

3,586,340✔

4502

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

3,586,340✔

4503

        break;

3,586,872✔

4504

      case PHY_INERP_FUNC_CODE_EXPR:

92,111✔

4505

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pExprs);

92,111✔

4506

        break;

92,111✔

4507

      case PHY_INERP_FUNC_CODE_FUNCS:

3,586,340✔

4508

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pFuncs);

3,586,340✔

4509

        break;

3,586,872✔

4510

      case PHY_INERP_FUNC_CODE_TIME_RANGE:

3,586,872✔

4511

        code = tlvDecodeObjFromTlv(pTlv, msgToTimeWindow, &pNode->timeRange);

3,586,872✔

4512

        break;

3,586,872✔

4516

      case PHY_INERP_FUNC_CODE_INTERVAL:

3,586,872✔

4517

        code = tlvDecodeI64(pTlv, &pNode->interval);

3,586,872✔

4518

        break;

3,586,872✔

4519

      case PHY_INERP_FUNC_CODE_INTERVAL_UNIT:

3,586,872✔

4520

        code = tlvDecodeI8(pTlv, &pNode->intervalUnit);

3,586,872✔

4521

        break;

3,586,872✔

4522

      case PHY_INERP_FUNC_CODE_FILL_MODE:

3,586,872✔

4523

        code = tlvDecodeEnum(pTlv, &pNode->fillMode, sizeof(pNode->fillMode));

3,586,872✔

4524

        break;

3,586,872✔

4525

      case PHY_INERP_FUNC_CODE_FILL_VALUES:

1,725,519✔

4526

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pFillValues);

1,725,519✔

4527

        break;

1,725,519✔

4528

      case PHY_INERP_FUNC_CODE_TIME_SERIES:

3,586,872✔

4529

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pTimeSeries);

3,586,872✔

4530

        break;

3,586,872✔

4531

      case PHY_INTERP_FUNC_CODE_SURROUNDING_TIME:

3,587,936✔

4532

        code = tlvDecodeI64(pTlv, &pNode->surroundingTime);

3,587,936✔

4533

        break;

3,586,872✔

4539

  return code;

3,587,404✔

4588

static int32_t physicDataSinkNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

540,744,852✔

4589

  const SDataSinkNode* pNode = (const SDataSinkNode*)pObj;

540,744,852✔

4590

  return tlvEncodeObj(pEncoder, PHY_DATA_SINK_CODE_INPUT_DESC, nodeToMsg, pNode->pInputDataBlockDesc);

540,744,852✔

4593

static int32_t msgToPhysicDataSinkNode(STlvDecoder* pDecoder, void* pObj) {

381,806,580✔

4594

  SDataSinkNode* pNode = (SDataSinkNode*)pObj;

381,806,580✔

4596

  int32_t code = TSDB_CODE_SUCCESS;

381,806,580✔

4597

  STlv*   pTlv = NULL;

381,806,580✔

4598

  tlvForEach(pDecoder, pTlv, code) {

763,705,744✔

4599

    switch (pTlv->type) {

381,877,431✔

4600

      case PHY_DATA_SINK_CODE_INPUT_DESC:

381,874,529✔

4601

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pInputDataBlockDesc);

381,874,529✔

4602

        break;

381,874,901✔

4608

  return code;

381,902,062✔

4614

static int32_t physiDispatchNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

538,364,533✔

4615

  const SDataDispatcherNode* pNode = (const SDataDispatcherNode*)pObj;

538,364,533✔

4616

  int32_t                    code = tlvEncodeObj(pEncoder, PHY_DISPATCH_CODE_SINK, physicDataSinkNodeToMsg, &pNode->sink);

538,364,533✔

4617

  if (TSDB_CODE_SUCCESS == code) {

538,937,666✔

4618

    code = tlvEncodeBool(pEncoder, PHY_DISPATCH_DYNAMIC_SCHEMA, pNode->dynamicSchema);

538,942,150✔

4620

  return code;

539,019,106✔

4623

static int32_t msgToPhysiDispatchNode(STlvDecoder* pDecoder, void* pObj) {

379,423,117✔

4624

  SDataDispatcherNode* pNode = (SDataDispatcherNode*)pObj;

379,423,117✔

4626

  int32_t code = TSDB_CODE_SUCCESS;

379,423,117✔

4627

  STlv*   pTlv = NULL;

379,423,117✔

4628

  tlvForEach(pDecoder, pTlv, code) {

1,138,416,010✔

4629

    switch (pTlv->type) {

758,967,393✔

4630

      case PHY_DISPATCH_CODE_SINK:

379,475,953✔

4631

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysicDataSinkNode, &pNode->sink);

379,475,953✔

4632

        break;

379,479,922✔

4633

      case PHY_DISPATCH_DYNAMIC_SCHEMA:

379,492,105✔

4634

        code = tlvDecodeBool(pTlv, &pNode->dynamicSchema);

379,492,105✔

4635

        break;

379,488,005✔

4641

  return code;

379,525,031✔

4656

static int32_t physiQueryInsertNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

499,646✔

4657

  const SQueryInserterNode* pNode = (const SQueryInserterNode*)pObj;

499,646✔

4659

  int32_t code = tlvEncodeObj(pEncoder, PHY_QUERY_INSERT_CODE_SINK, physicDataSinkNodeToMsg, &pNode->sink);

499,646✔

4660

  if (TSDB_CODE_SUCCESS == code) {

499,646✔

4661

    code = tlvEncodeObj(pEncoder, PHY_QUERY_INSERT_CODE_COLS, nodeListToMsg, pNode->pCols);

499,646✔

4663

  if (TSDB_CODE_SUCCESS == code) {

499,646✔

4664

    code = tlvEncodeU64(pEncoder, PHY_QUERY_INSERT_CODE_TABLE_ID, pNode->tableId);

499,646✔

4666

  if (TSDB_CODE_SUCCESS == code) {

499,646✔

4667

    code = tlvEncodeU64(pEncoder, PHY_QUERY_INSERT_CODE_STABLE_ID, pNode->stableId);

499,646✔

4669

  if (TSDB_CODE_SUCCESS == code) {

499,646✔

4670

    code = tlvEncodeI8(pEncoder, PHY_QUERY_INSERT_CODE_TABLE_TYPE, pNode->tableType);

499,646✔

4672

  if (TSDB_CODE_SUCCESS == code) {

499,646✔

4673

    code = tlvEncodeCStr(pEncoder, PHY_QUERY_INSERT_CODE_TABLE_NAME, pNode->tableName);

499,646✔

4675

  if (TSDB_CODE_SUCCESS == code) {

499,646✔

4676

    code = tlvEncodeI32(pEncoder, PHY_QUERY_INSERT_CODE_VG_ID, pNode->vgId);

499,646✔

4678

  if (TSDB_CODE_SUCCESS == code) {

499,646✔

4679

    code = tlvEncodeObj(pEncoder, PHY_QUERY_INSERT_CODE_EP_SET, epSetToMsg, &pNode->epSet);

499,646✔

4681

  if (TSDB_CODE_SUCCESS == code) {

499,646✔

4682

    code = tlvEncodeBool(pEncoder, PHY_QUERY_INSERT_CODE_EXPLAIN, pNode->explain);

499,646✔

4685

  return code;

499,646✔

4688

static int32_t msgToPhysiQueryInsertNode(STlvDecoder* pDecoder, void* pObj) {

499,196✔

4689

  SQueryInserterNode* pNode = (SQueryInserterNode*)pObj;

499,196✔

4691

  int32_t code = TSDB_CODE_SUCCESS;

499,196✔

4692

  STlv*   pTlv = NULL;

499,196✔

4693

  tlvForEach(pDecoder, pTlv, code) {

4,991,960✔

4694

    switch (pTlv->type) {

4,492,764✔

4695

      case PHY_QUERY_INSERT_CODE_SINK:

499,196✔

4696

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysicDataSinkNode, &pNode->sink);

499,196✔

4697

        break;

499,196✔

4698

      case PHY_QUERY_INSERT_CODE_COLS:

499,196✔

4699

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pCols);

499,196✔

4700

        break;

499,196✔

4701

      case PHY_QUERY_INSERT_CODE_TABLE_ID:

499,196✔

4702

        code = tlvDecodeU64(pTlv, &pNode->tableId);

499,196✔

4703

        break;

499,196✔

4704

      case PHY_QUERY_INSERT_CODE_STABLE_ID:

499,196✔

4705

        code = tlvDecodeU64(pTlv, &pNode->stableId);

499,196✔

4706

        break;

499,196✔

4707

      case PHY_QUERY_INSERT_CODE_TABLE_TYPE:

499,196✔

4708

        code = tlvDecodeI8(pTlv, &pNode->tableType);

499,196✔

4709

        break;

499,196✔

4710

      case PHY_QUERY_INSERT_CODE_TABLE_NAME:

499,196✔

4711

        code = tlvDecodeCStr(pTlv, pNode->tableName, sizeof(pNode->tableName));

499,196✔

4712

        break;

499,196✔

4713

      case PHY_QUERY_INSERT_CODE_VG_ID:

499,196✔

4714

        code = tlvDecodeI32(pTlv, &pNode->vgId);

499,196✔

4715

        break;

499,196✔

4716

      case PHY_QUERY_INSERT_CODE_EP_SET:

499,196✔

4717

        code = tlvDecodeObjFromTlv(pTlv, msgToEpSet, &pNode->epSet);

499,196✔

4718

        break;

499,196✔

4719

      case PHY_QUERY_INSERT_CODE_EXPLAIN:

499,196✔

4720

        code = tlvDecodeBool(pTlv, &pNode->explain);

499,196✔

4721

        break;

499,196✔

4727

  return code;

499,196✔

4742

static int32_t physiDeleteNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

1,887,752✔

4743

  const SDataDeleterNode* pNode = (const SDataDeleterNode*)pObj;

1,887,752✔

4745

  int32_t code = tlvEncodeObj(pEncoder, PHY_DELETER_CODE_SINK, physicDataSinkNodeToMsg, &pNode->sink);

1,887,752✔

4746

  if (TSDB_CODE_SUCCESS == code) {

1,887,752✔

4747

    code = tlvEncodeU64(pEncoder, PHY_DELETER_CODE_TABLE_ID, pNode->tableId);

1,887,752✔

4749

  if (TSDB_CODE_SUCCESS == code) {

1,887,752✔

4750

    code = tlvEncodeI8(pEncoder, PHY_DELETER_CODE_TABLE_TYPE, pNode->tableType);

1,887,752✔

4752

  if (TSDB_CODE_SUCCESS == code) {

1,887,752✔

4753

    code = tlvEncodeCStr(pEncoder, PHY_DELETER_CODE_TABLE_FNAME, pNode->tableFName);

1,887,752✔

4755

  if (TSDB_CODE_SUCCESS == code) {

1,887,752✔

4756

    code = tlvEncodeCStr(pEncoder, PHY_DELETER_CODE_TS_COL_NAME, pNode->tsColName);

1,887,752✔

4758

  if (TSDB_CODE_SUCCESS == code) {

1,887,752✔

4759

    code = tlvEncodeObj(pEncoder, PHY_DELETER_CODE_DELETE_TIME_RANGE, timeWindowToMsg, &pNode->deleteTimeRange);

1,887,752✔

4761

  if (TSDB_CODE_SUCCESS == code) {

1,887,752✔

4762

    code = tlvEncodeObj(pEncoder, PHY_DELETER_CODE_AFFECTED_ROWS, nodeToMsg, pNode->pAffectedRows);

1,887,752✔

4764

  if (TSDB_CODE_SUCCESS == code) {

1,887,752✔

4765

    code = tlvEncodeObj(pEncoder, PHY_DELETER_CODE_START_TS, nodeToMsg, pNode->pStartTs);

1,887,752✔

4767

  if (TSDB_CODE_SUCCESS == code) {

1,887,752✔

4768

    code = tlvEncodeObj(pEncoder, PHY_DELETER_CODE_END_TS, nodeToMsg, pNode->pEndTs);

1,887,752✔

4771

  return code;

1,887,752✔

4774

static int32_t msgToPhysiDeleteNode(STlvDecoder* pDecoder, void* pObj) {

1,885,698✔

4775

  SDataDeleterNode* pNode = (SDataDeleterNode*)pObj;

1,885,698✔

4777

  int32_t code = TSDB_CODE_SUCCESS;

1,885,698✔

4778

  STlv*   pTlv = NULL;

1,885,698✔

4779

  tlvForEach(pDecoder, pTlv, code) {

18,862,371✔

4780

    switch (pTlv->type) {

16,976,673✔

4781

      case PHY_DELETER_CODE_SINK:

1,884,490✔

4782

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysicDataSinkNode, &pNode->sink);

1,884,490✔

4783

        break;

1,886,297✔

4784

      case PHY_DELETER_CODE_TABLE_ID:

1,886,297✔

4785

        code = tlvDecodeU64(pTlv, &pNode->tableId);

1,886,297✔

4786

        break;

1,886,297✔

4787

      case PHY_DELETER_CODE_TABLE_TYPE:

1,886,297✔

4788

        code = tlvDecodeI8(pTlv, &pNode->tableType);

1,886,297✔

4789

        break;

1,886,297✔

4790

      case PHY_DELETER_CODE_TABLE_FNAME:

1,886,297✔

4791

        code = tlvDecodeCStr(pTlv, pNode->tableFName, sizeof(pNode->tableFName));

1,886,297✔

4792

        break;

1,886,297✔

4793

      case PHY_DELETER_CODE_TS_COL_NAME:

1,886,297✔

4794

        code = tlvDecodeCStr(pTlv, pNode->tsColName, sizeof(pNode->tsColName));

1,886,297✔

4795

        break;

1,886,297✔

4796

      case PHY_DELETER_CODE_DELETE_TIME_RANGE:

1,886,297✔

4797

        code = tlvDecodeObjFromTlv(pTlv, msgToTimeWindow, &pNode->deleteTimeRange);

1,886,297✔

4798

        break;

1,886,297✔

4799

      case PHY_DELETER_CODE_AFFECTED_ROWS:

1,886,297✔

4800

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pAffectedRows);

1,886,297✔

4801

        break;

1,886,297✔

4802

      case PHY_DELETER_CODE_START_TS:

1,886,297✔

4803

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pStartTs);

1,886,297✔

4804

        break;

1,886,297✔

4805

      case PHY_DELETER_CODE_END_TS:

1,887,505✔

4806

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pEndTs);

1,887,505✔

4807

        break;

1,886,297✔

4813

  return code;

1,886,297✔

4825

static int32_t physiGroupCacheNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

1,273,717✔

4826

  const SGroupCachePhysiNode* pNode = (const SGroupCachePhysiNode*)pObj;

1,273,717✔

4828

  int32_t code = tlvEncodeObj(pEncoder, PHY_GROUP_CACHE_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

1,273,717✔

4829

  if (TSDB_CODE_SUCCESS == code) {

1,273,717✔

4830

    code = tlvEncodeObj(pEncoder, PHY_GROUP_CACHE_CODE_GROUP_COLUMNS, nodeListToMsg, pNode->pGroupCols);

1,273,717✔

4832

  if (TSDB_CODE_SUCCESS == code) {

1,273,717✔

4833

    code = tlvEncodeBool(pEncoder, PHY_GROUP_CACHE_CODE_GROUP_COLS_MAY_BE_NULL, pNode->grpColsMayBeNull);

1,273,717✔

4835

  if (TSDB_CODE_SUCCESS == code) {

1,273,717✔

4836

    code = tlvEncodeBool(pEncoder, PHY_GROUP_CACHE_CODE_GROUP_BY_UID, pNode->grpByUid);

1,273,717✔

4838

  if (TSDB_CODE_SUCCESS == code) {

1,273,717✔

4839

    code = tlvEncodeBool(pEncoder, PHY_GROUP_CACHE_CODE_GLOBAL_GROUP, pNode->globalGrp);

1,273,717✔

4841

  if (TSDB_CODE_SUCCESS == code) {

1,273,717✔

4842

    code = tlvEncodeBool(pEncoder, PHY_GROUP_CACHE_CODE_BATCH_FETCH, pNode->batchFetch);

1,273,717✔

4845

  return code;

1,273,717✔

4848

static int32_t msgToPhysiGroupCacheNode(STlvDecoder* pDecoder, void* pObj) {

1,273,677✔

4849

  SGroupCachePhysiNode* pNode = (SGroupCachePhysiNode*)pObj;

1,273,677✔

4851

  int32_t code = TSDB_CODE_SUCCESS;

1,273,677✔

4852

  STlv*   pTlv = NULL;

1,273,677✔

4853

  tlvForEach(pDecoder, pTlv, code) {

7,642,062✔

4854

    switch (pTlv->type) {

6,368,385✔

4855

      case PHY_GROUP_CACHE_CODE_BASE_NODE:

1,273,677✔

4856

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

1,273,677✔

4857

        break;

1,273,677✔

4861

      case PHY_GROUP_CACHE_CODE_GROUP_COLS_MAY_BE_NULL:

1,273,677✔

4862

        code = tlvDecodeBool(pTlv, &pNode->grpColsMayBeNull);

1,273,677✔

4863

        break;

1,273,677✔

4864

      case PHY_GROUP_CACHE_CODE_GROUP_BY_UID:

1,273,677✔

4865

        code = tlvDecodeBool(pTlv, &pNode->grpByUid);

1,273,677✔

4866

        break;

1,273,677✔

4867

      case PHY_GROUP_CACHE_CODE_GLOBAL_GROUP:

1,273,677✔

4868

        code = tlvDecodeBool(pTlv, &pNode->globalGrp);

1,273,677✔

4869

        break;

1,273,677✔

4870

      case PHY_GROUP_CACHE_CODE_BATCH_FETCH:

1,273,677✔

4871

        code = tlvDecodeBool(pTlv, &pNode->batchFetch);

1,273,677✔

4872

        break;

1,273,677✔

4878

  return code;

1,273,677✔

4915

static int32_t physiDynQueryCtrlNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

5,568,760✔

4916

  const SDynQueryCtrlPhysiNode* pNode = (const SDynQueryCtrlPhysiNode*)pObj;

5,568,760✔

4918

  int32_t code = tlvEncodeObj(pEncoder, PHY_DYN_QUERY_CTRL_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

5,568,760✔

4919

  if (TSDB_CODE_SUCCESS == code) {

5,568,760✔

4920

    code = tlvEncodeEnum(pEncoder, PHY_DYN_QUERY_CTRL_CODE_QUERY_TYPE, pNode->qType);

5,568,760✔

4922

  if (TSDB_CODE_SUCCESS == code) {

5,568,760✔

4923

    switch (pNode->qType) {

5,568,760✔

4924

      case DYN_QTYPE_STB_HASH: {

1,273,717✔

4925

        code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_BATCH_FETCH, pNode->stbJoin.batchFetch);

1,273,717✔

4926

        if (TSDB_CODE_SUCCESS == code) {

1,273,717✔

4927

          code = tlvEncodeEnum(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT0, pNode->stbJoin.vgSlot[0]);

1,273,717✔

4929

        if (TSDB_CODE_SUCCESS == code) {

1,273,717✔

4930

          code = tlvEncodeEnum(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT1, pNode->stbJoin.vgSlot[1]);

1,273,717✔

4932

        if (TSDB_CODE_SUCCESS == code) {

1,273,717✔

4933

          code = tlvEncodeEnum(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_UID_SLOT0, pNode->stbJoin.uidSlot[0]);

1,273,717✔

4935

        if (TSDB_CODE_SUCCESS == code) {

1,273,717✔

4936

          code = tlvEncodeEnum(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_UID_SLOT1, pNode->stbJoin.uidSlot[1]);

1,273,717✔

4938

        if (TSDB_CODE_SUCCESS == code) {

1,273,717✔

4939

          code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_SRC_SCAN0, pNode->stbJoin.srcScan[0]);

1,273,717✔

4941

        if (TSDB_CODE_SUCCESS == code) {

1,273,717✔

4942

          code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_SRC_SCAN1, pNode->stbJoin.srcScan[1]);

1,273,717✔

4944

        break;

1,273,717✔

4946

      case DYN_QTYPE_VTB_WINDOW: {

547,471✔

4947

        code = tlvEncodeI32(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_WSTART_SLOTID, pNode->vtbWindow.wstartSlotId);

547,471✔

4948

        if (TSDB_CODE_SUCCESS == code) {

547,471✔

4949

          code = tlvEncodeI32(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_WEND_SLOTID, pNode->vtbWindow.wendSlotId);

547,471✔

4951

        if (TSDB_CODE_SUCCESS == code) {

547,471✔

4952

          code = tlvEncodeI32(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_WDURATION_SLOTID, pNode->vtbWindow.wdurationSlotId);

547,471✔

4954

        if (TSDB_CODE_SUCCESS == code) {

547,471✔

4955

          code = tlvEncodeObj(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_TARGETS, nodeListToMsg, pNode->vtbWindow.pTargets);

547,471✔

4957

        if (TSDB_CODE_SUCCESS == code) {

547,471✔

4958

          code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_IS_VSTB, pNode->vtbWindow.isVstb);

547,471✔

4960

        if (TSDB_CODE_SUCCESS == code) {

547,471✔

4961

          code = tlvEncodeI32(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_STATE_EXTEND_OPTION, pNode->vtbWindow.extendOption);

547,471✔

4969

        code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_SCAN_ALL_COLS, pNode->vtbScan.scanAllCols);

4,295,043✔

4970

        if (TSDB_CODE_SUCCESS == code) {

4,295,043✔

4971

          code = tlvEncodeU64(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_SUID, pNode->vtbScan.suid);

4,295,043✔

4973

        if (TSDB_CODE_SUCCESS == code) {

4,295,043✔

4974

          code = tlvEncodeCStr(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_DBNAME, pNode->vtbScan.dbName);

4,295,043✔

4976

        if (TSDB_CODE_SUCCESS == code) {

4,295,043✔

4977

          code = tlvEncodeCStr(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_STBNAME, pNode->vtbScan.tbName);

4,295,043✔

4979

        if (TSDB_CODE_SUCCESS == code) {

4,295,043✔

4980

          code = tlvEncodeI32(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_ACCOUNT_ID, pNode->vtbScan.accountId);

4,295,043✔

4982

        if (TSDB_CODE_SUCCESS == code) {

4,295,043✔

4983

          code = tlvEncodeObj(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_EP_SET, epSetToMsg, &pNode->vtbScan.mgmtEpSet);

4,295,043✔

4985

        if (TSDB_CODE_SUCCESS == code) {

4,295,043✔

4986

          code = tlvEncodeObj(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_SCAN_COLS, nodeListToMsg, pNode->vtbScan.pScanCols);

4,295,043✔

4988

        if (TSDB_CODE_SUCCESS == code) {

4,295,043✔

4989

          code = tlvEncodeU64(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_UID, pNode->vtbScan.uid);

4,295,043✔

4991

        if (TSDB_CODE_SUCCESS == code) {

4,295,043✔

4992

          code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_IS_SUPER_TABLE, pNode->vtbScan.isSuperTable);

4,295,043✔

4994

        if (TSDB_CODE_SUCCESS == code) {

4,295,043✔

4995

          code = tlvEncodeI32(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_RVERSION, pNode->vtbScan.rversion);

4,295,043✔

4997

        if (TSDB_CODE_SUCCESS == code) {

4,295,043✔

4998

          code = tlvEncodeObj(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_ORG_VG_IDS, nodeListToMsg, pNode->vtbScan.pOrgVgIds);

4,295,043✔

5000

        if (TSDB_CODE_SUCCESS == code) {

4,295,043✔

5001

          code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_BATCH_PROCESS_CHILD, pNode->vtbScan.batchProcessChild);

4,295,043✔

5003

        if (TSDB_CODE_SUCCESS == code) {

4,295,043✔

5004

          code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_HAS_PARTITION, pNode->vtbScan.hasPartition);

4,295,043✔

5006

        break;

4,295,043✔

5012

  if (TSDB_CODE_SUCCESS == code) {

5,568,760✔

5013

    code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_DYN_TBNAME, pNode->dynTbname);

5,568,760✔

5015

  return code;

5,568,760✔

5018

static int32_t msgToPhysiDynQueryCtrlNode(STlvDecoder* pDecoder, void* pObj) {

3,515,261✔

5019

  SDynQueryCtrlPhysiNode* pNode = (SDynQueryCtrlPhysiNode*)pObj;

3,515,261✔

5021

  int32_t code = TSDB_CODE_SUCCESS;

3,515,261✔

5022

  STlv*   pTlv = NULL;

3,515,261✔

5023

  tlvForEach(pDecoder, pTlv, code) {

55,047,427✔

5024

    switch (pTlv->type) {

51,532,166✔

5025

      case PHY_DYN_QUERY_CTRL_CODE_BASE_NODE:

3,515,261✔

5026

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

3,515,261✔

5027

        break;

3,515,261✔

5028

      case PHY_DYN_QUERY_CTRL_CODE_QUERY_TYPE:

3,515,261✔

5029

        code = tlvDecodeEnum(pTlv, &pNode->qType, sizeof(pNode->qType));

3,515,261✔

5030

        break;

3,515,261✔

5031

      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_BATCH_FETCH:

1,273,677✔

5032

        code = tlvDecodeBool(pTlv, &pNode->stbJoin.batchFetch);

1,273,677✔

5033

        break;

1,273,677✔

5034

      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT0:

1,273,677✔

5035

        code = tlvDecodeEnum(pTlv, &pNode->stbJoin.vgSlot[0], sizeof(pNode->stbJoin.vgSlot[0]));

1,273,677✔

5036

        break;

1,273,677✔

5037

      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT1:

1,273,677✔

5038

        code = tlvDecodeEnum(pTlv, &pNode->stbJoin.vgSlot[1], sizeof(pNode->stbJoin.vgSlot[1]));

1,273,677✔

5039

        break;

1,273,677✔

5040

      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_UID_SLOT0:

1,273,677✔

5041

        code = tlvDecodeEnum(pTlv, &pNode->stbJoin.uidSlot[0], sizeof(pNode->stbJoin.uidSlot[0]));

1,273,677✔

5042

        break;

1,273,677✔

5043

      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_UID_SLOT1:

1,273,677✔

5044

        code = tlvDecodeEnum(pTlv, &pNode->stbJoin.uidSlot[1], sizeof(pNode->stbJoin.uidSlot[1]));

1,273,677✔

5045

        break;

1,273,677✔

5046

      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_SRC_SCAN0:

1,273,677✔

5047

        code = tlvDecodeBool(pTlv, &pNode->stbJoin.srcScan[0]);

1,273,677✔

5048

        break;

1,273,677✔

5049

      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_SRC_SCAN1:

1,273,677✔

5050

        code = tlvDecodeBool(pTlv, &pNode->stbJoin.srcScan[1]);

1,273,677✔

5051

        break;

1,273,677✔

5052

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_SCAN_ALL_COLS:

2,241,584✔

5053

        code = tlvDecodeBool(pTlv, &pNode->vtbScan.scanAllCols);

2,241,584✔

5054

        break;

2,241,584✔

5055

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_SUID:

2,241,584✔

5056

        code = tlvDecodeU64(pTlv, &pNode->vtbScan.suid);

2,241,584✔

5057

        break;

2,241,584✔

5058

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_DBNAME:

2,241,584✔

5059

        code = tlvDecodeCStr(pTlv, pNode->vtbScan.dbName, sizeof(pNode->vtbScan.dbName));

2,241,584✔

5060

        break;

2,241,584✔

5061

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_STBNAME:

2,241,584✔

5062

        code = tlvDecodeCStr(pTlv, pNode->vtbScan.tbName, sizeof(pNode->vtbScan.tbName));

2,241,584✔

5063

        break;

2,241,584✔

5064

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_ACCOUNT_ID:

2,241,584✔

5065

        code = tlvDecodeI32(pTlv, &pNode->vtbScan.accountId);

2,241,584✔

5066

        break;

2,241,584✔

5067

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_EP_SET:

2,241,584✔

5068

        code = tlvDecodeObjFromTlv(pTlv, msgToEpSet, &pNode->vtbScan.mgmtEpSet);

2,241,584✔

5069

        break;

2,241,584✔

5070

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_SCAN_COLS:

2,241,584✔

5071

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->vtbScan.pScanCols);

2,241,584✔

5072

        break;

2,241,584✔

5073

      case PHY_DYN_QUERY_CTRL_CODE_DYN_TBNAME:

3,515,261✔

5074

        code = tlvDecodeBool(pTlv, &pNode->dynTbname);

3,515,261✔

5075

        break;

3,515,261✔

5076

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_UID:

2,241,584✔

5077

        code = tlvDecodeU64(pTlv, &pNode->vtbScan.uid);

2,241,584✔

5078

        break;

2,241,584✔

5079

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_IS_SUPER_TABLE:

2,241,584✔

5080

        code = tlvDecodeBool(pTlv, &pNode->vtbScan.isSuperTable);

2,241,584✔

5081

        break;

2,241,584✔

5082

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_RVERSION:

2,241,584✔

5083

        code = tlvDecodeI32(pTlv, &pNode->vtbScan.rversion);

2,241,584✔

5084

        break;

2,241,584✔

5085

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_ORG_VG_IDS:

1,926,212✔

5086

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->vtbScan.pOrgVgIds);

1,926,212✔

5087

        break;

1,926,212✔

5088

      case PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_WSTART_SLOTID:

540,904✔

5089

        code = tlvDecodeI32(pTlv, &pNode->vtbWindow.wstartSlotId);

540,904✔

5090

        break;

540,904✔

5091

      case PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_WEND_SLOTID:

540,904✔

5092

        code = tlvDecodeI32(pTlv, &pNode->vtbWindow.wendSlotId);

540,904✔

5093

        break;

540,904✔

5094

      case PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_WDURATION_SLOTID:

540,904✔

5095

        code = tlvDecodeI32(pTlv, &pNode->vtbWindow.wdurationSlotId);

540,904✔

5096

        break;

540,904✔

5097

      case PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_TARGETS:

540,904✔

5098

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->vtbWindow.pTargets);

540,904✔

5099

        break;

540,904✔

5100

      case PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_IS_VSTB:

540,904✔

5101

        code = tlvDecodeBool(pTlv, &pNode->vtbWindow.isVstb);

540,904✔

5102

        break;

540,904✔

5103

      case PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_STATE_EXTEND_OPTION:

540,904✔

5104

        code = tlvDecodeI32(pTlv, (int32_t*)&pNode->vtbWindow.extendOption);

540,904✔

5105

        break;

540,904✔

5106

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_BATCH_PROCESS_CHILD:

2,241,584✔

5107

        code = tlvDecodeBool(pTlv, &pNode->vtbScan.batchProcessChild);

2,241,584✔

5108

        break;

2,241,584✔

5109

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_HAS_PARTITION:

2,241,584✔

5110

        code = tlvDecodeBool(pTlv, &pNode->vtbScan.hasPartition);

2,241,584✔

5111

        break;

2,241,584✔

5117

  return code;

3,515,261✔

5124

static int32_t subplanIdInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {

541,107,791✔

5125

  const SSubplanId* pNode = (const SSubplanId*)pObj;

541,107,791✔

5127

  int32_t code = tlvEncodeValueU64(pEncoder, pNode->queryId);

541,107,791✔

5128

  if (TSDB_CODE_SUCCESS == code) {

540,294,284✔

5129

    code = tlvEncodeValueI32(pEncoder, pNode->groupId);

540,334,798✔

5131

  if (TSDB_CODE_SUCCESS == code) {

540,848,390✔

5132

    code = tlvEncodeValueI32(pEncoder, pNode->subplanId);

540,866,058✔

5135

  return code;

540,974,631✔

5152

static int32_t msgToSubplanIdInline(STlvDecoder* pDecoder, void* pObj) {

381,822,491✔

5153

  SSubplanId* pNode = (SSubplanId*)pObj;

381,822,491✔

5155

  int32_t code = tlvDecodeValueU64(pDecoder, &pNode->queryId);

381,822,491✔

5156

  if (TSDB_CODE_SUCCESS == code) {

381,771,173✔

5157

    code = tlvDecodeValueI32(pDecoder, &pNode->groupId);

381,778,480✔

5159

  if (TSDB_CODE_SUCCESS == code) {

381,816,607✔

5160

    code = tlvDecodeValueI32(pDecoder, &pNode->subplanId);

381,816,607✔

5163

  return code;

381,791,835✔

5198

static int32_t subplanInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {

541,094,514✔

5199

  const SSubplan* pNode = (const SSubplan*)pObj;

541,094,514✔

5201

  int32_t code = subplanIdInlineToMsg(&pNode->id, pEncoder);

541,094,514✔

5202

  if (TSDB_CODE_SUCCESS == code) {

540,966,855✔

5203

    code = tlvEncodeValueEnum(pEncoder, pNode->subplanType);

540,967,492✔

5205

  if (TSDB_CODE_SUCCESS == code) {

541,113,810✔

5206

    code = tlvEncodeValueI32(pEncoder, pNode->msgType);

541,131,615✔

5208

  if (TSDB_CODE_SUCCESS == code) {

541,030,046✔

5209

    code = tlvEncodeValueI32(pEncoder, pNode->level);

541,051,879✔

5211

  if (TSDB_CODE_SUCCESS == code) {

541,181,879✔

5212

    code = tlvEncodeValueCStr(pEncoder, pNode->dbFName);

541,170,272✔

5214

  if (TSDB_CODE_SUCCESS == code) {

541,165,070✔

5215

    code = tlvEncodeValueCStr(pEncoder, pNode->user);

541,156,316✔

5217

  if (TSDB_CODE_SUCCESS == code) {

541,256,010✔

5218

    code = queryNodeAddrInlineToMsg(&pNode->execNode, pEncoder);

541,251,573✔

5220

  if (TSDB_CODE_SUCCESS == code) {

541,173,235✔

5221

    code = tlvEncodeValueBool(pEncoder, pNode->showRewrite);

541,169,930✔

5223

  if (TSDB_CODE_SUCCESS == code) {

541,219,401✔

5224

    code = tlvEncodeValueI32(pEncoder, pNode->rowsThreshold);

541,182,786✔

5226

  if (TSDB_CODE_SUCCESS == code) {

541,138,097✔

5227

    code = tlvEncodeValueBool(pEncoder, pNode->dynamicRowThreshold);

541,106,138✔

5229

  if (TSDB_CODE_SUCCESS == code) {

541,182,146✔

5230

    code = tlvEncodeValueBool(pEncoder, pNode->isView);

541,151,078✔

5232

  if (TSDB_CODE_SUCCESS == code) {

541,183,632✔

5233

    code = tlvEncodeValueBool(pEncoder, pNode->isAudit);

541,161,518✔

5235

  if (TSDB_CODE_SUCCESS == code) {

541,265,717✔

5236

    code = tlvEncodeValueBool(pEncoder, pNode->processOneBlock);

541,209,765✔

5238

  if (TSDB_CODE_SUCCESS == code) {

541,245,934✔

5239

    code = tlvEncodeValueBool(pEncoder, pNode->dynTbname);

541,204,072✔

5241

  return code;

541,292,896✔

5244

static int32_t subplanToMsg(const void* pObj, STlvEncoder* pEncoder) {

541,142,258✔

5245

  const SSubplan* pNode = (const SSubplan*)pObj;

541,142,258✔

5247

  int32_t code = tlvEncodeObj(pEncoder, SUBPLAN_CODE_INLINE_ATTRS, subplanInlineToMsg, pNode);

541,142,258✔

5248

  if (TSDB_CODE_SUCCESS == code) {

540,899,699✔

5249

    code = tlvEncodeObj(pEncoder, SUBPLAN_CODE_ROOT_NODE, nodeToMsg, pNode->pNode);

540,913,974✔

5251

  if (TSDB_CODE_SUCCESS == code) {

541,122,062✔

5252

    code = tlvEncodeObj(pEncoder, SUBPLAN_CODE_DATA_SINK, nodeToMsg, pNode->pDataSink);

541,084,199✔

5254

  if (TSDB_CODE_SUCCESS == code) {

541,403,523✔

5255

    code = tlvEncodeObj(pEncoder, SUBPLAN_CODE_TAG_COND, nodeToMsg, pNode->pTagCond);

541,369,978✔

5257

  if (TSDB_CODE_SUCCESS == code) {

541,134,028✔

5258

    code = tlvEncodeObj(pEncoder, SUBPLAN_CODE_TAG_INDEX_COND, nodeToMsg, pNode->pTagIndexCond);

541,101,751✔

5261

  return code;

540,674,966✔

5264

static int32_t msgToSubplanInline(STlvDecoder* pDecoder, void* pObj) {

381,827,635✔

5265

  SSubplan* pNode = (SSubplan*)pObj;

381,827,635✔

5267

  int32_t code = msgToSubplanIdInline(pDecoder, &pNode->id);

381,827,635✔

5268

  if (TSDB_CODE_SUCCESS == code) {

381,793,051✔

5269

    code = tlvDecodeValueEnum(pDecoder, &pNode->subplanType, sizeof(pNode->subplanType));

381,791,445✔

5271

  if (TSDB_CODE_SUCCESS == code) {

381,782,036✔

5272

    code = tlvDecodeValueI32(pDecoder, &pNode->msgType);

381,782,036✔

5274

  if (TSDB_CODE_SUCCESS == code) {

381,862,089✔

5275

    code = tlvDecodeValueI32(pDecoder, &pNode->level);

381,862,089✔

5277

  if (TSDB_CODE_SUCCESS == code) {

381,860,335✔

5278

    code = tlvDecodeValueCStr(pDecoder, pNode->dbFName);

381,860,335✔

5280

  if (TSDB_CODE_SUCCESS == code) {

381,839,102✔

5281

    code = tlvDecodeValueCStr(pDecoder, pNode->user);

381,839,102✔

5283

  if (TSDB_CODE_SUCCESS == code) {

381,867,218✔

5284

    code = msgToQueryNodeAddrInline(pDecoder, &pNode->execNode);

381,867,218✔

5286

  if (TSDB_CODE_SUCCESS == code) {

381,766,320✔

5287

    code = tlvDecodeValueBool(pDecoder, &pNode->showRewrite);

381,766,320✔

5289

  if (TSDB_CODE_SUCCESS == code) {

381,776,343✔

5290

    code = tlvDecodeValueI32(pDecoder, &pNode->rowsThreshold);

381,776,343✔

5292

  if (TSDB_CODE_SUCCESS == code) {

381,858,268✔

5293

    code = tlvDecodeValueBool(pDecoder, &pNode->dynamicRowThreshold);

381,858,268✔

5295

  if (TSDB_CODE_SUCCESS == code) {

381,860,573✔

5296

    code = tlvDecodeValueBool(pDecoder, &pNode->isView);

381,860,573✔

5298

  if (TSDB_CODE_SUCCESS == code) {

381,865,576✔

5299

    code = tlvDecodeValueBool(pDecoder, &pNode->isAudit);

381,865,576✔

5301

  if (TSDB_CODE_SUCCESS == code) {

381,867,157✔

5302

    code = tlvDecodeValueBool(pDecoder, &pNode->processOneBlock);

381,867,157✔

5304

  if (TSDB_CODE_SUCCESS == code) {

381,868,431✔

5305

    code = tlvDecodeValueBool(pDecoder, &pNode->dynTbname);

381,868,431✔

5307

  return code;

381,870,503✔

5310

static int32_t msgToSubplan(STlvDecoder* pDecoder, void* pObj) {

381,821,994✔

5311

  SSubplan* pNode = (SSubplan*)pObj;

381,821,994✔

5313

  int32_t code = TSDB_CODE_SUCCESS;

381,821,994✔

5314

  STlv*   pTlv = NULL;

381,821,994✔

5315

  tlvForEach(pDecoder, pTlv, code) {

1,547,992,701✔

5316

    switch (pTlv->type) {

1,166,153,036✔

5317

      case SUBPLAN_CODE_INLINE_ATTRS:

381,812,488✔

5318

        code = tlvDecodeObjFromTlv(pTlv, msgToSubplanInline, pNode);

381,812,488✔

5319

        break;

381,867,802✔

5320

      case SUBPLAN_CODE_ROOT_NODE:

381,874,166✔

5321

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pNode);

381,874,166✔

5322

        break;

381,838,709✔

5323

      case SUBPLAN_CODE_DATA_SINK:

381,858,625✔

5324

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pDataSink);

381,858,625✔

5325

        break;

381,855,641✔

5326

      case SUBPLAN_CODE_TAG_COND:

15,960,156✔

5327

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pTagCond);

15,960,156✔

5328

        break;

15,958,667✔

5329

      case SUBPLAN_CODE_TAG_INDEX_COND:

4,664,979✔

5330

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pTagIndexCond);

4,664,979✔

5331

        break;

4,631,848✔

5337

  return code;

381,974,722✔

5342

static int32_t queryPlanInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,352✔

5343

  const SQueryPlan* pNode = (const SQueryPlan*)pObj;

2,352✔

5345

  int32_t code = tlvEncodeValueU64(pEncoder, pNode->queryId);

2,352✔

5346

  if (TSDB_CODE_SUCCESS == code) {

2,352✔

5347

    code = tlvEncodeValueI32(pEncoder, pNode->numOfSubplans);

2,352✔

5350

  return code;

2,352✔

5353

static int32_t queryPlanToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,352✔

5354

  const SQueryPlan* pNode = (const SQueryPlan*)pObj;

2,352✔

5356

  int32_t code = tlvEncodeObj(pEncoder, QUERY_PLAN_CODE_INLINE_ATTRS, queryPlanInlineToMsg, pNode);

2,352✔

5357

  if (TSDB_CODE_SUCCESS == code) {

2,352✔

5358

    code = tlvEncodeObj(pEncoder, QUERY_PLAN_CODE_SUBPLANS, nodeListToMsg, pNode->pSubplans);

2,352✔

5361

  return code;

2,352✔

5364

static int32_t msgToQueryPlanInline(STlvDecoder* pDecoder, void* pObj) {

1,176✔

5365

  SQueryPlan* pNode = (SQueryPlan*)pObj;

1,176✔

5367

  int32_t code = tlvDecodeValueU64(pDecoder, &pNode->queryId);

1,176✔

5368

  if (TSDB_CODE_SUCCESS == code) {

1,176✔

5369

    code = tlvDecodeValueI32(pDecoder, &pNode->numOfSubplans);

1,176✔

5372

  return code;

1,176✔

5375

static int32_t msgToQueryPlan(STlvDecoder* pDecoder, void* pObj) {

1,176✔

5376

  SQueryPlan* pNode = (SQueryPlan*)pObj;

1,176✔

5378

  int32_t code = TSDB_CODE_SUCCESS;

1,176✔

5379

  STlv*   pTlv = NULL;

1,176✔

5380

  tlvForEach(pDecoder, pTlv, code) {

3,528✔

5381

    switch (pTlv->type) {

2,352✔

5382

      case QUERY_PLAN_CODE_INLINE_ATTRS:

1,176✔

5383

        code = tlvDecodeObjFromTlv(pTlv, msgToQueryPlanInline, pNode);

1,176✔

5384

        break;

1,176✔

5385

      case QUERY_PLAN_CODE_SUBPLANS:

1,176✔

5386

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pSubplans);

1,176✔

5387

        break;

1,176✔

5393

  return code;

1,176✔

5396

static int32_t specificNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,147,483,647✔

5398

  int32_t code = TSDB_CODE_SUCCESS;

2,147,483,647✔

5399

  switch (nodeType(pObj)) {

2,147,483,647✔

5400

    case QUERY_NODE_COLUMN:

2,147,483,647✔

5401

      code = columnNodeToMsg(pObj, pEncoder);

2,147,483,647✔

5402

      break;

2,147,483,647✔

5403

    case QUERY_NODE_VALUE:

486,791,346✔

5404

      code = valueNodeToMsg(pObj, pEncoder);

486,791,346✔

5405

      break;

486,863,885✔

5406

    case QUERY_NODE_OPERATOR:

333,695,306✔

5407

      code = operatorNodeToMsg(pObj, pEncoder);

333,695,306✔

5408

      break;

333,735,811✔

5409

    case QUERY_NODE_LOGIC_CONDITION:

50,189,796✔

5410

      code = logicConditionNodeToMsg(pObj, pEncoder);

50,189,796✔

5411

      break;

50,210,354✔

5412

    case QUERY_NODE_FUNCTION:

706,526,895✔

5413

      code = functionNodeToMsg(pObj, pEncoder);

706,526,895✔

5414

      break;

706,592,731✔

5415

    case QUERY_NODE_ORDER_BY_EXPR:

97,025,989✔

5416

      code = orderByExprNodeToMsg(pObj, pEncoder);

97,025,989✔

5417

      break;

97,039,132✔

5418

    case QUERY_NODE_LIMIT:

41,721,961✔

5419

      code = limitNodeToMsg(pObj, pEncoder);

41,721,961✔

5420

      break;

41,743,626✔

5421

    case QUERY_NODE_NODE_LIST:

11,630,328✔

5422

      code = nodeListNodeToMsg(pObj, pEncoder);

11,630,328✔

5423

      break;

11,635,420✔

5424

    case QUERY_NODE_TARGET:

2,147,483,647✔

5425

      code = targetNodeToMsg(pObj, pEncoder);

2,147,483,647✔

5426

      break;

2,147,483,647✔

5430

    case QUERY_NODE_DATABLOCK_DESC:

1,668,396,579✔

5431

      code = dataBlockDescNodeToMsg(pObj, pEncoder);

1,668,396,579✔

5432

      break;

1,669,758,568✔

5433

    case QUERY_NODE_SLOT_DESC:

2,147,483,647✔

5434

      code = slotDescNodeToMsg(pObj, pEncoder);

2,147,483,647✔

5435

      break;

2,147,483,647✔

5436

    case QUERY_NODE_DOWNSTREAM_SOURCE:

261,808,440✔

5437

      code = downstreamSourceNodeToMsg(pObj, pEncoder);

261,808,440✔

5438

      break;

261,808,077✔

5439

    case QUERY_NODE_LEFT_VALUE:

7,755,691✔

5440

      break;

7,755,691✔

5441

    case QUERY_NODE_WHEN_THEN:

7,227,637✔

5442

      code = whenThenNodeToMsg(pObj, pEncoder);

7,227,637✔

5443

      break;

7,227,061✔

5444

    case QUERY_NODE_CASE_WHEN:

7,075,017✔

5445

      code = caseWhenNodeToMsg(pObj, pEncoder);

7,075,017✔

5446

      break;

7,075,018✔

5447

    case QUERY_NODE_WINDOW_OFFSET:

337,784✔

5448

      code = windowOffsetNodeToMsg(pObj, pEncoder);

337,784✔

5449

      break;

337,784✔

5450

    case QUERY_NODE_REMOTE_VALUE:

61,568,282✔

5451

      code = remoteValueNodeToMsg(pObj, pEncoder);

61,568,282✔

5452

      break;

61,564,516✔

5453

    case QUERY_NODE_REMOTE_VALUE_LIST:

18,935,704✔

5454

      code = remoteValueListNodeToMsg(pObj, pEncoder);

18,935,704✔

5455

      break;

18,939,819✔

5456

    case QUERY_NODE_REMOTE_ROW:

24,212,804✔

5457

      code = remoteRowNodeToMsg(pObj, pEncoder);

24,212,804✔

5458

      break;

24,212,296✔

5459

    case QUERY_NODE_REMOTE_ZERO_ROWS:

1,328,052✔

5460

      code = remoteZeroRowsNodeToMsg(pObj, pEncoder);

1,328,052✔

5461

      break;

1,327,262✔

5462

    case QUERY_NODE_REMOTE_TABLE:

495,062✔

5463

      code = remoteTableNodeToMsg(pObj, pEncoder);

495,062✔

5464

      break;

495,062✔

5465

    case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN:

14,931,613✔

5466

      code = physiTagScanNodeToMsg(pObj, pEncoder);

14,931,613✔

5467

      break;

14,930,599✔

5468

    case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN:

5,730✔

5469

      code = physiScanNodeToMsg(pObj, pEncoder);

5,730✔

5470

      break;

5,730✔

5471

    case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN:

1,580,884✔

5473

      code = physiLastRowScanNodeToMsg(pObj, pEncoder);

1,580,884✔

5474

      break;

1,578,889✔

5475

    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:

393,185,548✔

5478

      code = physiTableScanNodeToMsg(pObj, pEncoder);

393,185,548✔

5479

      break;

392,171,711✔

5480

    case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN:

39,623,010✔

5481

      code = physiSysTableScanNodeToMsg(pObj, pEncoder);

39,623,010✔

5482

      break;

39,631,452✔

5483

    case QUERY_NODE_PHYSICAL_PLAN_PROJECT:

215,334,587✔

5484

      code = physiProjectNodeToMsg(pObj, pEncoder);

215,334,587✔

5485

      break;

215,428,375✔

5486

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN:

16,403,412✔

5487

      code = physiMergeJoinNodeToMsg(pObj, pEncoder);

16,403,412✔

5488

      break;

16,403,955✔

5489

    case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN:

1,274,535✔

5490

      code = physiHashJoinNodeToMsg(pObj, pEncoder);

1,274,535✔

5491

      break;

1,274,535✔

5492

    case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG:

168,975,558✔

5493

      code = physiAggNodeToMsg(pObj, pEncoder);

168,975,558✔

5494

      break;

168,936,990✔

5495

    case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE:

148,111,943✔

5496

      code = physiExchangeNodeToMsg(pObj, pEncoder);

148,111,943✔

5497

      break;

148,110,996✔

5498

    case QUERY_NODE_PHYSICAL_PLAN_MERGE:

19,189,230✔

5499

      code = physiMergeNodeToMsg(pObj, pEncoder);

19,189,230✔

5500

      break;

19,189,398✔

5501

    case QUERY_NODE_PHYSICAL_PLAN_SORT:

55,797,562✔

5503

      code = physiSortNodeToMsg(pObj, pEncoder);

55,797,562✔

5504

      break;

55,806,242✔

5505

    case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL:

14,040,841✔

5507

      code = physiIntervalNodeToMsg(pObj, pEncoder);

14,040,841✔

5508

      break;

14,037,731✔

5509

    case QUERY_NODE_PHYSICAL_PLAN_FILL:

600,177✔

5510

      code = physiFillNodeToMsg(pObj, pEncoder);

600,177✔

5511

      break;

600,177✔

5512

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION:

2,477,682✔

5513

      code = physiSessionWindowNodeToMsg(pObj, pEncoder);

2,477,682✔

5514

      break;

2,477,682✔

5515

    case QUERY_NODE_PHYSICAL_PLAN_EXTERNAL_WINDOW:

1,484,891✔

5518

      code = physiExternalWindowNodeToMsg(pObj, pEncoder);

1,484,891✔

5519

      break;

1,485,309✔

5520

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE:

2,447,671✔

5521

      code = physiStateWindowNodeToMsg(pObj, pEncoder);

2,447,671✔

5522

      break;

2,447,339✔

5523

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT:

1,813,440✔

5524

      code = physiEventWindowNodeToMsg(pObj, pEncoder);

1,813,440✔

5525

      break;

1,815,263✔

5526

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_COUNT:

1,673,505✔

5527

      code = physiCountWindowNodeToMsg(pObj, pEncoder);

1,673,505✔

5528

      break;

1,674,792✔

5532

    case QUERY_NODE_PHYSICAL_PLAN_PARTITION:

10,968,836✔

5533

      code = physiPartitionNodeToMsg(pObj, pEncoder);

10,968,836✔

5534

      break;

10,970,306✔

5535

    case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC:

3,304,007✔

5536

      code = physiIndefRowsFuncNodeToMsg(pObj, pEncoder);

3,304,007✔

5537

      break;

3,301,826✔

5538

    case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC:

3,595,784✔

5539

      code = physiInterpFuncNodeToMsg(pObj, pEncoder);

3,595,784✔

5540

      break;

3,595,784✔

5545

    case QUERY_NODE_PHYSICAL_PLAN_DISPATCH:

538,422,066✔

5546

      code = physiDispatchNodeToMsg(pObj, pEncoder);

538,422,066✔

5547

      break;

538,571,413✔

5548

    case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT:

499,646✔

5549

      code = physiQueryInsertNodeToMsg(pObj, pEncoder);

499,646✔

5550

      break;

499,646✔

5551

    case QUERY_NODE_PHYSICAL_PLAN_DELETE:

1,887,752✔

5552

      code = physiDeleteNodeToMsg(pObj, pEncoder);

1,887,752✔

5553

      break;

1,887,752✔

5554

    case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE:

1,273,717✔

5555

      code = physiGroupCacheNodeToMsg(pObj, pEncoder);

1,273,717✔

5556

      break;

1,273,717✔

5557

    case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL:

5,568,760✔

5558

      code = physiDynQueryCtrlNodeToMsg(pObj, pEncoder);

5,568,760✔

5559

      break;

5,568,760✔

5560

    case QUERY_NODE_PHYSICAL_PLAN_VIRTUAL_TABLE_SCAN:

4,502,099✔

5561

      code = physiVirtualTableScanNodeToMsg(pObj, pEncoder);

4,502,099✔

5562

      break;

4,502,099✔

5563

    case QUERY_NODE_PHYSICAL_SUBPLAN:

541,192,968✔

5564

      code = subplanToMsg(pObj, pEncoder);

541,192,968✔

5565

      break;

540,733,660✔

5566

    case QUERY_NODE_PHYSICAL_PLAN:

2,354✔

5567

      code = queryPlanToMsg(pObj, pEncoder);

2,354✔

5568

      break;

2,352✔

5572

  if (TSDB_CODE_SUCCESS != code) {

2,147,483,647✔

5576

  return code;

2,147,483,647✔

5579

static int32_t msgToSpecificNode(STlvDecoder* pDecoder, void* pObj) {

2,147,483,647✔

5580

  int32_t code = TSDB_CODE_SUCCESS;

2,147,483,647✔

5581

  switch (nodeType(pObj)) {

2,147,483,647✔

5582

    case QUERY_NODE_COLUMN:

2,147,483,647✔

5583

      code = msgToColumnNode(pDecoder, pObj);

2,147,483,647✔

5584

      break;

2,147,483,647✔

5585

    case QUERY_NODE_VALUE:

405,570,592✔

5586

      code = msgToValueNode(pDecoder, pObj);

405,570,592✔

5587

      break;

405,541,233✔

5588

    case QUERY_NODE_OPERATOR:

274,902,359✔

5589

      code = msgToOperatorNode(pDecoder, pObj);

274,902,359✔

5590

      break;

274,905,939✔

5591

    case QUERY_NODE_LOGIC_CONDITION:

46,750,621✔

5592

      code = msgToLogicConditionNode(pDecoder, pObj);

46,750,621✔

5593

      break;

46,751,012✔

5594

    case QUERY_NODE_FUNCTION:

576,376,845✔

5595

      code = msgToFunctionNode(pDecoder, pObj);

576,376,845✔

5596

      break;

576,353,009✔

5597

    case QUERY_NODE_ORDER_BY_EXPR:

63,987,092✔

5598

      code = msgToOrderByExprNode(pDecoder, pObj);

63,987,092✔

5599

      break;

63,988,735✔

5600

    case QUERY_NODE_LIMIT:

34,953,705✔

5601

      code = msgToLimitNode(pDecoder, pObj);

34,953,705✔

5602

      break;

34,953,961✔

5603

    case QUERY_NODE_NODE_LIST:

7,870,706✔

5604

      code = msgToNodeListNode(pDecoder, pObj);

7,870,706✔

5605

      break;

7,871,879✔

5606

    case QUERY_NODE_TARGET:

2,147,483,647✔

5607

      code = msgToTargetNode(pDecoder, pObj);

2,147,483,647✔

5608

      break;

2,147,483,647✔

5612

    case QUERY_NODE_DATABLOCK_DESC:

1,188,387,971✔

5613

      code = msgToDataBlockDescNode(pDecoder, pObj);

1,188,387,971✔

5614

      break;

1,188,409,740✔

5615

    case QUERY_NODE_SLOT_DESC:

2,147,483,647✔

5616

      code = msgToSlotDescNode(pDecoder, pObj);

2,147,483,647✔

5617

      break;

2,147,483,647✔

5618

    case QUERY_NODE_DOWNSTREAM_SOURCE:

194,653,470✔

5619

      code = msgToDownstreamSourceNode(pDecoder, pObj);

194,653,470✔

5620

    case QUERY_NODE_LEFT_VALUE:

202,395,502✔

5621

      break;

202,395,502✔

5622

    case QUERY_NODE_WHEN_THEN:

1,598,878✔

5623

      code = msgToWhenThenNode(pDecoder, pObj);

1,598,878✔

5624

      break;

1,598,878✔

5625

    case QUERY_NODE_CASE_WHEN:

1,446,983✔

5626

      code = msgToCaseWhenNode(pDecoder, pObj);

1,446,983✔

5627

      break;

1,446,983✔

5628

    case QUERY_NODE_WINDOW_OFFSET:

338,570✔

5629

      code = msgToWindowOffsetNode(pDecoder, pObj);

338,570✔

5630

      break;

338,570✔

5631

    case QUERY_NODE_REMOTE_VALUE:

5,022,417✔

5632

      code = msgToRemoteValueNode(pDecoder, pObj);

5,022,417✔

5633

      break;

5,023,553✔

5634

    case QUERY_NODE_REMOTE_VALUE_LIST:

12,489,018✔

5635

      code = msgToRemoteValueListNode(pDecoder, pObj);

12,489,018✔

5636

      break;

12,489,018✔

5637

    case QUERY_NODE_REMOTE_ROW:

22,686,476✔

5638

      code = msgToRemoteRowNode(pDecoder, pObj);

22,686,476✔

5639

      break;

22,686,476✔

5640

    case QUERY_NODE_REMOTE_ZERO_ROWS:

395,288✔

5641

      code = msgToRemoteZeroRowsNode(pDecoder, pObj);

395,288✔

5642

      break;

395,288✔

5643

    case QUERY_NODE_REMOTE_TABLE:

491,026✔

5644

      code = msgToRemoteTableNode(pDecoder, pObj);

491,026✔

5645

      break;

491,026✔

5646

    case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN:

8,287,652✔

5647

      code = msgToPhysiTagScanNode(pDecoder, pObj);

8,287,652✔

5648

      break;

8,286,134✔

5649

    case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN:

5,735✔

5650

      code = msgToPhysiScanNode(pDecoder, pObj);

5,735✔

5651

      break;

5,735✔

5652

    case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN:

1,573,768✔

5654

      code = msgToPhysiLastRowScanNode(pDecoder, pObj);

1,573,768✔

5655

      break;

1,574,436✔

5656

    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:

283,733,321✔

5659

      code = msgToPhysiTableScanNode(pDecoder, pObj);

283,733,321✔

5660

      break;

283,752,923✔

5661

    case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN:

23,194,999✔

5662

      code = msgToPhysiSysTableScanNode(pDecoder, pObj);

23,194,999✔

5663

      break;

23,192,177✔

5664

    case QUERY_NODE_PHYSICAL_PLAN_PROJECT:

151,972,759✔

5665

      code = msgToPhysiProjectNode(pDecoder, pObj);

151,972,759✔

5666

      break;

151,977,281✔

5667

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN:

13,457,881✔

5668

      code = msgToPhysiMergeJoinNode(pDecoder, pObj);

13,457,881✔

5669

      break;

13,457,881✔

5670

    case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN:

1,274,495✔

5671

      code = msgToPhysiHashJoinNode(pDecoder, pObj);

1,274,495✔

5672

      break;

1,274,495✔

5673

    case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG:

130,625,939✔

5674

      code = msgToPhysiAggNode(pDecoder, pObj);

130,625,939✔

5675

      break;

130,632,572✔

5676

    case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE:

114,249,686✔

5677

      code = msgToPhysiExchangeNode(pDecoder, pObj);

114,249,686✔

5678

      break;

114,247,146✔

5679

    case QUERY_NODE_PHYSICAL_PLAN_MERGE:

14,494,530✔

5680

      code = msgToPhysiMergeNode(pDecoder, pObj);

14,494,530✔

5681

      break;

14,495,998✔

5682

    case QUERY_NODE_PHYSICAL_PLAN_SORT:

34,589,737✔

5684

      code = msgToPhysiSortNode(pDecoder, pObj);

34,589,737✔

5685

      break;

34,590,688✔

5686

    case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL:

5,926,881✔

5688

      code = msgToPhysiIntervalNode(pDecoder, pObj);

5,926,881✔

5689

      break;

5,927,874✔

5690

    case QUERY_NODE_PHYSICAL_PLAN_FILL:

594,893✔

5691

      code = msgToPhysiFillNode(pDecoder, pObj);

594,893✔

5692

      break;

594,893✔

5693

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION:

597,979✔

5694

      code = msgToPhysiSessionWindowNode(pDecoder, pObj);

597,979✔

5695

      break;

597,979✔

5696

    case QUERY_NODE_PHYSICAL_PLAN_EXTERNAL_WINDOW:

1,470,374✔

5699

      code = msgToPhysiExternalWindowNode(pDecoder, pObj);

1,470,374✔

5700

      break;

1,470,374✔

5701

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE:

1,027,780✔

5702

      code = msgToPhysiStateWindowNode(pDecoder, pObj);

1,027,780✔

5703

      break;

1,027,780✔

5704

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT:

337,781✔

5705

      code = msgToPhysiEventWindowNode(pDecoder, pObj);

337,781✔

5706

      break;

337,781✔

5707

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_COUNT:

275,221✔

5708

      code = msgToPhysiCountWindowNode(pDecoder, pObj);

275,221✔

5709

      break;

275,221✔

5713

    case QUERY_NODE_PHYSICAL_PLAN_PARTITION:

3,105,656✔

5714

      code = msgToPhysiPartitionNode(pDecoder, pObj);

3,105,656✔

5715

      break;

3,106,064✔

5716

    case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC:

3,274,962✔

5717

      code = msgToPhysiIndefRowsFuncNode(pDecoder, pObj);

3,274,962✔

5718

      break;

3,275,099✔

5719

    case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC:

3,586,340✔

5720

      code = msgToPhysiInterpFuncNode(pDecoder, pObj);

3,586,340✔

5721

      break;

3,586,872✔

5726

    case QUERY_NODE_PHYSICAL_PLAN_DISPATCH:

379,430,287✔

5727

      code = msgToPhysiDispatchNode(pDecoder, pObj);

379,430,287✔

5728

      break;

379,444,645✔

5729

    case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT:

499,196✔

5730

      code = msgToPhysiQueryInsertNode(pDecoder, pObj);

499,196✔

5731

      break;

499,196✔

5732

    case QUERY_NODE_PHYSICAL_PLAN_DELETE:

1,885,698✔

5733

      code = msgToPhysiDeleteNode(pDecoder, pObj);

1,885,698✔

5734

      break;

1,885,698✔

5735

    case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE:

1,273,677✔

5736

      code = msgToPhysiGroupCacheNode(pDecoder, pObj);

1,273,677✔

5737

      break;

1,273,677✔

5738

    case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL:

3,515,261✔

5739

      code = msgToPhysiDynQueryCtrlNode(pDecoder, pObj);

3,515,261✔

5740

      break;

3,515,261✔

5741

    case QUERY_NODE_PHYSICAL_PLAN_VIRTUAL_TABLE_SCAN:

4,037,211✔

5742

      code = msgToPhysiVirtualTableScanNode(pDecoder, pObj);

4,037,211✔

5743

      break;

4,037,211✔

5744

    case QUERY_NODE_PHYSICAL_SUBPLAN:

381,820,456✔

5745

      code = msgToSubplan(pDecoder, pObj);

381,820,456✔

5746

      break;

381,848,147✔

5747

    case QUERY_NODE_PHYSICAL_PLAN:

1,176✔

5748

      code = msgToQueryPlan(pDecoder, pObj);

1,176✔

5749

      break;

1,176✔

5753

  if (TSDB_CODE_SUCCESS != code) {

2,147,483,647✔

5756

  return code;

2,147,483,647✔

5759

static int32_t nodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,147,483,647✔

5760

  return tlvEncodeObj(pEncoder, nodeType(pObj), specificNodeToMsg, pObj);

2,147,483,647✔

5763

static int32_t msgToNode(STlvDecoder* pDecoder, void** pObj) {

2,147,483,647✔

5764

  return tlvDecodeDynObj(pDecoder, (FMakeObject)nodesMakeNode, msgToSpecificNode, pObj);

2,147,483,647✔

5767

static int32_t msgToNodeFromTlv(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 msgToNode(&decoder, pObj);

2,147,483,647✔

5772

static int32_t nodeListToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,147,483,647✔

5773

  const SNodeList* pList = (const SNodeList*)pObj;

2,147,483,647✔

5775

  SNode* pNode = NULL;

2,147,483,647✔

5776

  FOREACH(pNode, pList) {

2,147,483,647✔

5777

    int32_t code = nodeToMsg(pNode, pEncoder);

2,147,483,647✔

5778

    if (TSDB_CODE_SUCCESS != code) {

2,147,483,647✔

5783

  return TSDB_CODE_SUCCESS;

2,147,483,647✔

5792

static int32_t SArrayToMsg(const void* pObj, STlvEncoder* pEncoder) {

148,111,305✔

5793

  const SArray* pArray = (const SArray*)pObj;

148,111,305✔

5794

  int32_t code = TSDB_CODE_SUCCESS;

148,111,305✔

5795

  if (TSDB_CODE_SUCCESS == code) {

148,111,305✔

5796

    code = tlvEncodeI32(pEncoder, SARRAY_CODE_CAPACITY, pArray->capacity);

148,112,293✔

5798

  if (TSDB_CODE_SUCCESS == code) {

148,111,005✔

5799

    code = tlvEncodeI32(pEncoder, SARRAY_CODE_ELEMSIZE, pArray->elemSize);

148,111,659✔

5801

  if (TSDB_CODE_SUCCESS == code) {

148,111,047✔

5802

    code = tlvEncodeI32(pEncoder, SARRAY_CODE_SIZE, pArray->size);

148,111,701✔

5804

  if (TSDB_CODE_SUCCESS == code && pArray->capacity * pArray->elemSize > 0 && pArray->pData != NULL) {

148,112,795✔

5805

    code = tlvEncodeBinary(pEncoder, SARRAY_CODE_PDATA, pArray->pData, pArray->capacity * pArray->elemSize);

148,111,314✔

5807

  return code;

148,112,841✔

5811

static int32_t msgToNodeList(STlvDecoder* pDecoder, void** pObj) {

2,147,483,647✔

5812

  SNodeList* pList = NULL;

2,147,483,647✔

5813

  int32_t code = TSDB_CODE_SUCCESS;

2,147,483,647✔

5814

  code = nodesMakeList(&pList);

2,147,483,647✔

5816

  while (TSDB_CODE_SUCCESS == code && !tlvDecodeEnd(pDecoder)) {

2,147,483,647✔

5817

    SNode* pNode = NULL;

2,147,483,647✔

5818

    code = msgToNode(pDecoder, (void**)&pNode);

2,147,483,647✔

5819

    if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

5820

      code = nodesListAppend(pList, pNode);

2,147,483,647✔

5823

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

5824

    *pObj = pList;

2,147,483,647✔

5828

  return code;

2,147,483,647✔

5831

static int32_t msgToSArray(STlv* pTlv, void** pObj){

114,248,615✔

5832

  SArray* pArray = NULL;

114,248,615✔

5833

  uint32_t capacity = 0;

114,248,615✔

5834

  uint32_t elemSize = 0;

114,249,164✔

5835

  uint32_t actualSize;

114,248,024✔

5836

  int32_t decodeFieldNum = 0;;

114,248,609✔

5837

  int32_t code = TSDB_CODE_SUCCESS;

114,248,609✔

5838

  STlvDecoder decoder = {.bufSize = pTlv->len, .offset = 0, .pBuf = pTlv->value};

114,248,609✔

5839

  STlv*   pTlvTemp = NULL;

114,248,087✔

5840

  STlv*   pDataTlv = NULL;

114,248,739✔

5842

  tlvForEach(&decoder, pTlvTemp, code) {

571,245,751✔

5843

    switch (pTlvTemp->type) {

456,997,088✔

5844

      case SARRAY_CODE_CAPACITY:

114,249,288✔

5845

        code = tlvDecodeI32(pTlvTemp, &capacity);

114,249,288✔

5846

        break;

114,249,686✔

5847

      case SARRAY_CODE_ELEMSIZE:

114,249,686✔

5848

        code = tlvDecodeI32(pTlvTemp, &elemSize);

114,249,686✔

5849

        break;

114,249,686✔

5850

      case SARRAY_CODE_SIZE:

114,250,027✔

5851

        code = tlvDecodeI32(pTlvTemp, &actualSize);

114,250,027✔

5852

        break;

114,249,686✔

5853

      case SARRAY_CODE_PDATA:

114,248,087✔

5854

        if (decodeFieldNum < 3) {

114,248,087✔

5858

        pArray = taosArrayInit(capacity, elemSize);

114,248,087✔

5859

        if (NULL == pArray) {

114,249,164✔

5862

        pArray->size = actualSize;

114,249,164✔

5863

        if (TSDB_CODE_SUCCESS != code || pTlvTemp == NULL) {

114,247,826✔

5864

          taosArrayDestroy(pArray);

552✔

5867

        code = tlvDecodeBinary(pTlvTemp, pArray->pData);

114,247,274✔

5868

        break;

114,247,954✔

5872

    decodeFieldNum++;

456,997,012✔

5875

  if (pDataTlv != NULL) {

114,251,792✔

5887

  *pObj = pArray;

114,251,792✔

5888

  return code;

114,247,674✔

5892

static int32_t msgToNodeListFromTlv(STlv* pTlv, void** pObj) {

2,147,483,647✔

5893

  STlvDecoder decoder = {.bufSize = pTlv->len, .offset = 0, .pBuf = pTlv->value};

2,147,483,647✔

5894

  return msgToNodeList(&decoder, pObj);

2,147,483,647✔

5897

int32_t nodesNodeToMsg(const SNode* pNode, char** pMsg, int32_t* pLen) {

541,187,512✔

5898

  if (NULL == pNode || NULL == pMsg || NULL == pLen) {

541,187,512✔

5899

    terrno = TSDB_CODE_FAILED;

6✔

5903

  STlvEncoder encoder;

412,896,158✔

5904

  int32_t     code = initTlvEncoder(&encoder);

541,353,879✔

5905

  if (TSDB_CODE_SUCCESS == code) {

540,368,962✔

5906

    code = nodeToMsg(pNode, &encoder);

540,401,005✔

5908

  if (TSDB_CODE_SUCCESS == code) {

541,154,627✔

5909

    endTlvEncode(&encoder, pMsg, pLen);

541,148,266✔

5911

  clearTlvEncoder(&encoder);

540,445,539✔

5913

  terrno = code;

540,787,316✔

5914

  return code;

540,916,528✔

5917

int32_t nodesMsgToNode(const char* pMsg, int32_t len, SNode** pNode) {

381,904,974✔

5918

  if (NULL == pMsg || NULL == pNode) {

381,904,974✔

5922

  STlvDecoder decoder = {.bufSize = len, .offset = 0, .pBuf = pMsg};

381,926,357✔

5923

  int32_t     code = msgToNode(&decoder, (void**)pNode);

381,926,643✔

5924

  if (TSDB_CODE_SUCCESS != code) {

381,912,574✔

5929

  terrno = code;

381,912,574✔

5930

  return code;

381,863,434✔

taosdata / TDengine / #5034

Source File
Press 'n' to go to next uncovered line, 'b' for previous

taosdata / TDengine / #5034

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