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

77

static int32_t initTlvEncoder(STlvEncoder* pEncoder) {

522,885,741✔

78

  pEncoder->allocSize = NODES_MSG_DEFAULT_LEN;

522,885,741✔

79

  pEncoder->offset = 0;

523,066,072✔

80

  pEncoder->tlvCount = 0;

522,990,398✔

81

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

523,032,805✔

82

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

522,169,069✔

85

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

522,474,992✔

87

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

522,520,243✔

88

  *pMsg = pEncoder->pBuf;

522,520,243✔

89

  pEncoder->pBuf = NULL;

522,866,981✔

90

  *pLen = pEncoder->offset;

522,737,839✔

91

522,774,239✔

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

241,263,358✔

97

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

241,326,683✔

98

    if (NULL == pNewBuf) {

241,147,930✔

101

    pEncoder->pBuf = pNewBuf;

241,147,930✔

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

237,157,714✔

115

    if (NULL == pNewBuf) {

237,011,805✔

118

    pEncoder->pBuf = pNewBuf;

237,011,805✔

119

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

236,988,188✔

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

544,891,910✔

135

  value = htons(value);

544,891,910✔

136

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

544,891,910✔

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

492,453,277✔

155

  value = htonll(value);

492,453,277✔

156

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

492,453,277✔

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

85,356,753✔

173

  value = htons(value);

85,356,753✔

174

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

85,356,753✔

177

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

704,795,176✔

178

  value = htons(value);

704,795,176✔

179

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

704,795,176✔

182

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

889,679,621✔

183

  value = htonll(value);

889,679,621✔

184

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

889,679,621✔

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

26,514,752✔

193

  int64_t temp = *(int64_t*)&value;

26,514,752✔

194

  temp = htonll(temp);

26,489,075✔

195

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

26,489,075✔

198

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

378,040,523✔

199

  int64_t temp = *(int64_t*)&value;

378,040,523✔

200

  temp = htonll(temp);

378,188,913✔

201

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

378,188,913✔

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,120,261,056✔

223

  if (NULL == pValue) {

2,120,261,056✔

224

    return TSDB_CODE_SUCCESS;

237,515,736✔

226

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

1,882,745,320✔

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

211,665,673✔

239

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

211,665,673✔

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

124,458,422✔

249

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

124,466,201✔

250

    if (NULL == pNewBuf) {

124,356,607✔

253

    pEncoder->pBuf = pNewBuf;

124,356,607✔

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,883,430✔

270

  int32_t code = TSDB_CODE_SUCCESS;

44,883,430✔

271

  if (num > 0) {

44,883,430✔

272

    int32_t start = pEncoder->offset;

44,905,151✔

273

    pEncoder->offset += sizeof(STlv);

44,925,330✔

274

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

90,195,207✔

275

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

45,306,219✔

277

    if (TSDB_CODE_SUCCESS == code) {

44,888,988✔

278

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

44,925,267✔

279

      pTlv->type = htons(type);

44,898,817✔

280

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

44,878,529✔

283

  return code;

44,890,509✔

286

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

778,503,639✔

288

  int32_t code = tlvEncodeValueI32(pEncoder, num);

778,503,639✔

289

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

1,483,464,511✔

290

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

704,580,619✔

292

  return code;

778,883,892✔

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

412,001,065✔

342

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

412,001,065✔

343

  if (TSDB_CODE_SUCCESS == code) {

412,031,371✔

344

    *pValue = ntohs(*pValue);

412,034,400✔

346

  return code;

412,001,731✔

349

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

2,147,483,647✔

350

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

2,147,483,647✔

351

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

352

    *pValue = ntohs(*pValue);

2,147,483,647✔

354

  return code;

2,147,483,647✔

357

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

2,147,483,647✔

358

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

2,147,483,647✔

359

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

360

    *pValue = ntohl(*pValue);

2,147,483,647✔

362

  return code;

2,147,483,647✔

365

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

2,147,483,647✔

366

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

2,147,483,647✔

367

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

368

    *pValue = ntohl(*pValue);

2,147,483,647✔

370

  return code;

2,147,483,647✔

373

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

403,742,245✔

374

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

403,742,245✔

375

  if (TSDB_CODE_SUCCESS == code) {

403,749,253✔

376

    *pValue = ntohll(*pValue);

403,753,737✔

378

  return code;

403,759,929✔

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

54,175,822✔

401

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

54,175,822✔

402

  if (TSDB_CODE_SUCCESS == code) {

54,175,898✔

403

    *pValue = ntohs(*pValue);

54,176,516✔

405

  return code;

54,175,830✔

408

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

511,337,189✔

409

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

511,337,189✔

410

  if (TSDB_CODE_SUCCESS == code) {

511,392,163✔

411

    *pValue = ntohs(*pValue);

511,390,987✔

413

  return code;

511,342,886✔

416

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

635,456,213✔

417

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

635,456,213✔

418

  if (TSDB_CODE_SUCCESS == code) {

635,545,399✔

419

    *pValue = ntohll(*pValue);

635,557,503✔

421

  return code;

635,548,648✔

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

26,433,095✔

433

  volatile int64_t temp = 0;

26,433,095✔

434

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

26,435,770✔

435

  if (TSDB_CODE_SUCCESS == code) {

26,434,376✔

436

    *pValue = *(double*)&temp;

26,435,811✔

438

  return code;

26,430,516✔

441

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

274,348,202✔

442

  volatile int64_t temp = 0;

274,348,202✔

443

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

274,370,922✔

444

  if (TSDB_CODE_SUCCESS == code) {

274,400,276✔

445

    *pValue = *(double*)&temp;

274,399,079✔

447

  return code;

274,380,712✔

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,183,042,177✔

504

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

1,183,042,177✔

507

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

1,183,054,289✔

508

  return TSDB_CODE_SUCCESS;

1,183,037,574✔

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

244,924,893✔

521

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

244,924,893✔

522

  return NULL == *pValue ? terrno : TSDB_CODE_SUCCESS;

244,877,346✔

525

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

1,491✔

526

  *pValue = taosMemoryMalloc(pTlv->len);

1,491✔

527

  if (NULL == *pValue) {

1,491✔

530

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

1,491✔

531

  return TSDB_CODE_SUCCESS;

1,491✔

534

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

166,944,969✔

535

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

166,944,969✔

536

  return TSDB_CODE_SUCCESS;

166,942,335✔

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

28,405,925✔

554

  int32_t code = TSDB_CODE_SUCCESS;

28,405,925✔

555

  int32_t i = 0;

28,405,925✔

556

  STlv*   pTlv = NULL;

28,405,925✔

557

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

57,153,260✔

558

  return code;

28,408,791✔

561

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

566,355,703✔

563

  int32_t code = tlvDecodeValueI32(pDecoder, pNum);

566,355,703✔

564

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

1,077,749,152✔

565

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

511,407,734✔

567

  return code;

566,365,941✔

570

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

28,406,513✔

571

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

28,406,513✔

572

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

28,407,695✔

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,592,995,151✔

612

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

1,592,995,151✔

614

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

1,592,995,151✔

615

  if (TSDB_CODE_SUCCESS == code) {

1,593,587,821✔

616

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

1,593,633,176✔

618

  if (TSDB_CODE_SUCCESS == code) {

1,594,256,855✔

619

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

1,594,267,571✔

621

  if (TSDB_CODE_SUCCESS == code) {

1,594,340,593✔

622

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

1,594,353,997✔

625

  return code;

1,594,342,211✔

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,259,577,184✔

646

  SDataType* pNode = (SDataType*)pObj;

1,259,577,184✔

648

  int32_t code = TSDB_CODE_SUCCESS;

1,259,577,184✔

649

  STlv*   pTlv = NULL;

1,259,577,184✔

650

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

651

    switch (pTlv->type) {

2,147,483,647✔

652

      case DATA_TYPE_CODE_TYPE:

1,259,636,673✔

653

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

1,259,636,673✔

654

        break;

1,259,614,602✔

655

      case DATA_TYPE_CODE_PRECISION:

1,259,675,351✔

656

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

1,259,675,351✔

657

        break;

1,259,653,720✔

658

      case DATA_TYPE_CODE_SCALE:

1,259,679,787✔

659

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

1,259,679,787✔

660

        break;

1,259,675,558✔

661

      case DATA_TYPE_CODE_BYTES:

1,259,568,674✔

662

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

1,259,568,674✔

663

        break;

1,259,646,852✔

669

  return code;

1,259,346,698✔

674

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

1,593,015,032✔

675

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

1,593,015,032✔

676

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

1,593,015,032✔

677

  if (TSDB_CODE_SUCCESS == code) {

1,594,318,998✔

678

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

1,594,326,750✔

680

  if (TSDB_CODE_SUCCESS == code) {

1,594,325,007✔

681

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

1,594,283,384✔

683

  if (TSDB_CODE_SUCCESS == code) {

1,594,384,252✔

684

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

1,594,345,084✔

686

  return code;

1,594,406,785✔

689

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

1,259,552,361✔

690

  SExprNode* pNode = (SExprNode*)pObj;

1,259,552,361✔

692

  int32_t code = TSDB_CODE_SUCCESS;

1,259,552,361✔

693

  STlv*   pTlv = NULL;

1,259,552,361✔

694

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

695

    switch (pTlv->type) {

2,147,483,647✔

696

      case EXPR_CODE_RES_TYPE:

1,259,639,909✔

697

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

1,259,639,909✔

698

        break;

1,259,598,903✔

699

      case EXPR_CODE_BIND_TUPLE_FUNC_IDX:

1,259,669,703✔

700

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

1,259,669,703✔

701

        break;

1,259,655,359✔

702

      case EXPR_CODE_TUPLE_FUNC_IDX:

1,259,669,444✔

703

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

1,259,669,444✔

704

        break;

1,259,655,177✔

705

      case EXPR_CODE_HAS_NULL:

1,259,528,716✔

706

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

1,259,528,716✔

707

        break;

1,259,618,924✔

713

  return code;

1,259,786,196✔

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

454,673,719✔

892

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

454,673,719✔

894

  int32_t code = TSDB_CODE_SUCCESS;

454,673,719✔

895

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

454,673,719✔

898

    case TSDB_DATA_TYPE_BOOL:

18,150,757✔

899

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

18,150,757✔

900

      break;

18,163,278✔

901

    case TSDB_DATA_TYPE_TINYINT:

341,888,110✔

906

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

341,888,110✔

907

      break;

342,557,851✔

908

    case TSDB_DATA_TYPE_UTINYINT:

16,429✔

912

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

16,429✔

913

      break;

16,429✔

914

    case TSDB_DATA_TYPE_FLOAT:

26,480,033✔

916

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

26,480,033✔

917

      break;

26,541,491✔

918

    case TSDB_DATA_TYPE_VARCHAR:

67,385,767✔

922

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

67,385,767✔

923

      break;

67,575,040✔

924

    case TSDB_DATA_TYPE_JSON:

1,494✔

925

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

1,494✔

926

      break;

9,799✔

927

    case TSDB_DATA_TYPE_DECIMAL:

2,436✔

928

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

2,436✔

929

      break;

2,436✔

930

    case TSDB_DATA_TYPE_DECIMAL64:

195✔

931

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

195✔

932

      break;

195✔

941

  return code;

454,844,757✔

944

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

544,879,928✔

945

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

544,879,928✔

947

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

544,879,928✔

948

  if (TSDB_CODE_SUCCESS == code) {

545,333,183✔

949

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

545,334,963✔

951

  if (TSDB_CODE_SUCCESS == code) {

545,267,242✔

952

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

545,234,139✔

954

  if (TSDB_CODE_SUCCESS == code) {

545,231,425✔

955

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

545,201,996✔

957

  if (TSDB_CODE_SUCCESS == code) {

545,014,847✔

958

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

544,986,964✔

960

  if (TSDB_CODE_SUCCESS == code) {

545,352,353✔

961

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

545,325,203✔

963

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

545,008,118✔

964

    code = datumToMsg(pNode, pEncoder);

454,710,233✔

966

  if (TSDB_CODE_SUCCESS == code) {

545,254,703✔

967

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

545,107,355✔

970

  return code;

545,302,632✔

973

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

382,614,932✔

974

  SValueNode* pNode = (SValueNode*)pObj;

382,614,932✔

976

  int32_t code = TSDB_CODE_SUCCESS;

382,614,932✔

977

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

382,614,932✔

980

    case TSDB_DATA_TYPE_BOOL:

18,081,835✔

981

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

18,081,835✔

982

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

18,082,213✔

983

      break;

18,082,213✔

984

    case TSDB_DATA_TYPE_TINYINT:

139,396,304✔

985

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

139,396,304✔

986

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

139,412,578✔

987

      break;

139,415,978✔

988

    case TSDB_DATA_TYPE_SMALLINT:

8,869,011✔

989

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

8,869,011✔

990

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

8,874,983✔

991

      break;

8,874,156✔

992

    case TSDB_DATA_TYPE_INT:

22,047,879✔

993

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

22,047,879✔

994

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

22,051,299✔

995

      break;

22,050,959✔

996

    case TSDB_DATA_TYPE_BIGINT:

103,001,045✔

997

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

103,001,045✔

998

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

103,017,622✔

999

      break;

103,020,767✔

1000

    case TSDB_DATA_TYPE_TIMESTAMP:

9,970,468✔

1001

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

9,970,468✔

1002

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

9,969,394✔

1003

      break;

9,970,302✔

1004

    case TSDB_DATA_TYPE_UTINYINT:

6,363✔

1005

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

6,363✔

1006

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

6,363✔

1007

      break;

6,363✔

1008

    case TSDB_DATA_TYPE_USMALLINT:

1,275✔

1009

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

1,275✔

1010

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

1,275✔

1011

      break;

1,275✔

1012

    case TSDB_DATA_TYPE_UINT:

2,283✔

1013

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

2,283✔

1014

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

2,283✔

1015

      break;

2,283✔

1016

    case TSDB_DATA_TYPE_UBIGINT:

6,479✔

1017

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

6,479✔

1018

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

6,479✔

1019

      break;

6,479✔

1020

    case TSDB_DATA_TYPE_FLOAT:

1,332,710✔

1021

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

1,332,710✔

1022

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

1,332,710✔

1023

      break;

1,332,710✔

1024

    case TSDB_DATA_TYPE_DOUBLE:

25,102,900✔

1025

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

25,102,900✔

1026

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

25,093,864✔

1027

      break;

25,097,316✔

1028

    case TSDB_DATA_TYPE_NCHAR:

54,726,649✔

1032

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

54,726,649✔

1036

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

54,725,663✔

1037

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

54,725,280✔

1041

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

54,715,081✔

1042

      if (TSDB_CODE_SUCCESS == code) {

54,710,129✔

1043

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

54,710,438✔

1045

      break;

54,708,614✔

1047

    case TSDB_DATA_TYPE_JSON: {

1,491✔

1048

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

1,491✔

1052

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

1,491✔

1053

      break;

1,491✔

1055

    case TSDB_DATA_TYPE_DECIMAL:

2,241✔

1056

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

2,241✔

1057

      if (!pNode->datum.p) {

2,241✔

1061

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

2,241✔

1062

      break;

2,241✔

1075

        break;

1,357✔

1087

  return code;

382,573,688✔

1090

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

412,014,867✔

1091

  SValueNode* pNode = (SValueNode*)pObj;

412,014,867✔

1093

  int32_t code = TSDB_CODE_SUCCESS;

412,014,867✔

1094

  STlv*   pTlv = NULL;

412,014,867✔

1095

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

1096

    switch (pTlv->type) {

2,147,483,647✔

1097

      case VALUE_CODE_EXPR_BASE:

411,997,977✔

1098

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

411,997,977✔

1099

        break;

412,042,807✔

1100

      case VALUE_CODE_LITERAL:

244,947,896✔

1101

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

244,947,896✔

1102

        break;

244,909,654✔

1103

      case VALUE_CODE_FLAG:

412,042,219✔

1104

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

412,042,219✔

1105

        break;

412,028,388✔

1106

      case VALUE_CODE_TRANSLATE:

412,045,872✔

1107

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

412,045,872✔

1108

        break;

411,995,173✔

1109

      case VALUE_CODE_NOT_RESERVED:

412,045,598✔

1110

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

412,045,598✔

1111

        break;

412,029,381✔

1112

      case VALUE_CODE_IS_NULL:

412,042,410✔

1113

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

412,042,410✔

1114

        break;

412,037,329✔

1115

      case VALUE_CODE_DATUM:

382,657,516✔

1116

        code = msgToDatum(pTlv, pNode);

382,657,516✔

1117

        break;

382,578,100✔

1118

      case VALUE_CODE_PLACEHOLDER_NO:

411,968,270✔

1119

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

411,968,270✔

1120

        break;

412,020,049✔

1126

  return code;

412,304,445✔

1135

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

60,439,873✔

1136

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

60,439,873✔

1138

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

60,439,873✔

1144

  if (TSDB_CODE_SUCCESS == code) {

60,489,030✔

1145

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

60,489,224✔

1148

  return code;

60,477,615✔

1152

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

5,265,223✔

1153

  SRemoteValueNode* pNode = (SRemoteValueNode*)pObj;

5,265,223✔

1155

  int32_t code = TSDB_CODE_SUCCESS;

5,265,223✔

1156

  STlv*   pTlv = NULL;

5,265,223✔

1157

  tlvForEach(pDecoder, pTlv, code) {

15,797,346✔

1158

    switch (pTlv->type) {

10,532,682✔

1159

      case REMOTE_VALUE_CODE_VAL:

5,265,782✔

1160

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

5,265,782✔

1161

        break;

5,265,782✔

1167

      case REMOTE_VALUE_CODE_SUBQ_IDX:

5,266,341✔

1168

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

5,266,341✔

1169

        break;

5,266,341✔

1175

  return code;

5,265,223✔

1184

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

18,057,243✔

1185

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

18,057,243✔

1187

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

18,057,243✔

1188

  if (TSDB_CODE_SUCCESS == code) {

18,066,163✔

1189

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

18,066,163✔

1191

  if (TSDB_CODE_SUCCESS == code) {

18,064,662✔

1192

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

18,064,806✔

1195

  return code;

18,066,332✔

1199

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

11,779,294✔

1200

  SRemoteValueListNode* pNode = (SRemoteValueListNode*)pObj;

11,779,294✔

1202

  int32_t code = TSDB_CODE_SUCCESS;

11,779,294✔

1203

  STlv*   pTlv = NULL;

11,779,294✔

1204

  tlvForEach(pDecoder, pTlv, code) {

47,118,853✔

1205

    switch (pTlv->type) {

35,339,559✔

1206

      case REMOTE_VALUELIST_CODE_EXPR:

11,779,853✔

1207

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

11,779,853✔

1208

        break;

11,779,853✔

1209

      case REMOTE_VALUELIST_CODE_FLAG:

11,779,853✔

1210

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

11,779,853✔

1211

        break;

11,779,853✔

1212

      case REMOTE_VALUELIST_CODE_SUBQ_IDX:

11,779,853✔

1213

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

11,779,853✔

1214

        break;

11,779,853✔

1220

  return code;

11,779,853✔

1232

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

22,908,417✔

1233

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

22,908,417✔

1235

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

22,908,417✔

1236

  if (TSDB_CODE_SUCCESS == code) {

22,911,363✔

1237

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

22,911,363✔

1239

  if (TSDB_CODE_SUCCESS == code) {

22,911,363✔

1240

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

22,911,449✔

1242

  if (TSDB_CODE_SUCCESS == code) {

22,911,191✔

1243

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

22,911,277✔

1245

  if (TSDB_CODE_SUCCESS == code) {

22,911,535✔

1246

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

22,910,504✔

1248

  if (TSDB_CODE_SUCCESS == code) {

22,911,708✔

1249

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

22,910,507✔

1252

  return code;

22,911,279✔

1256

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

21,370,781✔

1257

  SRemoteRowNode* pNode = (SRemoteRowNode*)pObj;

21,370,781✔

1259

  int32_t code = TSDB_CODE_SUCCESS;

21,370,781✔

1260

  STlv*   pTlv = NULL;

21,370,781✔

1261

  tlvForEach(pDecoder, pTlv, code) {

149,595,467✔

1262

    switch (pTlv->type) {

128,224,686✔

1263

      case REMOTE_ROW_CODE_VAL:

21,370,781✔

1264

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

21,370,781✔

1265

        break;

21,370,781✔

1266

      case REMOTE_ROW_CODE_IS_MIN:

21,370,781✔

1267

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

21,370,781✔

1268

        break;

21,370,781✔

1269

      case REMOTE_ROW_CODE_VAL_SET:

21,370,781✔

1270

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

21,370,781✔

1271

        break;

21,370,781✔

1272

      case REMOTE_ROW_CODE_HAS_VALUE:

21,370,781✔

1273

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

21,370,781✔

1274

        break;

21,370,781✔

1275

      case REMOTE_ROW_CODE_HAS_NULL:

21,370,781✔

1276

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

21,370,781✔

1277

        break;

21,370,781✔

1278

      case REMOTE_ROW_CODE_SUBQ_IDX:

21,370,781✔

1279

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

21,370,781✔

1280

        break;

21,370,781✔

1286

  return code;

21,371,328✔

1289

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

1,310,309✔

1290

  return remoteValueNodeToMsg(pObj, pEncoder);

1,310,309✔

1294

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

382,995✔

1295

  return msgToRemoteValueNode(pDecoder, pObj);

382,995✔

1304

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

401,449✔

1305

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

401,449✔

1307

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

401,449✔

1308

  if (TSDB_CODE_SUCCESS == code) {

401,853✔

1309

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

401,853✔

1311

  if (TSDB_CODE_SUCCESS == code) {

401,853✔

1312

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

401,853✔

1315

  return code;

401,853✔

1320

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

398,164✔

1321

  SRemoteTableNode* pNode = (SRemoteTableNode*)pObj;

398,164✔

1323

  int32_t code = TSDB_CODE_SUCCESS;

398,164✔

1324

  STlv*   pTlv = NULL;

398,164✔

1325

  tlvForEach(pDecoder, pTlv, code) {

1,593,865✔

1326

    switch (pTlv->type) {

1,195,701✔

1327

      case REMOTE_TABLE_CODE_FLAG:

398,164✔

1328

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

398,164✔

1329

        break;

398,567✔

1330

      case REMOTE_TABLE_CODE_RES_COLS:

398,567✔

1331

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

398,567✔

1332

        break;

398,567✔

1333

      case REMOTE_TABLE_CODE_SUBQ_IDX:

398,970✔

1334

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

398,970✔

1335

        break;

398,567✔

1341

  return code;

398,567✔

1348

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

318,017,287✔

1349

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

318,017,287✔

1351

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

318,017,287✔

1352

  if (TSDB_CODE_SUCCESS == code) {

318,317,596✔

1353

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

318,318,157✔

1355

  if (TSDB_CODE_SUCCESS == code) {

318,270,623✔

1356

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

318,271,961✔

1358

  if (TSDB_CODE_SUCCESS == code) {

318,306,720✔

1359

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

318,308,227✔

1361

  if (TSDB_CODE_SUCCESS == code) {

318,253,439✔

1362

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

318,236,940✔

1365

  return code;

318,276,634✔

1368

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

262,397,451✔

1369

  SOperatorNode* pNode = (SOperatorNode*)pObj;

262,397,451✔

1371

  int32_t code = TSDB_CODE_SUCCESS;

262,397,451✔

1372

  STlv*   pTlv = NULL;

262,397,451✔

1373

  tlvForEach(pDecoder, pTlv, code) {

1,539,954,048✔

1374

    switch (pTlv->type) {

1,277,581,025✔

1375

      case OPERATOR_CODE_EXPR_BASE:

262,392,305✔

1376

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

262,392,305✔

1377

        break;

262,419,164✔

1378

      case OPERATOR_CODE_OP_TYPE:

262,421,856✔

1379

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

262,421,856✔

1380

        break;

262,412,020✔

1381

      case OPERATOR_CODE_FLAG:

262,401,291✔

1382

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

262,401,291✔

1383

        break;

262,416,937✔

1384

      case OPERATOR_CODE_LEFT:

262,421,884✔

1385

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

262,421,884✔

1386

        break;

262,395,066✔

1387

      case OPERATOR_CODE_RIGHT:

227,943,062✔

1388

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

227,943,062✔

1389

        break;

227,898,432✔

1395

  return code;

262,513,717✔

1400

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

48,310,903✔

1401

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

48,310,903✔

1403

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

48,310,903✔

1404

  if (TSDB_CODE_SUCCESS == code) {

48,375,763✔

1405

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

48,376,036✔

1407

  if (TSDB_CODE_SUCCESS == code) {

48,349,152✔

1408

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

48,349,158✔

1411

  return code;

48,381,803✔

1414

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

45,319,834✔

1415

  SLogicConditionNode* pNode = (SLogicConditionNode*)pObj;

45,319,834✔

1417

  int32_t code = TSDB_CODE_SUCCESS;

45,319,834✔

1418

  STlv*   pTlv = NULL;

45,319,834✔

1419

  tlvForEach(pDecoder, pTlv, code) {

181,302,374✔

1420

    switch (pTlv->type) {

135,985,114✔

1421

      case LOGIC_COND_CODE_EXPR_BASE:

45,322,241✔

1422

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

45,322,241✔

1423

        break;

45,327,683✔

1424

      case LOGIC_COND_CODE_COND_TYPE:

45,328,817✔

1425

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

45,328,817✔

1426

        break;

45,323,844✔

1427

      case LOGIC_COND_CODE_PARAMETERS:

45,333,678✔

1428

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

45,333,678✔

1429

        break;

45,328,557✔

1435

  return code;

45,335,353✔

1453

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

638,857,044✔

1454

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

638,857,044✔

1456

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

638,857,044✔

1457

  if (TSDB_CODE_SUCCESS == code) {

639,374,366✔

1458

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

639,385,709✔

1460

  if (TSDB_CODE_SUCCESS == code) {

639,388,610✔

1461

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

639,364,461✔

1463

  if (TSDB_CODE_SUCCESS == code) {

639,426,475✔

1464

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

639,403,450✔

1466

  if (TSDB_CODE_SUCCESS == code) {

639,440,766✔

1467

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

639,418,516✔

1469

  if (TSDB_CODE_SUCCESS == code) {

639,157,321✔

1470

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

639,134,915✔

1472

  if (TSDB_CODE_SUCCESS == code) {

639,421,439✔

1473

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

639,386,798✔

1475

  if (TSDB_CODE_SUCCESS == code) {

639,435,435✔

1476

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

639,401,136✔

1478

  if (TSDB_CODE_SUCCESS == code) {

639,441,625✔

1479

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

639,407,628✔

1481

  if (TSDB_CODE_SUCCESS == code) {

639,451,689✔

1482

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

639,418,028✔

1484

  if (TSDB_CODE_SUCCESS == code) {

639,455,558✔

1485

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

639,411,099✔

1487

  if (TSDB_CODE_SUCCESS == code) {

639,465,589✔

1488

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

639,422,353✔

1491

  return code;

639,205,914✔

1494

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

517,511,578✔

1495

  SFunctionNode* pNode = (SFunctionNode*)pObj;

517,511,578✔

1497

  int32_t code = TSDB_CODE_SUCCESS;

517,511,578✔

1498

  STlv*   pTlv = NULL;

517,511,578✔

1499

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

1500

    switch (pTlv->type) {

2,147,483,647✔

1501

      case FUNCTION_CODE_EXPR_BASE:

517,520,921✔

1502

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

517,520,921✔

1503

        break;

517,536,708✔

1504

      case FUNCTION_CODE_FUNCTION_NAME:

517,505,569✔

1505

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

517,505,569✔

1506

        break;

517,520,844✔

1507

      case FUNCTION_CODE_FUNCTION_ID:

517,546,538✔

1508

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

517,546,538✔

1509

        break;

517,539,623✔

1510

      case FUNCTION_CODE_FUNCTION_TYPE:

517,544,222✔

1511

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

517,544,222✔

1512

        break;

517,537,457✔

1513

      case FUNCTION_CODE_PARAMETERS:

423,298,688✔

1514

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

423,298,688✔

1515

        break;

423,298,214✔

1516

      case FUNCTION_CODE_UDF_BUF_SIZE:

517,528,595✔

1517

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

517,528,595✔

1518

        break;

517,536,843✔

1519

      case FUNCTION_NODE_HAS_PK:

517,542,779✔

1520

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

517,542,779✔

1521

        break;

517,533,494✔

1522

      case FUNCTION_NODE_PK_BYTES:

517,545,356✔

1523

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

517,545,356✔

1524

        break;

517,536,047✔

1525

      case FUNCTION_CODE_IS_MERGE_FUNC:

517,544,363✔

1526

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

517,544,363✔

1527

        break;

517,530,327✔

1528

      case FUNCTION_CODE_MERGE_FUNC_OF:

517,543,682✔

1529

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

517,543,682✔

1530

        break;

517,540,326✔

1531

      case FUNCTION_CODE_TRIM_TYPE:

517,540,880✔

1532

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

517,540,880✔

1533

        break;

517,533,570✔

1534

      case FUNCTION_SRC_FUNC_INPUT_TYPE:

517,539,917✔

1535

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

517,539,917✔

1536

      default:

517,530,424✔

1537

        break;

517,530,424✔

1541

  return code;

518,891,889✔

1546

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

93,786,831✔

1547

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

93,786,831✔

1549

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

93,786,831✔

1550

  if (TSDB_CODE_SUCCESS == code) {

93,823,434✔

1551

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

93,823,500✔

1553

  if (TSDB_CODE_SUCCESS == code) {

93,826,554✔

1554

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

93,825,358✔

1557

  return code;

93,825,610✔

1560

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

62,397,373✔

1561

  SOrderByExprNode* pNode = (SOrderByExprNode*)pObj;

62,397,373✔

1563

  int32_t code = TSDB_CODE_SUCCESS;

62,397,373✔

1564

  STlv*   pTlv = NULL;

62,397,373✔

1565

  tlvForEach(pDecoder, pTlv, code) {

249,618,711✔

1566

    switch (pTlv->type) {

187,214,974✔

1567

      case ORDER_BY_EXPR_CODE_EXPR:

62,397,416✔

1568

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

62,397,416✔

1569

        break;

62,405,611✔

1570

      case ORDER_BY_EXPR_CODE_ORDER:

62,405,611✔

1571

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

62,405,611✔

1572

        break;

62,405,611✔

1573

      case ORDER_BY_EXPR_CODE_NULL_ORDER:

62,411,006✔

1574

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

62,411,006✔

1575

        break;

62,405,611✔

1581

  return code;

62,412,920✔

1586

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

41,006,466✔

1587

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

41,006,466✔

1589

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

41,006,466✔

1590

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

41,051,613✔

1591

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

10,711,146✔

1594

  return code;

41,029,711✔

1597

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

34,770,341✔

1598

  SLimitNode* pNode = (SLimitNode*)pObj;

34,770,341✔

1600

  int32_t code = TSDB_CODE_SUCCESS;

34,770,341✔

1601

  STlv*   pTlv = NULL;

34,770,341✔

1602

  tlvForEach(pDecoder, pTlv, code) {

80,127,607✔

1603

    switch (pTlv->type) {

45,358,845✔

1604

      case LIMIT_CODE_LIMIT:

34,768,894✔

1605

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

34,768,894✔

1606

        break;

34,771,077✔

1607

      case LIMIT_CODE_OFFSET:

10,589,951✔

1608

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

10,589,951✔

1609

        break;

10,584,726✔

1615

  return code;

34,774,041✔

1620

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

438,809,007✔

1621

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

438,809,007✔

1623

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

438,809,007✔

1624

  if (TSDB_CODE_SUCCESS == code) {

439,441,568✔

1625

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

439,458,244✔

1627

  if (TSDB_CODE_SUCCESS == code) {

439,454,233✔

1628

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

439,365,555✔

1630

  if (TSDB_CODE_SUCCESS == code) {

439,245,855✔

1631

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

439,170,491✔

1634

  return code;

439,538,340✔

1637

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

313,825,415✔

1638

  SName* pNode = (SName*)pObj;

313,825,415✔

1640

  int32_t code = TSDB_CODE_SUCCESS;

313,825,415✔

1641

  STlv*   pTlv = NULL;

313,825,415✔

1642

  tlvForEach(pDecoder, pTlv, code) {

1,569,299,764✔

1643

    switch (pTlv->type) {

1,255,560,117✔

1644

      case NAME_CODE_TYPE:

313,837,675✔

1645

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

313,837,675✔

1646

        break;

313,861,953✔

1647

      case NAME_CODE_ACCT_ID:

313,893,376✔

1648

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

313,893,376✔

1649

        break;

313,880,404✔

1650

      case NAME_CODE_DB_NAME:

313,895,273✔

1651

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

313,895,273✔

1652

        break;

313,814,756✔

1653

      case NAME_CODE_TABLE_NAME:

313,924,769✔

1654

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

313,924,769✔

1655

        break;

313,887,819✔

1661

  return code;

313,934,856✔

1666

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

22,938,077✔

1667

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

22,938,077✔

1669

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

22,938,077✔

1670

  if (TSDB_CODE_SUCCESS == code) {

22,958,802✔

1671

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

22,958,102✔

1674

  return code;

22,962,571✔

1677

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

15,170,277✔

1678

  STimeWindow* pNode = (STimeWindow*)pObj;

15,170,277✔

1680

  int32_t code = TSDB_CODE_SUCCESS;

15,170,277✔

1681

  STlv*   pTlv = NULL;

15,170,277✔

1682

  tlvForEach(pDecoder, pTlv, code) {

45,515,399✔

1683

    switch (pTlv->type) {

30,345,837✔

1684

      case TIME_WINDOW_CODE_START_KEY:

15,172,042✔

1685

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

15,172,042✔

1686

        break;

15,171,507✔

1687

      case TIME_WINDOW_CODE_END_KEY:

15,173,795✔

1688

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

15,173,795✔

1689

        break;

15,173,108✔

1695

  return code;

15,173,084✔

1700

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

10,910,674✔

1701

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

10,910,674✔

1703

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

10,910,674✔

1704

  if (TSDB_CODE_SUCCESS == code) {

10,936,472✔

1705

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

10,936,472✔

1708

  return code;

10,935,318✔

1711

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

7,431,031✔

1712

  SNodeListNode* pNode = (SNodeListNode*)pObj;

7,431,031✔

1714

  int32_t code = TSDB_CODE_SUCCESS;

7,431,031✔

1715

  STlv*   pTlv = NULL;

7,431,031✔

1716

  tlvForEach(pDecoder, pTlv, code) {

22,295,363✔

1717

    switch (pTlv->type) {

14,862,241✔

1718

      case NODE_LIST_CODE_EXPR_BASE:

7,431,788✔

1719

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

7,431,788✔

1720

        break;

7,432,166✔

1721

      case NODE_LIST_CODE_NODE_LIST:

7,430,453✔

1722

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

7,430,453✔

1723

        break;

7,432,166✔

1729

  return code;

7,433,123✔

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,609,118,564✔

1833

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

1,609,118,564✔

1835

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

1,609,118,564✔

1836

  if (TSDB_CODE_SUCCESS == code) {

1,607,990,900✔

1837

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

1,608,024,525✔

1839

  if (TSDB_CODE_SUCCESS == code) {

1,610,266,209✔

1840

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

1,610,289,538✔

1842

  if (TSDB_CODE_SUCCESS == code) {

1,610,386,377✔

1843

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

1,610,419,650✔

1846

  return code;

1,610,476,887✔

1849

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

1,608,841,754✔

1850

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

1,608,841,754✔

1852

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

1,608,841,754✔

1853

  if (TSDB_CODE_SUCCESS == code) {

1,610,477,979✔

1854

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

1,610,494,827✔

1857

  return code;

1,610,670,473✔

1860

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

1,155,745,315✔

1861

  SDataBlockDescNode* pNode = (SDataBlockDescNode*)pObj;

1,155,745,315✔

1863

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

1,155,745,315✔

1864

  if (TSDB_CODE_SUCCESS == code) {

1,155,649,819✔

1865

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

1,155,705,687✔

1867

  if (TSDB_CODE_SUCCESS == code) {

1,155,798,641✔

1868

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

1,155,798,641✔

1870

  if (TSDB_CODE_SUCCESS == code) {

1,155,812,945✔

1871

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

1,155,812,945✔

1874

  return code;

1,155,736,048✔

1877

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

1,155,695,922✔

1878

  SDataBlockDescNode* pNode = (SDataBlockDescNode*)pObj;

1,155,695,922✔

1880

  int32_t code = TSDB_CODE_SUCCESS;

1,155,695,922✔

1881

  STlv*   pTlv = NULL;

1,155,695,922✔

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,155,851,312✔

1885

        code = tlvDecodeObjFromTlv(pTlv, msgToDataBlockDescNodeInline, pNode);

1,155,851,312✔

1886

        break;

1,155,738,759✔

1887

      case DATA_BLOCK_DESC_CODE_SLOTS:

1,155,831,709✔

1888

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

1,155,831,709✔

1889

        break;

1,155,776,168✔

1895

  return code;

1,155,854,264✔

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

704,470,297✔

1965

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

704,470,297✔

1967

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

704,470,297✔

1968

  if (TSDB_CODE_SUCCESS == code) {

704,969,129✔

1969

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

704,979,073✔

1972

  return code;

705,068,560✔

1975

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

45,282,911✔

1976

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

45,282,911✔

1978

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

45,282,911✔

1979

  if (TSDB_CODE_SUCCESS == code) {

45,340,738✔

1980

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

45,340,738✔

1983

  return code;

45,336,531✔

1986

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

511,315,185✔

1987

  SEp* pNode = (SEp*)pObj;

511,315,185✔

1989

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

511,315,185✔

1990

  if (TSDB_CODE_SUCCESS == code) {

511,397,449✔

1991

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

511,398,359✔

1994

  return code;

511,325,208✔

1997

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

28,744,511✔

1998

  SEp* pNode = (SEp*)pObj;

28,744,511✔

2000

  int32_t code = TSDB_CODE_SUCCESS;

28,744,511✔

2001

  STlv*   pTlv = NULL;

28,744,511✔

2002

  tlvForEach(pDecoder, pTlv, code) {

86,238,923✔

2003

    switch (pTlv->type) {

57,502,056✔

2004

      case EP_CODE_FQDN:

28,749,824✔

2005

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

28,749,824✔

2006

        break;

28,742,217✔

2007

      case EP_CODE_port:

28,752,232✔

2008

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

28,752,232✔

2009

        break;

28,749,834✔

2015

  return code;

28,754,872✔

2020

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

778,556,838✔

2021

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

778,556,838✔

2023

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

778,556,838✔

2024

  if (TSDB_CODE_SUCCESS == code) {

778,757,879✔

2025

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

778,778,631✔

2028

  return code;

778,926,190✔

2031

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

44,887,763✔

2032

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

44,887,763✔

2034

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

44,887,763✔

2035

  if (TSDB_CODE_SUCCESS == code) {

44,929,904✔

2036

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

44,930,434✔

2038

  if (TSDB_CODE_SUCCESS == code) {

44,930,129✔

2039

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

44,930,129✔

2042

  return code;

44,871,965✔

2045

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

566,362,964✔

2046

  SEpSet* pNode = (SEpSet*)pObj;

566,362,964✔

2048

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

566,362,964✔

2049

  if (TSDB_CODE_SUCCESS == code) {

566,414,158✔

2050

    int32_t numOfEps = 0;

566,410,157✔

2051

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

566,348,510✔

2052

    pNode->numOfEps = numOfEps;

566,363,886✔

2055

  return code;

566,361,970✔

2058

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

28,406,658✔

2059

  SEpSet* pNode = (SEpSet*)pObj;

28,406,658✔

2061

  int32_t code = TSDB_CODE_SUCCESS;

28,406,658✔

2062

  STlv*   pTlv = NULL;

28,406,658✔

2063

  tlvForEach(pDecoder, pTlv, code) {

113,635,513✔

2064

    switch (pTlv->type) {

85,234,285✔

2065

      case EP_SET_CODE_IN_USE:

28,407,691✔

2066

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

28,407,691✔

2067

        break;

28,408,286✔

2068

      case EP_SET_CODE_NUM_OF_EPS:

28,411,253✔

2069

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

28,411,253✔

2070

        break;

28,409,993✔

2071

      case EP_SET_CODE_EPS:

28,415,870✔

2072

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

28,415,870✔

2073

        break;

28,408,864✔

2079

  return code;

28,415,549✔

2084

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

778,544,823✔

2085

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

778,544,823✔

2087

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

778,544,823✔

2088

  if (TSDB_CODE_SUCCESS == code) {

778,803,418✔

2089

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

778,808,219✔

2092

  return code;

778,932,749✔

2106

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

566,360,949✔

2107

  SQueryNodeAddr* pNode = (SQueryNodeAddr*)pObj;

566,360,949✔

2109

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

566,360,949✔

2110

  if (TSDB_CODE_SUCCESS == code) {

566,419,069✔

2111

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

566,419,690✔

2114

  return code;

566,323,886✔

2138

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

255,863,187✔

2139

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

255,863,187✔

2141

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

255,863,187✔

2142

  if (TSDB_CODE_SUCCESS == code) {

255,868,091✔

2143

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

255,865,353✔

2145

  if (TSDB_CODE_SUCCESS == code) {

255,868,273✔

2146

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

255,868,352✔

2148

  if (TSDB_CODE_SUCCESS == code) {

255,868,593✔

2149

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

255,868,672✔

2151

  if (TSDB_CODE_SUCCESS == code) {

255,868,884✔

2152

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

255,867,761✔

2154

  if (TSDB_CODE_SUCCESS == code) {

255,870,217✔

2155

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

255,869,160✔

2158

  return code;

255,868,255✔

2161

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

255,865,279✔

2162

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

255,865,279✔

2165

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

193,656,524✔

2166

  SDownstreamSourceNode* pNode = (SDownstreamSourceNode*)pObj;

193,656,524✔

2168

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

193,656,524✔

2169

  if (TSDB_CODE_SUCCESS == code) {

193,657,726✔

2170

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

193,657,726✔

2172

  if (TSDB_CODE_SUCCESS == code) {

193,658,104✔

2173

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

193,658,104✔

2175

  if (TSDB_CODE_SUCCESS == code) {

193,656,490✔

2176

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

193,656,490✔

2178

  if (TSDB_CODE_SUCCESS == code) {

193,657,033✔

2179

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

193,657,033✔

2181

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

193,657,037✔

2182

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

193,657,037✔

2185

  return code;

193,658,104✔

2188

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

193,656,524✔

2189

  SDownstreamSourceNode* pNode = (SDownstreamSourceNode*)pObj;

193,656,524✔

2191

  int32_t code = TSDB_CODE_SUCCESS;

193,656,524✔

2192

  STlv*   pTlv = NULL;

193,656,524✔

2193

  tlvForEach(pDecoder, pTlv, code) {

387,315,171✔

2194

    switch (pTlv->type) {

193,656,524✔

2195

      case DOWNSTREAM_SOURCE_CODE_INLINE_ATTRS:

193,656,524✔

2196

        code = tlvDecodeObjFromTlv(pTlv, msgToDownstreamSourceNodeInlineToMsg, pNode);

193,656,524✔

2197

        break;

193,658,104✔

2203

  return code;

193,662,869✔

2208

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

7,073,246✔

2209

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

7,073,246✔

2211

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

7,073,246✔

2212

  if (TSDB_CODE_SUCCESS == code) {

7,074,028✔

2213

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

7,074,028✔

2215

  if (TSDB_CODE_SUCCESS == code) {

7,074,532✔

2216

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

7,074,532✔

2219

  return code;

7,074,452✔

2222

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

1,636,231✔

2223

  SWhenThenNode* pNode = (SWhenThenNode*)pObj;

1,636,231✔

2225

  int32_t code = TSDB_CODE_SUCCESS;

1,636,231✔

2226

  STlv*   pTlv = NULL;

1,636,231✔

2227

  tlvForEach(pDecoder, pTlv, code) {

6,544,924✔

2228

    switch (pTlv->type) {

4,908,693✔

2229

      case WHEN_THEN_CODE_EXPR_BASE:

1,636,231✔

2230

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

1,636,231✔

2231

        break;

1,636,231✔

2232

      case WHEN_THEN_CODE_WHEN:

1,636,231✔

2233

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

1,636,231✔

2234

        break;

1,636,231✔

2235

      case WHEN_THEN_CODE_THEN:

1,636,231✔

2236

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

1,636,231✔

2237

        break;

1,636,231✔

2243

  return code;

1,636,231✔

2248

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

6,930,427✔

2249

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

6,930,427✔

2251

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

6,930,427✔

2252

  if (TSDB_CODE_SUCCESS == code) {

6,931,904✔

2253

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

6,931,904✔

2255

  if (TSDB_CODE_SUCCESS == code) {

6,931,437✔

2256

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

6,931,173✔

2258

  if (TSDB_CODE_SUCCESS == code) {

6,932,168✔

2259

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

6,931,904✔

2262

  return code;

6,931,824✔

2265

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

1,494,374✔

2266

  SCaseWhenNode* pNode = (SCaseWhenNode*)pObj;

1,494,374✔

2268

  int32_t code = TSDB_CODE_SUCCESS;

1,494,374✔

2269

  STlv*   pTlv = NULL;

1,494,374✔

2270

  tlvForEach(pDecoder, pTlv, code) {

6,010,109✔

2271

    switch (pTlv->type) {

4,515,735✔

2272

      case CASE_WHEN_CODE_EXPR_BASE:

1,494,374✔

2273

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

1,494,374✔

2274

        break;

1,494,374✔

2275

      case CASE_WHEN_CODE_CASE:

137,547✔

2276

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

137,547✔

2277

        break;

137,547✔

2278

      case CASE_WHEN_CODE_ELSE:

1,389,440✔

2279

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

1,389,440✔

2280

        break;

1,389,440✔

2281

      case CASE_WHEN_CODE_WHEN_THEN_LIST:

1,494,374✔

2282

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

1,494,374✔

2283

        break;

1,494,374✔

2289

  return code;

1,494,374✔

2294

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

330,511✔

2295

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

330,511✔

2297

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

330,511✔

2298

  if (TSDB_CODE_SUCCESS == code) {

330,511✔

2299

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

330,511✔

2302

  return code;

330,511✔

2305

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

331,963✔

2306

  SWindowOffsetNode* pNode = (SWindowOffsetNode*)pObj;

331,963✔

2308

  int32_t code = TSDB_CODE_SUCCESS;

331,963✔

2309

  STlv*   pTlv = NULL;

331,963✔

2310

  tlvForEach(pDecoder, pTlv, code) {

995,889✔

2311

    switch (pTlv->type) {

663,926✔

2312

      case WINDOW_OFFSET_CODE_START_OFFSET:

331,963✔

2313

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

331,963✔

2314

        break;

331,963✔

2315

      case WINDOW_OFFSET_CODE_END_OFFSET:

331,963✔

2316

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

331,963✔

2317

        break;

331,963✔

2323

  return code;

331,963✔

2339

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

1,086,501,903✔

2340

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

1,086,501,903✔

2342

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

1,086,501,903✔

2343

  if (TSDB_CODE_SUCCESS == code) {

1,087,716,944✔

2344

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

1,087,345,219✔

2346

  if (TSDB_CODE_SUCCESS == code) {

1,087,642,344✔

2347

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

1,087,655,921✔

2349

  if (TSDB_CODE_SUCCESS == code) {

1,087,394,251✔

2350

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

1,087,418,435✔

2352

  if (TSDB_CODE_SUCCESS == code) {

1,087,086,729✔

2353

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

1,087,085,839✔

2355

  if (TSDB_CODE_SUCCESS == code) {

1,086,833,098✔

2356

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

1,086,845,001✔

2358

  if (TSDB_CODE_SUCCESS == code) {

1,086,236,702✔

2359

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

1,086,253,529✔

2361

  if (TSDB_CODE_SUCCESS == code) {

1,087,619,713✔

2362

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

1,087,640,998✔

2364

  if (TSDB_CODE_SUCCESS == code) {

1,087,782,578✔

2365

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

1,087,761,328✔

2368

  return code;

1,087,853,137✔

2371

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

782,857,766✔

2372

  SPhysiNode* pNode = (SPhysiNode*)pObj;

782,857,766✔

2374

  int32_t code = TSDB_CODE_SUCCESS;

782,857,766✔

2375

  STlv*   pTlv = NULL;

782,857,766✔

2376

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

2377

    switch (pTlv->type) {

2,147,483,647✔

2378

      case PHY_NODE_CODE_OUTPUT_DESC:

783,006,781✔

2379

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

783,006,781✔

2380

        break;

783,006,703✔

2381

      case PHY_NODE_CODE_CONDITIONS:

98,958,999✔

2382

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

98,958,999✔

2383

        break;

98,947,429✔

2384

      case PHY_NODE_CODE_CHILDREN:

359,128,484✔

2385

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

359,128,484✔

2386

        break;

359,154,363✔

2387

      case PHY_NODE_CODE_LIMIT:

31,932,727✔

2388

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

31,932,727✔

2389

        break;

31,931,633✔

2390

      case PHY_NODE_CODE_SLIMIT:

2,677,220✔

2391

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

2,677,220✔

2392

        break;

2,677,220✔

2393

      case PHY_NODE_CODE_INPUT_TS_ORDER:

783,035,326✔

2394

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

783,035,326✔

2395

        break;

783,043,656✔

2396

      case PHY_NODE_CODE_OUTPUT_TS_ORDER:

783,071,752✔

2397

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

783,071,752✔

2398

        break;

783,061,006✔

2399

      case PHY_NODE_CODE_DYNAMIC_OP:

783,072,222✔

2400

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

783,072,222✔

2401

        break;

783,053,028✔

2402

      case PHY_NODE_CODE_FORCE_NONBLOCKING_OPTR:

783,100,844✔

2403

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

783,100,844✔

2404

        break;

783,056,902✔

2410

  return code;

783,076,735✔

2425

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

438,693,649✔

2426

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

438,693,649✔

2428

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

438,693,649✔

2429

  if (TSDB_CODE_SUCCESS == code) {

439,442,271✔

2430

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

439,444,566✔

2432

  if (TSDB_CODE_SUCCESS == code) {

439,441,893✔

2433

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

439,396,462✔

2435

  if (TSDB_CODE_SUCCESS == code) {

439,464,800✔

2436

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

439,427,319✔

2438

  if (TSDB_CODE_SUCCESS == code) {

439,184,760✔

2439

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

439,149,246✔

2441

  if (TSDB_CODE_SUCCESS == code) {

439,540,035✔

2442

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

439,505,876✔

2444

  if (TSDB_CODE_SUCCESS == code) {

439,542,958✔

2445

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

439,432,338✔

2447

  if (TSDB_CODE_SUCCESS == code) {

438,964,882✔

2448

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

438,855,250✔

2450

  if (TSDB_CODE_SUCCESS == code) {

439,579,953✔

2451

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

439,471,860✔

2454

  return code;

439,531,587✔

2457

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

313,787,581✔

2458

  SScanPhysiNode* pNode = (SScanPhysiNode*)pObj;

313,787,581✔

2460

  int32_t code = TSDB_CODE_SUCCESS;

313,787,581✔

2461

  STlv*   pTlv = NULL;

313,787,581✔

2462

  tlvForEach(pDecoder, pTlv, code) {

2,147,483,647✔

2463

    switch (pTlv->type) {

2,147,483,647✔

2464

      case PHY_SCAN_CODE_BASE_NODE:

313,798,967✔

2465

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

313,798,967✔

2466

        break;

313,863,833✔

2467

      case PHY_SCAN_CODE_SCAN_COLS:

305,772,055✔

2468

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

305,772,055✔

2469

        break;

305,791,826✔

2470

      case PHY_SCAN_CODE_SCAN_PSEUDO_COLS:

76,470,955✔

2471

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

76,470,955✔

2472

        break;

76,473,411✔

2473

      case PHY_SCAN_CODE_BASE_UID:

313,891,423✔

2474

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

313,891,423✔

2475

        break;

313,864,234✔

2476

      case PHY_SCAN_CODE_BASE_SUID:

313,890,763✔

2477

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

313,890,763✔

2478

        break;

313,891,493✔

2479

      case PHY_SCAN_CODE_BASE_TABLE_TYPE:

313,893,932✔

2480

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

313,893,932✔

2481

        break;

313,893,557✔

2482

      case PHY_SCAN_CODE_BASE_TABLE_NAME:

313,893,306✔

2483

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

313,893,306✔

2484

        break;

313,881,400✔

2485

      case PHY_SCAN_CODE_BASE_GROUP_ORDER_SCAN:

313,893,469✔

2486

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

313,893,469✔

2487

        break;

313,885,395✔

2488

      case PHY_SCAN_CODE_BASE_VIRTUAL_STABLE_SCAN:

313,892,891✔

2489

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

313,892,891✔

2490

      default:

313,891,945✔

2491

        break;

313,891,945✔

2495

  return code;

314,092,153✔

2510

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

4,463,924✔

2511

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

4,463,924✔

2513

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

4,463,924✔

2515

  if (TSDB_CODE_SUCCESS == code) {

4,463,924✔

2516

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

4,463,924✔

2519

  if (TSDB_CODE_SUCCESS == code) {

4,463,924✔

2520

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

4,463,924✔

2523

  if (TSDB_CODE_SUCCESS == code) {

4,463,924✔

2524

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

4,463,924✔

2527

  if (TSDB_CODE_SUCCESS == code) {

4,463,924✔

2528

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

4,463,924✔

2531

  if (TSDB_CODE_SUCCESS == code) {

4,463,924✔

2532

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

4,463,924✔

2535

  if (TSDB_CODE_SUCCESS == code) {

4,463,924✔

2536

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

4,463,924✔

2539

  if (TSDB_CODE_SUCCESS == code) {

4,463,924✔

2540

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

4,463,924✔

2543

  if (TSDB_CODE_SUCCESS == code) {

4,463,924✔

2544

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

4,463,924✔

2547

  return code;

4,463,924✔

2550

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

4,060,966✔

2551

  SVirtualScanPhysiNode* pNode = (SVirtualScanPhysiNode*)pObj;

4,060,966✔

2553

  int32_t code = TSDB_CODE_SUCCESS;

4,060,966✔

2554

  STlv*   pTlv = NULL;

4,060,966✔

2555

  tlvForEach(pDecoder, pTlv, code) {

28,423,038✔

2556

    switch (pTlv->type) {

24,362,072✔

2557

      case PHY_VIRTUAL_TABLE_SCAN_CODE_SCAN:

4,060,966✔

2558

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

4,060,966✔

2559

        break;

4,060,966✔

2563

      case PHY_VIRTUAL_TABLE_SCAN_CODE_GROUP_SORT:

4,060,966✔

2564

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

4,060,966✔

2565

        break;

4,060,966✔

2566

      case PHY_VIRTUAL_TABLE_SCAN_CODE_ONLY_TS:

4,060,966✔

2567

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

4,060,966✔

2568

        break;

4,060,966✔

2569

      case PHY_VIRTUAL_TABLE_SCAN_CODE_TARGETS:

4,057,242✔

2570

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

4,057,242✔

2571

        break;

4,057,242✔

2578

      case PHY_VIRTUAL_TABLE_SCAN_CODE_IGNORE_EXPIRED:

4,060,966✔

2579

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

4,060,966✔

2580

        break;

4,060,966✔

2581

      case PHY_VIRTUAL_TABLE_SCAN_CODE_IGNORE_CHECK_UPDATE:

4,060,966✔

2582

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

4,060,966✔

2583

        break;

4,060,966✔

2589

  return code;

4,060,966✔

2597

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

14,345,732✔

2598

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

14,345,732✔

2600

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

14,345,732✔

2602

  if (TSDB_CODE_SUCCESS == code) {

14,379,358✔

2603

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

14,379,866✔

2605

  return code;

14,383,530✔

2608

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

8,117,869✔

2609

  STagScanPhysiNode* pNode = (STagScanPhysiNode*)pObj;

8,117,869✔

2611

  int32_t code = TSDB_CODE_SUCCESS;

8,117,869✔

2612

  STlv*   pTlv = NULL;

8,117,869✔

2613

  tlvForEach(pDecoder, pTlv, code) {

24,362,037✔

2614

    switch (pTlv->type) {

16,244,764✔

2615

      case PHY_TAG_SCAN_CODE_SCAN:

8,113,534✔

2616

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

8,113,534✔

2617

        break;

8,121,258✔

2618

      case PHY_TAG_SCAN_CODE_ONLY_META_CTB_IDX:

8,130,852✔

2619

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

8,130,852✔

2620

        break;

8,121,987✔

2626

  return code;

8,121,170✔

2638

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

1,850,374✔

2639

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

1,850,374✔

2641

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

1,850,374✔

2642

  if (TSDB_CODE_SUCCESS == code) {

1,857,056✔

2643

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

1,857,056✔

2645

  if (TSDB_CODE_SUCCESS == code) {

1,854,668✔

2646

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

1,854,705✔

2648

  if (TSDB_CODE_SUCCESS == code) {

1,857,176✔

2649

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

1,857,213✔

2651

  if (TSDB_CODE_SUCCESS == code) {

1,857,215✔

2652

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

1,857,252✔

2654

  if (TSDB_CODE_SUCCESS == code) {

1,855,517✔

2655

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

1,855,554✔

2658

  return code;

1,856,625✔

2661

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

1,849,951✔

2662

  SLastRowScanPhysiNode* pNode = (SLastRowScanPhysiNode*)pObj;

1,849,951✔

2664

  int32_t code = TSDB_CODE_SUCCESS;

1,849,951✔

2665

  STlv*   pTlv = NULL;

1,849,951✔

2666

  tlvForEach(pDecoder, pTlv, code) {

9,427,806✔

2667

    switch (pTlv->type) {

7,577,883✔

2668

      case PHY_LAST_ROW_SCAN_CODE_SCAN:

1,849,951✔

2669

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

1,849,951✔

2670

        break;

1,850,591✔

2671

      case PHY_LAST_ROW_SCAN_CODE_GROUP_TAGS:

205,025✔

2672

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

205,025✔

2673

        break;

205,025✔

2674

      case PHY_LAST_ROW_SCAN_CODE_GROUP_SORT:

1,850,591✔

2675

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

1,850,591✔

2676

        break;

1,850,591✔

2677

      case PHY_LAST_ROW_SCAN_CODE_IGNULL:

1,850,591✔

2678

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

1,850,591✔

2679

        break;

1,850,563✔

2680

      case PHY_LAST_ROW_SCAN_CODE_TARGETS:

1,821,085✔

2681

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

1,821,085✔

2682

        break;

1,821,085✔

2683

      case PHY_LAST_ROW_SCAN_CODE_FUNCTYPES:

640✔

2684

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

640✔

2692

  return code;

1,850,591✔

2708

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

378,024,199✔

2709

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

378,024,199✔

2711

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

378,024,199✔

2712

  if (TSDB_CODE_SUCCESS == code) {

378,067,807✔

2713

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

378,041,976✔

2715

  if (TSDB_CODE_SUCCESS == code) {

378,428,257✔

2716

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

378,365,820✔

2718

  if (TSDB_CODE_SUCCESS == code) {

378,461,002✔

2719

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

378,407,024✔

2721

  if (TSDB_CODE_SUCCESS == code) {

378,544,598✔

2722

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

378,492,042✔

2724

  if (TSDB_CODE_SUCCESS == code) {

377,743,324✔

2725

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

377,694,491✔

2727

  if (TSDB_CODE_SUCCESS == code) {

378,640,470✔

2728

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

378,487,313✔

2730

  if (TSDB_CODE_SUCCESS == code) {

378,674,690✔

2731

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

378,546,215✔

2733

  if (TSDB_CODE_SUCCESS == code) {

378,662,552✔

2734

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

378,536,893✔

2736

  if (TSDB_CODE_SUCCESS == code) {

378,746,516✔

2737

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

378,624,243✔

2739

  if (TSDB_CODE_SUCCESS == code) {

378,667,769✔

2740

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

378,461,253✔

2742

  if (TSDB_CODE_SUCCESS == code) {

378,754,520✔

2743

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

378,568,264✔

2745

  if (TSDB_CODE_SUCCESS == code) {

378,751,003✔

2746

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

378,572,376✔

2748

  if (TSDB_CODE_SUCCESS == code) {

378,805,925✔

2749

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

378,637,839✔

2751

  if (TSDB_CODE_SUCCESS == code) {

378,769,163✔

2752

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

378,491,392✔

2754

  if (TSDB_CODE_SUCCESS == code) {

378,768,873✔

2755

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

378,514,306✔

2757

  if (TSDB_CODE_SUCCESS == code) {

378,771,319✔

2758

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

378,527,123✔

2760

  if (TSDB_CODE_SUCCESS == code) {

378,765,819✔

2761

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

378,529,535✔

2763

  if (TSDB_CODE_SUCCESS == code) {

378,751,746✔

2764

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

378,393,258✔

2766

  if (TSDB_CODE_SUCCESS == code) {

378,950,869✔

2767

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

378,612,704✔

2769

  if (TSDB_CODE_SUCCESS == code) {

378,909,662✔

2770

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

378,578,042✔

2772

  return code;

378,649,315✔

2775

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

378,067,928✔

2776

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

378,067,928✔

2778

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

378,067,928✔

2779

  if (TSDB_CODE_SUCCESS == code) {

378,711,377✔

2780

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

378,716,359✔

2782

  if (TSDB_CODE_SUCCESS == code) {

378,632,419✔

2783

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

378,642,164✔

2785

  if (TSDB_CODE_SUCCESS == code) {

378,001,393✔

2786

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

378,010,957✔

2788

  if (TSDB_CODE_SUCCESS == code) {

378,263,132✔

2789

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

378,116,100✔

2791

  if (TSDB_CODE_SUCCESS == code) {

378,106,943✔

2792

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

378,026,175✔

2794

  if (TSDB_CODE_SUCCESS == code) {

377,903,637✔

2795

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

377,835,886✔

2797

  if (TSDB_CODE_SUCCESS == code) {

377,761,187✔

2798

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

377,699,894✔

2800

  if (TSDB_CODE_SUCCESS == code) {

377,571,358✔

2801

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

377,510,024✔

2803

  if (TSDB_CODE_SUCCESS == code) {

377,579,637✔

2804

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

377,519,598✔

2807

  return code;

377,499,723✔

2810

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

274,351,399✔

2811

  STableScanPhysiNode* pNode = (STableScanPhysiNode*)pObj;

274,351,399✔

2813

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

274,351,399✔

2814

  if (TSDB_CODE_SUCCESS == code) {

274,414,641✔

2815

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

274,415,039✔

2817

  if (TSDB_CODE_SUCCESS == code) {

274,372,402✔

2818

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

274,372,402✔

2820

  if (TSDB_CODE_SUCCESS == code) {

274,419,561✔

2821

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

274,419,561✔

2823

  if (TSDB_CODE_SUCCESS == code) {

274,355,802✔

2824

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

274,355,802✔

2826

  if (TSDB_CODE_SUCCESS == code) {

274,345,124✔

2827

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

274,345,124✔

2829

  if (TSDB_CODE_SUCCESS == code) {

274,350,413✔

2830

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

274,350,413✔

2832

  if (TSDB_CODE_SUCCESS == code) {

274,409,172✔

2833

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

274,409,172✔

2835

  if (TSDB_CODE_SUCCESS == code) {

274,358,822✔

2836

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

274,358,822✔

2838

  if (TSDB_CODE_SUCCESS == code) {

274,403,835✔

2839

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

274,403,835✔

2841

  if (TSDB_CODE_SUCCESS == code) {

274,356,843✔

2842

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

274,356,843✔

2844

  if (TSDB_CODE_SUCCESS == code) {

274,415,031✔

2845

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

274,415,031✔

2847

  if (TSDB_CODE_SUCCESS == code) {

274,354,941✔

2848

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

274,354,941✔

2850

  if (TSDB_CODE_SUCCESS == code) {

274,411,528✔

2851

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

274,411,528✔

2853

  if (TSDB_CODE_SUCCESS == code) {

274,352,036✔

2854

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

274,352,036✔

2856

  if (TSDB_CODE_SUCCESS == code) {

274,412,706✔

2857

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

274,412,706✔

2859

  if (TSDB_CODE_SUCCESS == code) {

274,339,160✔

2860

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

274,339,160✔

2862

  if (TSDB_CODE_SUCCESS == code) {

274,408,960✔

2863

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

274,408,960✔

2865

  if (TSDB_CODE_SUCCESS == code) {

274,352,396✔

2866

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

274,352,396✔

2868

  if (TSDB_CODE_SUCCESS == code) {

274,417,477✔

2869

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

274,417,477✔

2871

  if (TSDB_CODE_SUCCESS == code) {

274,348,975✔

2872

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

274,348,975✔

2874

  return code;

274,418,162✔

2877

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

274,351,953✔

2878

  STableScanPhysiNode* pNode = (STableScanPhysiNode*)pObj;

274,351,953✔

2880

  int32_t code = TSDB_CODE_SUCCESS;

274,351,953✔

2881

  STlv*   pTlv = NULL;

274,351,953✔

2882

  tlvForEach(pDecoder, pTlv, code) {

865,522,185✔

2883

    switch (pTlv->type) {

591,181,646✔

2884

      case PHY_TABLE_SCAN_CODE_SCAN:

274,318,601✔

2885

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

274,318,601✔

2886

        break;

274,392,629✔

2887

      case PHY_TABLE_SCAN_CODE_INLINE_ATTRS:

274,417,482✔

2888

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiTableScanNodeInline, pNode);

274,417,482✔

2889

        break;

274,415,210✔

2893

      case PHY_TABLE_SCAN_CODE_GROUP_TAGS:

37,999,866✔

2894

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

37,999,866✔

2895

        break;

38,014,413✔

2905

      case PHY_TABLE_SCAN_CODE_EXT_SCAN_RANGE:

3,686,769✔

2906

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

3,686,769✔

2907

        if (NULL == pNode->pExtScanRange) {

3,687,276✔

2911

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

3,687,276✔

2912

        break;

3,688,208✔

2916

      case PHY_TABLE_SCAN_CODE_PRIM_COND_EXPR:

752,188✔

2917

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

752,188✔

2918

        break;

638,352✔

2924

  return code;

274,442,654✔

2936

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

40,011,528✔

2937

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

40,011,528✔

2939

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

40,011,528✔

2940

  if (TSDB_CODE_SUCCESS == code) {

40,076,252✔

2941

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

40,076,252✔

2943

  if (TSDB_CODE_SUCCESS == code) {

40,030,845✔

2944

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

40,030,845✔

2946

  if (TSDB_CODE_SUCCESS == code) {

40,079,448✔

2947

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

40,079,448✔

2949

  if (TSDB_CODE_SUCCESS == code) {

40,078,039✔

2950

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

40,077,940✔

2952

  if (TSDB_CODE_SUCCESS == code) {

40,077,178✔

2953

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

40,077,079✔

2956

  return code;

40,077,850✔

2959

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

25,428,996✔

2960

  SSystemTableScanPhysiNode* pNode = (SSystemTableScanPhysiNode*)pObj;

25,428,996✔

2962

  int32_t code = TSDB_CODE_SUCCESS;

25,428,996✔

2963

  STlv*   pTlv = NULL;

25,428,996✔

2964

  tlvForEach(pDecoder, pTlv, code) {

178,007,580✔

2965

    switch (pTlv->type) {

152,586,301✔

2966

      case PHY_SYSTABLE_SCAN_CODE_SCAN:

25,426,634✔

2967

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

25,426,634✔

2968

        break;

25,428,449✔

2969

      case PHY_SYSTABLE_SCAN_CODE_MGMT_EP_SET:

25,430,887✔

2970

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

25,430,887✔

2971

        break;

25,430,710✔

2972

      case PHY_SYSTABLE_SCAN_CODE_SHOW_REWRITE:

25,428,501✔

2973

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

25,428,501✔

2974

        break;

25,424,855✔

2975

      case PHY_SYSTABLE_SCAN_CODE_ACCOUNT_ID:

25,430,713✔

2976

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

25,430,713✔

2977

        break;

25,431,336✔

2978

      case PHY_SYSTABLE_SCAN_CODE_SYS_INFO:

25,431,945✔

2979

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

25,431,945✔

2980

        break;

25,431,945✔

2981

      case PHY_SYSTABLE_SCAN_CODE_PRIV_INFO:

25,431,945✔

2982

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

25,431,945✔

2983

      default:

25,430,754✔

2984

        break;

25,430,754✔

2988

  return code;

25,433,065✔

2999

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

207,059,812✔

3000

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

207,059,812✔

3002

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

207,059,812✔

3003

  if (TSDB_CODE_SUCCESS == code) {

207,266,793✔

3004

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

207,270,596✔

3006

  if (TSDB_CODE_SUCCESS == code) {

207,260,742✔

3007

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

207,262,792✔

3009

  if (TSDB_CODE_SUCCESS == code) {

207,264,116✔

3010

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

207,267,462✔

3012

  if (TSDB_CODE_SUCCESS == code) {

207,263,416✔

3013

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

207,226,562✔

3016

  return code;

207,255,746✔

3019

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

146,488,396✔

3020

  SProjectPhysiNode* pNode = (SProjectPhysiNode*)pObj;

146,488,396✔

3022

  int32_t code = TSDB_CODE_SUCCESS;

146,488,396✔

3023

  STlv*   pTlv = NULL;

146,488,396✔

3024

  tlvForEach(pDecoder, pTlv, code) {

879,029,891✔

3025

    switch (pTlv->type) {

732,545,412✔

3026

      case PHY_PROJECT_CODE_BASE_NODE:

146,493,757✔

3027

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

146,493,757✔

3028

        break;

146,490,277✔

3029

      case PHY_PROJECT_CODE_PROJECTIONS:

146,507,261✔

3030

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

146,507,261✔

3031

        break;

146,510,292✔

3032

      case PHY_PROJECT_CODE_MERGE_DATA_BLOCK:

146,512,266✔

3033

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

146,512,266✔

3034

        break;

146,511,685✔

3035

      case PHY_PROJECT_CODE_IGNORE_GROUP_ID:

146,511,685✔

3036

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

146,511,685✔

3037

        break;

146,510,370✔

3038

      case PHY_PROJECT_CODE_INPUT_IGNORE_GROUP:

146,518,255✔

3039

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

146,518,255✔

3040

        break;

146,511,120✔

3046

  return code;

146,522,785✔

3073

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

15,856,105✔

3074

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

15,856,105✔

3076

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

15,856,105✔

3077

  if (TSDB_CODE_SUCCESS == code) {

15,856,748✔

3078

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

15,856,748✔

3080

  if (TSDB_CODE_SUCCESS == code) {

15,856,841✔

3081

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

15,856,675✔

3083

  if (TSDB_CODE_SUCCESS == code) {

15,856,748✔

3084

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

15,856,582✔

3086

  if (TSDB_CODE_SUCCESS == code) {

15,856,387✔

3087

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

15,856,221✔

3089

  if (TSDB_CODE_SUCCESS == code) {

15,856,387✔

3090

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

15,856,142✔

3092

  if (TSDB_CODE_SUCCESS == code) {

15,856,841✔

3093

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

15,856,513✔

3095

  if (TSDB_CODE_SUCCESS == code) {

15,855,976✔

3096

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

15,855,727✔

3098

  if (TSDB_CODE_SUCCESS == code) {

15,855,883✔

3099

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

15,855,634✔

3101

  if (TSDB_CODE_SUCCESS == code) {

15,856,997✔

3102

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

15,856,748✔

3104

  if (TSDB_CODE_SUCCESS == code) {

15,856,997✔

3105

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

15,856,748✔

3107

  if (TSDB_CODE_SUCCESS == code) {

15,856,470✔

3108

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

15,856,221✔

3110

  if (TSDB_CODE_SUCCESS == code) {

15,855,966✔

3111

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

15,855,717✔

3113

  if (TSDB_CODE_SUCCESS == code) {

15,856,997✔

3114

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

15,856,748✔

3116

  if (TSDB_CODE_SUCCESS == code) {

15,856,470✔

3117

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

15,856,059✔

3119

  if (TSDB_CODE_SUCCESS == code) {

15,857,252✔

3120

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

15,856,841✔

3122

  if (TSDB_CODE_SUCCESS == code) {

15,857,252✔

3123

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

15,856,841✔

3125

  if (TSDB_CODE_SUCCESS == code) {

15,857,186✔

3126

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

15,856,775✔

3128

  if (TSDB_CODE_SUCCESS == code) {

15,857,169✔

3129

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

15,856,841✔

3131

  if (TSDB_CODE_SUCCESS == code) {

15,857,169✔

3132

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

15,856,841✔

3134

  if (TSDB_CODE_SUCCESS == code) {

15,857,169✔

3135

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

15,856,841✔

3138

  return code;

15,856,841✔

3141

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

13,000,999✔

3142

  SSortMergeJoinPhysiNode* pNode = (SSortMergeJoinPhysiNode*)pObj;

13,000,999✔

3144

  int32_t code = TSDB_CODE_SUCCESS;

13,000,999✔

3145

  STlv*   pTlv = NULL;

13,000,999✔

3146

  tlvForEach(pDecoder, pTlv, code) {

191,303,808✔

3147

    switch (pTlv->type) {

178,302,809✔

3148

      case PHY_SORT_MERGE_JOIN_CODE_BASE_NODE:

13,000,497✔

3149

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

13,000,497✔

3150

        break;

13,000,999✔

3151

      case PHY_SORT_MERGE_JOIN_CODE_JOIN_TYPE:

13,000,999✔

3152

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

13,000,999✔

3153

        break;

13,000,999✔

3154

      case PHY_SORT_MERGE_JOIN_CODE_SUB_TYPE:

13,000,999✔

3155

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

13,000,999✔

3156

        break;

13,000,999✔

3157

      case PHY_SORT_MERGE_JOIN_CODE_WINDOW_OFFSET:

331,963✔

3158

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

331,963✔

3159

        break;

331,963✔

3160

      case PHY_SORT_MERGE_JOIN_CODE_JOIN_LIMIT:

163,067✔

3161

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

163,067✔

3162

        break;

163,067✔

3163

      case PHY_SORT_MERGE_JOIN_CODE_ASOF_OP:

13,000,999✔

3164

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

13,000,999✔

3165

        break;

13,000,999✔

3166

      case PHY_SORT_MERGE_JOIN_CODE_LEFT_PRIM_EXPR:

316,184✔

3167

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

316,184✔

3168

        break;

316,184✔

3169

      case PHY_SORT_MERGE_JOIN_CODE_RIGHT_PRIM_EXPR:

279,959✔

3170

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

279,959✔

3171

        break;

279,959✔

3172

      case PHY_SORT_MERGE_JOIN_CODE_LEFT_PRIM_SLOT_ID:

13,000,999✔

3173

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

13,000,999✔

3174

        break;

13,000,999✔

3175

      case PHY_SORT_MERGE_JOIN_CODE_RIGHT_PRIM_SLOT_ID:

13,000,999✔

3176

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

13,000,999✔

3177

        break;

13,000,999✔

3178

      case PHY_SORT_MERGE_JOIN_CODE_LEFT_EQ_COLS:

103,117✔

3179

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

103,117✔

3180

        break;

103,117✔

3181

      case PHY_SORT_MERGE_JOIN_CODE_RIGHT_EQ_COLS:

103,117✔

3182

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

103,117✔

3183

        break;

103,117✔

3184

      case PHY_SORT_MERGE_JOIN_CODE_COL_ON_CONDITIONS:

3,963,969✔

3185

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

3,963,969✔

3186

        break;

3,963,969✔

3187

      case PHY_SORT_MERGE_JOIN_CODE_FULL_ON_CONDITIONS:

4,028,446✔

3188

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

4,028,446✔

3189

        break;

4,028,446✔

3190

      case PHY_SORT_MERGE_JOIN_CODE_TARGETS:

13,000,999✔

3191

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

13,000,999✔

3192

        break;

13,000,999✔

3193

      case PHY_SORT_MERGE_JOIN_CODE_INPUT_ROW_NUM0:

13,000,999✔

3194

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

13,000,999✔

3195

        break;

13,000,999✔

3196

      case PHY_SORT_MERGE_JOIN_CODE_INPUT_ROW_NUM1:

13,000,999✔

3197

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

13,000,999✔

3198

        break;

13,000,999✔

3199

      case PHY_SORT_MERGE_JOIN_CODE_INPUT_ROW_SIZE0:

13,000,999✔

3200

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

13,000,999✔

3201

        break;

13,000,999✔

3202

      case PHY_SORT_MERGE_JOIN_CODE_INPUT_ROW_SIZE1:

13,000,999✔

3203

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

13,000,999✔

3204

        break;

13,000,999✔

3205

      case PHY_SORT_MERGE_JOIN_CODE_SEQ_WIN_GROUP:

13,000,999✔

3206

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

13,000,999✔

3207

        break;

13,000,999✔

3208

      case PHY_SORT_MERGE_JOIN_CODE_GROUP_JOIN:

13,000,975✔

3209

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

13,000,975✔

3210

        break;

13,000,999✔

3216

  return code;

13,000,999✔

3243

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

1,225,529✔

3244

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

1,225,529✔

3246

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

1,225,529✔

3247

  if (TSDB_CODE_SUCCESS == code) {

1,225,529✔

3248

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

1,225,529✔

3250

  if (TSDB_CODE_SUCCESS == code) {

1,225,529✔

3251

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

1,225,529✔

3253

  if (TSDB_CODE_SUCCESS == code) {

1,225,529✔

3254

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

1,225,529✔

3256

  if (TSDB_CODE_SUCCESS == code) {

1,225,529✔

3257

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

1,225,529✔

3259

  if (TSDB_CODE_SUCCESS == code) {

1,225,529✔

3260

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

1,225,529✔

3262

  if (TSDB_CODE_SUCCESS == code) {

1,225,529✔

3263

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

1,225,529✔

3265

  if (TSDB_CODE_SUCCESS == code) {

1,225,529✔

3266

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

1,225,529✔

3268

  if (TSDB_CODE_SUCCESS == code) {

1,225,529✔

3269

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

1,225,529✔

3271

  if (TSDB_CODE_SUCCESS == code) {

1,225,529✔

3272

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

1,225,529✔

3274

  if (TSDB_CODE_SUCCESS == code) {

1,225,529✔

3275

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

1,225,529✔

3277

  if (TSDB_CODE_SUCCESS == code) {

1,225,529✔

3278

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

1,225,529✔

3280

  if (TSDB_CODE_SUCCESS == code) {

1,225,529✔

3281

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

1,225,529✔

3283

  if (TSDB_CODE_SUCCESS == code) {

1,225,529✔

3284

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

1,225,529✔

3286

  if (TSDB_CODE_SUCCESS == code) {

1,225,529✔

3287

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

1,225,529✔

3289

  if (TSDB_CODE_SUCCESS == code) {

1,225,529✔

3290

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

1,225,529✔

3292

  if (TSDB_CODE_SUCCESS == code) {

1,225,529✔

3293

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

1,225,529✔

3295

  if (TSDB_CODE_SUCCESS == code) {

1,225,529✔

3296

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

1,225,529✔

3298

  if (TSDB_CODE_SUCCESS == code) {

1,225,529✔

3299

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

1,225,529✔

3301

  if (TSDB_CODE_SUCCESS == code) {

1,225,529✔

3302

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

1,225,529✔

3305

  return code;

1,225,529✔

3309

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

1,225,277✔

3310

  SHashJoinPhysiNode* pNode = (SHashJoinPhysiNode*)pObj;

1,225,277✔

3312

  int32_t code = TSDB_CODE_SUCCESS;

1,225,277✔

3313

  STlv*   pTlv = NULL;

1,225,277✔

3314

  tlvForEach(pDecoder, pTlv, code) {

19,604,432✔

3315

    switch (pTlv->type) {

18,379,155✔

3316

      case PHY_HASH_JOIN_CODE_BASE_NODE:

1,225,277✔

3317

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

1,225,277✔

3318

        break;

1,225,277✔

3319

      case PHY_HASH_JOIN_CODE_JOIN_TYPE:

1,225,277✔

3320

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

1,225,277✔

3321

        break;

1,225,277✔

3322

      case PHY_HASH_JOIN_CODE_JOIN_STYPE:

1,225,277✔

3323

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

1,225,277✔

3324

        break;

1,225,277✔

3325

      case PHY_HASH_JOIN_CODE_ON_LEFT_COLUMN:

1,225,277✔

3326

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

1,225,277✔

3327

        break;

1,225,277✔

3328

      case PHY_HASH_JOIN_CODE_ON_RIGHT_COLUMN:

1,225,277✔

3329

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

1,225,277✔

3330

        break;

1,225,277✔

3337

      case PHY_HASH_JOIN_CODE_LEFT_PRIM_SLOTID:

1,225,277✔

3338

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

1,225,277✔

3339

        break;

1,225,277✔

3340

      case PHY_HASH_JOIN_CODE_RIGHT_PRIM_SLOTID:

1,225,277✔

3341

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

1,225,277✔

3342

        break;

1,225,277✔

3343

      case PHY_HASH_JOIN_CODE_TIME_RANGE_TARGET:

1,225,277✔

3344

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

1,225,277✔

3345

        break;

1,225,277✔

3349

      case PHY_HASH_JOIN_CODE_TARGETS:

1,225,277✔

3350

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

1,225,277✔

3351

        break;

1,225,277✔

3352

      case PHY_HASH_JOIN_CODE_INPUT_ROW_NUM0:

1,225,277✔

3353

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

1,225,277✔

3354

        break;

1,225,277✔

3355

      case PHY_HASH_JOIN_CODE_INPUT_ROW_NUM1:

1,225,277✔

3356

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

1,225,277✔

3357

        break;

1,225,277✔

3358

      case PHY_HASH_JOIN_CODE_INPUT_ROW_SIZE0:

1,225,277✔

3359

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

1,225,277✔

3360

        break;

1,225,277✔

3361

      case PHY_HASH_JOIN_CODE_INPUT_ROW_SIZE1:

1,225,277✔

3362

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

1,225,277✔

3363

        break;

1,225,277✔

3370

      case PHY_HASH_JOIN_CODE_TIME_RANGE_SKEY:

1,225,277✔

3371

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

1,225,277✔

3372

        break;

1,225,277✔

3373

      case PHY_HASH_JOIN_CODE_TIME_RANGE_EKEY:

1,225,277✔

3374

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

1,225,277✔

3375

        break;

1,225,277✔

3381

  return code;

1,225,277✔

3395

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

159,447,745✔

3396

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

159,447,745✔

3398

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

159,447,745✔

3399

  if (TSDB_CODE_SUCCESS == code) {

159,648,666✔

3400

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

159,652,063✔

3402

  if (TSDB_CODE_SUCCESS == code) {

159,527,191✔

3403

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

159,506,065✔

3405

  if (TSDB_CODE_SUCCESS == code) {

159,507,673✔

3406

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

159,490,122✔

3408

  if (TSDB_CODE_SUCCESS == code) {

159,660,511✔

3409

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

159,643,092✔

3411

  if (TSDB_CODE_SUCCESS == code) {

159,680,623✔

3412

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

159,663,486✔

3414

  if (TSDB_CODE_SUCCESS == code) {

159,675,449✔

3415

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

159,650,843✔

3418

  return code;

159,658,744✔

3421

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

123,870,701✔

3422

  SAggPhysiNode* pNode = (SAggPhysiNode*)pObj;

123,870,701✔

3424

  int32_t code = TSDB_CODE_SUCCESS;

123,870,701✔

3425

  STlv*   pTlv = NULL;

123,870,701✔

3426

  tlvForEach(pDecoder, pTlv, code) {

778,704,639✔

3427

    switch (pTlv->type) {

654,822,446✔

3428

      case PHY_AGG_CODE_BASE_NODE:

123,864,349✔

3429

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

123,864,349✔

3430

        break;

123,890,247✔

3431

      case PHY_AGG_CODE_EXPR:

31,498,250✔

3432

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

31,498,250✔

3433

        break;

31,499,336✔

3434

      case PHY_AGG_CODE_GROUP_KEYS:

31,501,101✔

3435

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

31,501,101✔

3436

        break;

31,502,239✔

3437

      case PHY_AGG_CODE_AGG_FUNCS:

96,242,663✔

3438

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

96,242,663✔

3439

        break;

96,255,647✔

3440

      case PHY_AGG_CODE_MERGE_DATA_BLOCK:

123,893,846✔

3441

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

123,893,846✔

3442

        break;

123,893,397✔

3443

      case PHY_AGG_CODE_GROUP_KEY_OPTIMIZE:

123,893,874✔

3444

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

123,893,874✔

3445

        break;

123,892,856✔

3446

      case PHY_AGG_CODE_HAS_COUNT_LIKE_FUNCS:

123,923,003✔

3447

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

123,923,003✔

3448

        break;

123,892,352✔

3454

  return code;

123,908,881✔

3469

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

144,179,921✔

3470

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

144,179,921✔

3472

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

144,179,921✔

3473

  if (TSDB_CODE_SUCCESS == code) {

144,186,676✔

3474

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

144,186,676✔

3476

  if (TSDB_CODE_SUCCESS == code) {

144,185,933✔

3477

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

144,184,522✔

3479

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

144,187,730✔

3480

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

144,186,451✔

3482

  if (TSDB_CODE_SUCCESS == code) {

144,185,872✔

3483

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

144,184,686✔

3485

  if (TSDB_CODE_SUCCESS == code) {

144,187,777✔

3486

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

144,186,663✔

3488

  if (TSDB_CODE_SUCCESS == code) {

144,185,845✔

3489

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

144,185,373✔

3491

  if (TSDB_CODE_SUCCESS == code) {

144,186,437✔

3492

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

144,186,115✔

3494

  if (TSDB_CODE_SUCCESS == code) {

144,182,495✔

3495

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

144,182,173✔

3498

  return code;

144,186,295✔

3501

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

112,223,574✔

3502

  SExchangePhysiNode* pNode = (SExchangePhysiNode*)pObj;

112,223,574✔

3504

  int32_t code = TSDB_CODE_SUCCESS;

112,223,574✔

3505

  STlv*   pTlv = NULL;

112,223,574✔

3506

  tlvForEach(pDecoder, pTlv, code) {

1,122,233,049✔

3507

    switch (pTlv->type) {

1,010,011,080✔

3508

      case PHY_EXCHANGE_CODE_BASE_NODE:

112,223,574✔

3509

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

112,223,574✔

3510

        break;

112,222,500✔

3511

      case PHY_EXCHANGE_CODE_SRC_START_GROUP_ID:

112,223,574✔

3512

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

112,223,574✔

3513

        break;

112,223,574✔

3514

      case PHY_EXCHANGE_CODE_SRC_END_GROUP_ID:

112,223,574✔

3515

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

112,223,574✔

3516

        break;

112,223,574✔

3517

      case PHY_EXCHANGE_CODE_CHILDREN_VGIDS:

112,223,574✔

3518

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

112,223,574✔

3519

        break;

112,222,500✔

3520

      case PHY_EXCHANGE_CODE_SINGLE_CHANNEL:

112,223,574✔

3521

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

112,223,574✔

3522

        break;

112,223,574✔

3523

      case PHY_EXCHANGE_CODE_SRC_ENDPOINTS:

112,223,574✔

3524

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

112,223,574✔

3525

        break;

112,223,574✔

3526

      case PHY_EXCHANGE_CODE_SEQ_RECV_DATA:

112,223,574✔

3527

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

112,223,574✔

3528

        break;

112,223,574✔

3529

      case PHY_EXCHANGE_CODE_DYN_TBNAME:

112,223,574✔

3530

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

112,223,574✔

3531

        break;

112,223,031✔

3532

      case PHY_EXCHANGE_CODE_SINGLE_SOURCE:

112,221,945✔

3533

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

112,221,945✔

3534

        break;

112,223,574✔

3540

  return code;

112,229,198✔

3555

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

18,474,546✔

3556

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

18,474,546✔

3558

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

18,474,546✔

3559

  if (TSDB_CODE_SUCCESS == code) {

18,474,828✔

3560

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

18,474,828✔

3562

  if (TSDB_CODE_SUCCESS == code) {

18,474,828✔

3563

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

18,474,828✔

3565

  if (TSDB_CODE_SUCCESS == code) {

18,474,828✔

3566

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

18,474,828✔

3568

  if (TSDB_CODE_SUCCESS == code) {

18,474,828✔

3569

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

18,474,828✔

3571

  if (TSDB_CODE_SUCCESS == code) {

18,474,828✔

3572

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

18,474,828✔

3574

  if (TSDB_CODE_SUCCESS == code) {

18,474,828✔

3575

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

18,474,828✔

3577

  if (TSDB_CODE_SUCCESS == code) {

18,474,828✔

3578

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

18,474,828✔

3580

  if (TSDB_CODE_SUCCESS == code) {

18,474,828✔

3581

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

18,474,828✔

3584

  return code;

18,474,828✔

3587

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

14,022,957✔

3588

  SMergePhysiNode* pNode = (SMergePhysiNode*)pObj;

14,022,957✔

3590

  int32_t code = TSDB_CODE_SUCCESS;

14,022,957✔

3591

  STlv*   pTlv = NULL;

14,022,957✔

3592

  tlvForEach(pDecoder, pTlv, code) {

139,631,155✔

3593

    switch (pTlv->type) {

125,607,668✔

3594

      case PHY_MERGE_CODE_BASE_NODE:

14,022,053✔

3595

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

14,022,053✔

3596

        break;

14,023,488✔

3597

      case PHY_MERGE_CODE_MERGE_KEYS:

13,420,294✔

3598

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

13,420,294✔

3599

        break;

13,420,294✔

3600

      case PHY_MERGE_CODE_TARGETS:

14,023,488✔

3601

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

14,023,488✔

3602

        break;

14,023,488✔

3603

      case PHY_MERGE_CODE_NUM_OF_CHANNELS:

14,023,488✔

3604

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

14,023,488✔

3605

        break;

14,023,488✔

3606

      case PHY_MERGE_CODE_SRC_GROUP_ID:

14,023,488✔

3607

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

14,023,488✔

3608

        break;

14,023,488✔

3609

      case PHY_MERGE_CODE_GROUP_SORT:

14,023,488✔

3610

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

14,023,488✔

3611

        break;

14,023,488✔

3612

      case PHY_MERGE_CODE_IGNORE_GROUP_ID:

14,023,488✔

3613

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

14,023,488✔

3614

        break;

14,023,488✔

3615

      case PHY_MERGE_CODE_INPUT_WITH_GROUP_ID:

14,023,488✔

3616

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

14,023,488✔

3617

        break;

14,023,488✔

3618

      case PHY_MERGE_CODE_TYPE:

14,024,393✔

3619

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

14,024,393✔

3620

        break;

14,023,488✔

3626

  return code;

14,024,931✔

3638

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

54,079,422✔

3639

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

54,079,422✔

3641

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

54,079,422✔

3642

  if (TSDB_CODE_SUCCESS == code) {

54,113,997✔

3643

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

54,114,876✔

3645

  if (TSDB_CODE_SUCCESS == code) {

54,091,821✔

3646

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

54,080,287✔

3648

  if (TSDB_CODE_SUCCESS == code) {

54,127,907✔

3649

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

54,116,609✔

3651

  if (TSDB_CODE_SUCCESS == code) {

54,127,552✔

3652

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

54,116,320✔

3654

  if (TSDB_CODE_SUCCESS == code) {

54,127,744✔

3655

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

54,116,584✔

3658

  return code;

54,118,044✔

3661

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

33,786,365✔

3662

  SSortPhysiNode* pNode = (SSortPhysiNode*)pObj;

33,786,365✔

3664

  int32_t code = TSDB_CODE_SUCCESS;

33,786,365✔

3665

  STlv*   pTlv = NULL;

33,786,365✔

3666

  tlvForEach(pDecoder, pTlv, code) {

203,546,157✔

3667

    switch (pTlv->type) {

169,759,709✔

3668

      case PHY_SORT_CODE_BASE_NODE:

33,787,388✔

3669

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

33,787,388✔

3670

        break;

33,790,578✔

3671

      case PHY_SORT_CODE_EXPR:

803,414✔

3672

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

803,414✔

3673

        break;

803,414✔

3674

      case PHY_SORT_CODE_SORT_KEYS:

33,785,987✔

3675

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

33,785,987✔

3676

        break;

33,790,864✔

3677

      case PHY_SORT_CODE_TARGETS:

33,791,423✔

3678

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

33,791,423✔

3679

        break;

33,791,423✔

3680

      case PHY_SORT_CODE_CALC_GROUPID:

33,791,423✔

3681

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

33,791,423✔

3682

        break;

33,791,423✔

3683

      case PHY_SORT_CODE_EXCLUDE_PK_COL:

33,791,423✔

3684

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

33,791,423✔

3685

      default:

33,791,423✔

3686

        break;

33,791,423✔

3690

  return code;

33,791,616✔

3710

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

23,190,931✔

3711

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

23,190,931✔

3713

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

23,190,931✔

3714

  if (TSDB_CODE_SUCCESS == code) {

23,216,152✔

3715

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

23,216,152✔

3717

  if (TSDB_CODE_SUCCESS == code) {

23,205,506✔

3718

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

23,205,439✔

3720

  if (TSDB_CODE_SUCCESS == code) {

23,217,108✔

3721

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

23,217,041✔

3723

  if (TSDB_CODE_SUCCESS == code) {

23,215,468✔

3724

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

23,214,268✔

3726

  if (TSDB_CODE_SUCCESS == code) {

23,215,863✔

3727

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

23,215,195✔

3729

  if (TSDB_CODE_SUCCESS == code) {

23,217,271✔

3730

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

23,216,603✔

3732

  if (TSDB_CODE_SUCCESS == code) {

23,215,714✔

3733

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

23,215,046✔

3735

  if (TSDB_CODE_SUCCESS == code) {

23,216,336✔

3736

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

23,214,323✔

3738

  if (TSDB_CODE_SUCCESS == code) {

23,218,459✔

3739

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

23,216,597✔

3741

  if (TSDB_CODE_SUCCESS == code) {

23,219,928✔

3742

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

23,218,204✔

3744

  if (TSDB_CODE_SUCCESS == code) {

23,217,968✔

3745

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

23,216,324✔

3748

  return code;

23,210,066✔

3751

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

9,475,952✔

3752

  SWindowPhysiNode* pNode = (SWindowPhysiNode*)pObj;

9,475,952✔

3754

  int32_t code = TSDB_CODE_SUCCESS;

9,475,952✔

3755

  STlv*   pTlv = NULL;

9,475,952✔

3756

  tlvForEach(pDecoder, pTlv, code) {

96,192,223✔

3757

    switch (pTlv->type) {

86,718,110✔

3758

      case PHY_WINDOW_CODE_BASE_NODE:

9,474,874✔

3759

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

9,474,874✔

3760

        break;

9,477,995✔

3761

      case PHY_WINDOW_CODE_EXPR:

904,146✔

3762

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

904,146✔

3763

        break;

904,146✔

3764

      case PHY_WINDOW_CODE_FUNCS:

9,348,227✔

3765

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

9,348,227✔

3766

        break;

9,350,805✔

3767

      case PHY_WINDOW_CODE_TS_PK:

9,478,554✔

3768

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

9,478,554✔

3769

        break;

9,478,151✔

3770

      case PHY_WINDOW_CODE_TS_END:

585,551✔

3771

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

585,551✔

3772

        break;

585,551✔

3773

      case PHY_WINDOW_CODE_TRIGGER_TYPE:

9,478,554✔

3774

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

9,478,554✔

3775

        break;

9,478,554✔

3776

      case PHY_WINDOW_CODE_WATERMARK:

9,478,554✔

3777

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

9,478,554✔

3778

        break;

9,478,431✔

3779

      case PHY_WINDOW_CODE_DELETE_MARK:

9,478,554✔

3780

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

9,478,554✔

3781

        break;

9,477,160✔

3782

      case PHY_WINDOW_CODE_IG_EXPIRED:

9,478,554✔

3783

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

9,478,554✔

3784

        break;

9,478,554✔

3785

      case PHY_WINDOW_CODE_MERGE_DATA_BLOCK:

9,478,554✔

3786

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

9,478,554✔

3787

        break;

9,477,995✔

3788

      case PHY_WINDOW_CODE_INDEF_ROWS_FUNC:

9,478,554✔

3789

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

9,478,554✔

3790

        break;

9,478,554✔

3791

      case PHY_WINDOW_CODE_PROJS:

54,207✔

3792

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

54,207✔

3793

        break;

50,375✔

3799

  return code;

9,479,646✔

3804

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

13,488,646✔

3805

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

13,488,646✔

3807

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

13,488,646✔

3808

  if (TSDB_CODE_SUCCESS == code) {

13,500,983✔

3809

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

13,501,253✔

3811

  if (TSDB_CODE_SUCCESS == code) {

13,500,754✔

3812

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

13,498,951✔

3814

  if (TSDB_CODE_SUCCESS == code) {

13,504,083✔

3815

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

13,502,352✔

3817

  if (TSDB_CODE_SUCCESS == code) {

13,505,086✔

3818

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

13,503,493✔

3821

  return code;

13,501,099✔

3824

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

13,478,915✔

3825

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

13,478,915✔

3827

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

13,478,915✔

3828

  if (TSDB_CODE_SUCCESS == code) {

13,501,678✔

3829

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

13,503,398✔

3831

  if (TSDB_CODE_SUCCESS == code) {

13,499,168✔

3832

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

13,500,837✔

3835

  return code;

13,496,452✔

3838

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

5,740,200✔

3839

  SIntervalPhysiNode* pNode = (SIntervalPhysiNode*)pObj;

5,740,200✔

3841

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

5,740,200✔

3842

  if (TSDB_CODE_SUCCESS == code) {

5,741,191✔

3843

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

5,740,200✔

3845

  if (TSDB_CODE_SUCCESS == code) {

5,740,812✔

3846

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

5,740,812✔

3848

  if (TSDB_CODE_SUCCESS == code) {

5,740,812✔

3849

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

5,740,812✔

3851

  if (TSDB_CODE_SUCCESS == code) {

5,740,812✔

3852

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

5,740,812✔

3855

  return code;

5,740,812✔

3858

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

5,739,123✔

3859

  SIntervalPhysiNode* pNode = (SIntervalPhysiNode*)pObj;

5,739,123✔

3861

  int32_t code = TSDB_CODE_SUCCESS;

5,739,123✔

3862

  STlv*   pTlv = NULL;

5,739,123✔

3863

  tlvForEach(pDecoder, pTlv, code) {

22,961,850✔

3864

    switch (pTlv->type) {

17,223,573✔

3865

      case PHY_INTERVAL_CODE_WINDOW:

5,739,707✔

3866

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

5,739,707✔

3867

        break;

5,740,200✔

3868

      case PHY_INTERVAL_CODE_INLINE_ATTRS:

5,741,191✔

3869

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiIntervalNodeInline, pNode);

5,741,191✔

3870

        break;

5,740,812✔

3871

      case PHY_INTERVAL_CODE_TIME_RANGE:

5,741,191✔

3872

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

5,741,191✔

3873

      default:

5,741,191✔

3874

        break;

5,741,191✔

3878

  return code;

5,739,988✔

3895

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

497,491✔

3896

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

497,491✔

3898

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

497,491✔

3899

  if (TSDB_CODE_SUCCESS == code) {

499,457✔

3900

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

499,457✔

3902

  if (TSDB_CODE_SUCCESS == code) {

499,457✔

3903

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

499,457✔

3905

  if (TSDB_CODE_SUCCESS == code) {

499,457✔

3906

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

499,457✔

3908

  if (TSDB_CODE_SUCCESS == code) {

499,457✔

3909

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

499,457✔

3911

  if (TSDB_CODE_SUCCESS == code) {

499,457✔

3912

    code = tlvEncodeObj(pEncoder, PHY_FILL_CODE_VALUES, nodeToMsg, pNode->pValues);

499,457✔

3914

  if (TSDB_CODE_SUCCESS == code) {

499,457✔

3915

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

499,457✔

3917

  if (TSDB_CODE_SUCCESS == code) {

499,457✔

3918

    code = tlvEncodeObj(pEncoder, PHY_FILL_CODE_FILL_NULL_EXPRS, nodeListToMsg, pNode->pFillNullExprs);

499,457✔

3920

  if (TSDB_CODE_SUCCESS == code) {

499,457✔

3921

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

499,457✔

3923

  if (TSDB_CODE_SUCCESS == code) {

499,056✔

3924

    code = tlvEncodeObj(pEncoder, PHY_FILL_CODE_SURROUNDING_TIME, nodeToMsg,

498,639✔

3925

                        pNode->pSurroundingTime);

499,056✔

3927

  return code;

499,056✔

3930

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

494,431✔

3931

  SFillPhysiNode* pNode = (SFillPhysiNode*)pObj;

494,431✔

3933

  int32_t code = TSDB_CODE_SUCCESS;

494,431✔

3934

  STlv*   pTlv = NULL;

494,431✔

3935

  tlvForEach(pDecoder, pTlv, code) {

3,494,993✔

3936

    switch (pTlv->type) {

3,000,562✔

3937

      case PHY_FILL_CODE_BASE_NODE:

494,431✔

3938

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

494,431✔

3939

        break;

494,431✔

3940

      case PHY_FILL_CODE_MODE:

494,431✔

3941

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

494,431✔

3942

        break;

494,431✔

3943

      case PHY_FILL_CODE_FILL_EXPRS:

493,673✔

3944

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

493,673✔

3945

        break;

493,673✔

3946

      case PHY_FILL_CODE_NOT_FILL_EXPRS:

419,485✔

3947

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

419,485✔

3948

        break;

419,485✔

3949

      case PHY_FILL_CODE_WSTART:

494,431✔

3950

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

494,431✔

3951

        break;

494,431✔

3952

      case PHY_FILL_CODE_VALUES:

85,268✔

3953

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

85,268✔

3954

        break;

85,268✔

3955

      case PHY_FILL_CODE_TIME_RANGE:

494,030✔

3956

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

494,030✔

3957

        break;

494,431✔

3958

      case PHY_FILL_CODE_FILL_NULL_EXPRS:

18,727✔

3959

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

18,727✔

3960

        break;

18,727✔

3964

      case PHY_FILL_CODE_SURROUNDING_TIME:

6,086✔

3965

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

6,086✔

3966

        break;

5,685✔

3972

  return code;

494,431✔

3977

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

2,394,327✔

3978

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

2,394,327✔

3980

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

2,394,327✔

3981

  if (TSDB_CODE_SUCCESS == code) {

2,394,499✔

3982

    code = tlvEncodeI64(pEncoder, PHY_SESSION_CODE_GAP, pNode->gap);

2,394,499✔

3985

  return code;

2,394,499✔

3988

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

585,551✔

3989

  SSessionWinodwPhysiNode* pNode = (SSessionWinodwPhysiNode*)pObj;

585,551✔

3991

  int32_t code = TSDB_CODE_SUCCESS;

585,551✔

3992

  STlv*   pTlv = NULL;

585,551✔

3993

  tlvForEach(pDecoder, pTlv, code) {

1,756,653✔

3994

    switch (pTlv->type) {

1,171,102✔

3995

      case PHY_SESSION_CODE_WINDOW:

585,551✔

3996

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

585,551✔

3997

        break;

585,551✔

3998

      case PHY_SESSION_CODE_GAP:

585,551✔

3999

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

585,551✔

4000

        break;

585,551✔

4006

  return code;

585,551✔

4024

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

1,454,526✔

4025

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

1,454,526✔

4026

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

1,454,526✔

4027

  if (TSDB_CODE_SUCCESS == code) {

1,454,930✔

4028

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

1,454,930✔

4030

  if (TSDB_CODE_SUCCESS == code) {

1,454,930✔

4031

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

1,454,930✔

4033

  if (TSDB_CODE_SUCCESS == code) {

1,454,930✔

4034

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

1,454,930✔

4036

  if (TSDB_CODE_SUCCESS == code) {

1,454,526✔

4037

    code = tlvEncodeBool(pEncoder, PHY_EXT_CODE_IS_SINGLE_TABLE, pNode->isSingleTable);

1,454,526✔

4039

  if (TSDB_CODE_SUCCESS == code) {

1,454,930✔

4040

    code = tlvEncodeBool(pEncoder, PHY_EXT_CODE_INPUT_HAS_ORDER, pNode->inputHasOrder);

1,454,930✔

4042

  if (TSDB_CODE_SUCCESS == code) {

1,454,930✔

4043

    code = tlvEncodeI64(pEncoder, PHY_EXT_CODE_ORG_TABLE_UID, pNode->orgTableUid);

1,454,930✔

4045

  if (TSDB_CODE_SUCCESS == code) {

1,454,930✔

4046

    code = tlvEncodeI32(pEncoder, PHY_EXT_CODE_ORG_TABLE_VGID, pNode->orgTableVgId);

1,454,930✔

4048

  if (TSDB_CODE_SUCCESS == code) {

1,454,930✔

4049

    code = tlvEncodeBool(pEncoder, PHY_EXT_CODE_NEED_GROUP_SORT, pNode->needGroupSort);

1,454,930✔

4051

  if (TSDB_CODE_SUCCESS == code) {

1,454,930✔

4052

    code = tlvEncodeBool(pEncoder, PHY_EXT_CODE_CALC_WITH_PARTITION, pNode->calcWithPartition);

1,454,930✔

4054

  if (TSDB_CODE_SUCCESS == code) {

1,454,930✔

4055

    code = tlvEncodeBool(pEncoder, PHY_EXT_CODE_EXT_WIN_SPLIT, pNode->extWinSplit);

1,454,930✔

4057

  if (TSDB_CODE_SUCCESS == code) {

1,454,930✔

4058

    code = tlvEncodeObj(pEncoder, PHY_EXT_CODE_SUB_QUERY, nodeToMsg, pNode->pSubquery);

1,454,930✔

4061

  return code;

1,454,930✔

4064

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

1,436,826✔

4065

  SExternalWindowPhysiNode* pNode = (SExternalWindowPhysiNode*)pObj;

1,436,826✔

4067

  int32_t code = TSDB_CODE_SUCCESS;

1,436,826✔

4068

  STlv*   pTlv = NULL;

1,436,826✔

4069

  tlvForEach(pDecoder, pTlv, code) {

16,203,250✔

4070

    switch (pTlv->type) {

14,766,827✔

4071

      case PHY_EXT_CODE_WINDOW:

1,436,826✔

4072

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

1,436,826✔

4073

        break;

1,436,826✔

4074

      case PHY_EXT_CODE_SKEY:

1,436,423✔

4075

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

1,436,423✔

4076

        break;

1,436,826✔

4077

      case PHY_EXT_CODE_EKEY:

1,436,826✔

4078

        code = tlvDecodeI64(pTlv, &pNode->timeRange.ekey);

1,436,826✔

4079

        break;

1,436,826✔

4083

      case PHY_EXT_CODE_IS_SINGLE_TABLE:

1,436,826✔

4084

        code = tlvDecodeBool(pTlv, &pNode->isSingleTable);

1,436,826✔

4085

        break;

1,436,826✔

4086

      case PHY_EXT_CODE_INPUT_HAS_ORDER:

1,436,826✔

4087

        code = tlvDecodeBool(pTlv, &pNode->inputHasOrder);

1,436,826✔

4088

        break;

1,436,826✔

4089

      case PHY_EXT_CODE_ORG_TABLE_UID:

1,436,826✔

4090

        code = tlvDecodeI64(pTlv, &pNode->orgTableUid);

1,436,826✔

4091

        break;

1,436,826✔

4092

      case PHY_EXT_CODE_ORG_TABLE_VGID:

1,436,826✔

4093

        code = tlvDecodeI32(pTlv, &pNode->orgTableVgId);

1,436,826✔

4094

        break;

1,436,423✔

4095

      case PHY_EXT_CODE_NEED_GROUP_SORT:

1,436,826✔

4096

        code = tlvDecodeBool(pTlv, &pNode->needGroupSort);

1,436,826✔

4097

        break;

1,436,826✔

4098

      case PHY_EXT_CODE_CALC_WITH_PARTITION:

1,436,826✔

4099

        code = tlvDecodeBool(pTlv, &pNode->calcWithPartition);

1,436,826✔

4100

        break;

1,436,826✔

4101

      case PHY_EXT_CODE_EXT_WIN_SPLIT:

1,436,826✔

4102

        code = tlvDecodeBool(pTlv, &pNode->extWinSplit);

1,436,826✔

4103

        break;

1,436,826✔

4104

      case PHY_EXT_CODE_SUB_QUERY:

398,567✔

4105

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pSubquery);

398,567✔

4106

        break;

398,567✔

4111

  return code;

1,436,826✔

4116

static int32_t physiStateWindowNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,435,369✔

4117

  const SStateWindowPhysiNode* pNode = (const SStateWindowPhysiNode*)pObj;

2,435,369✔

4119

  int32_t code = tlvEncodeObj(pEncoder, PHY_STATE_CODE_WINDOW, physiWindowNodeToMsg, &pNode->window);

2,435,369✔

4120

  if (TSDB_CODE_SUCCESS == code) {

2,435,462✔

4121

    code = tlvEncodeObj(pEncoder, PHY_STATE_CODE_KEY, nodeToMsg, pNode->pStateKey);

2,435,462✔

4123

  if (TSDB_CODE_SUCCESS == code) {

2,435,462✔

4124

    code = tlvEncodeI32(pEncoder, PHY_STATE_CODE_TRUE_FOR_TYPE, pNode->trueForType);

2,435,462✔

4126

  if (TSDB_CODE_SUCCESS == code) {

2,435,462✔

4127

    code = tlvEncodeI32(pEncoder, PHY_STATE_CODE_TRUE_FOR_COUNT, pNode->trueForCount);

2,435,462✔

4129

  if (TSDB_CODE_SUCCESS == code) {

2,435,462✔

4130

    code = tlvEncodeI64(pEncoder, PHY_STATE_CODE_TRUE_FOR_DURATION, pNode->trueForDuration);

2,435,462✔

4132

  if (TSDB_CODE_SUCCESS == code) {

2,435,382✔

4133

    code = tlvEncodeI32(pEncoder, PHY_STATE_CODE_EXTEND_OPTION, pNode->extendOption);

2,435,382✔

4136

  return code;

2,435,462✔

4139

static int32_t msgToPhysiStateWindowNode(STlvDecoder* pDecoder, void* pObj) {

1,067,240✔

4140

  SStateWindowPhysiNode* pNode = (SStateWindowPhysiNode*)pObj;

1,067,240✔

4142

  int32_t code = TSDB_CODE_SUCCESS;

1,067,240✔

4143

  STlv*   pTlv = NULL;

1,067,240✔

4144

  tlvForEach(pDecoder, pTlv, code) {

7,470,680✔

4145

    switch (pTlv->type) {

6,403,440✔

4146

      case PHY_STATE_CODE_WINDOW:

1,067,240✔

4147

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiWindowNode, &pNode->window);

1,067,240✔

4148

        break;

1,067,240✔

4149

      case PHY_STATE_CODE_KEY:

1,067,240✔

4150

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pStateKey);

1,067,240✔

4151

        break;

1,067,240✔

4152

      case PHY_STATE_CODE_TRUE_FOR_TYPE:

1,067,240✔

4153

        code = tlvDecodeI32(pTlv, (int32_t*)&pNode->trueForType);

1,067,240✔

4154

        break;

1,067,240✔

4155

      case PHY_STATE_CODE_TRUE_FOR_COUNT:

1,067,240✔

4156

        code = tlvDecodeI32(pTlv, &pNode->trueForCount);

1,067,240✔

4157

        break;

1,067,240✔

4158

      case PHY_STATE_CODE_TRUE_FOR_DURATION:

1,067,240✔

4159

        code = tlvDecodeI64(pTlv, &pNode->trueForDuration);

1,067,240✔

4160

        break;

1,067,240✔

4161

      case PHY_STATE_CODE_EXTEND_OPTION:

1,067,240✔

4162

        code = tlvDecodeI32(pTlv, (int32_t*)&pNode->extendOption);

1,067,240✔

4163

      default:

1,067,240✔

4164

        break;

1,067,240✔

4168

  return code;

1,067,240✔

4173

static int32_t physiEventWindowNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

1,788,996✔

4174

  const SEventWinodwPhysiNode* pNode = (const SEventWinodwPhysiNode*)pObj;

1,788,996✔

4176

  int32_t code = tlvEncodeObj(pEncoder, PHY_EVENT_CODE_WINDOW, physiWindowNodeToMsg, &pNode->window);

1,788,996✔

4177

  if (TSDB_CODE_SUCCESS == code) {

1,790,334✔

4178

    code = tlvEncodeObj(pEncoder, PHY_EVENT_CODE_START_COND, nodeToMsg, pNode->pStartCond);

1,790,334✔

4180

  if (TSDB_CODE_SUCCESS == code) {

1,790,334✔

4181

    code = tlvEncodeObj(pEncoder, PHY_EVENT_CODE_END_COND, nodeToMsg, pNode->pEndCond);

1,790,334✔

4183

  if (TSDB_CODE_SUCCESS == code) {

1,790,334✔

4184

    code = tlvEncodeI32(pEncoder, PHY_EVENT_CODE_TRUE_FOR_TYPE, pNode->trueForType);

1,790,334✔

4186

  if (TSDB_CODE_SUCCESS == code) {

1,790,334✔

4187

    code = tlvEncodeI32(pEncoder, PHY_EVENT_CODE_TRUE_FOR_COUNT, pNode->trueForCount);

1,790,255✔

4189

  if (TSDB_CODE_SUCCESS == code) {

1,790,413✔

4190

    code = tlvEncodeI64(pEncoder, PHY_EVENT_CODE_TRUE_FOR_DURATION, pNode->trueForDuration);

1,790,334✔

4193

  return code;

1,790,334✔

4196

static int32_t msgToPhysiEventWindowNode(STlvDecoder* pDecoder, void* pObj) {

361,734✔

4197

  SEventWinodwPhysiNode* pNode = (SEventWinodwPhysiNode*)pObj;

361,734✔

4199

  int32_t code = TSDB_CODE_SUCCESS;

361,734✔

4200

  STlv*   pTlv = NULL;

361,734✔

4201

  tlvForEach(pDecoder, pTlv, code) {

2,532,138✔

4202

    switch (pTlv->type) {

2,170,404✔

4203

      case PHY_EVENT_CODE_WINDOW:

361,734✔

4204

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiWindowNode, &pNode->window);

361,734✔

4205

        break;

361,734✔

4206

      case PHY_EVENT_CODE_START_COND:

361,734✔

4207

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pStartCond);

361,734✔

4208

        break;

361,734✔

4209

      case PHY_EVENT_CODE_END_COND:

361,734✔

4210

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pEndCond);

361,734✔

4211

        break;

361,734✔

4212

      case PHY_EVENT_CODE_TRUE_FOR_TYPE:

361,734✔

4213

        code = tlvDecodeI32(pTlv, (int32_t *)&pNode->trueForType);

361,734✔

4214

        break;

361,734✔

4215

      case PHY_EVENT_CODE_TRUE_FOR_COUNT:

361,734✔

4216

        code = tlvDecodeI32(pTlv, &pNode->trueForCount);

361,734✔

4217

        break;

361,734✔

4218

      case PHY_EVENT_CODE_TRUE_FOR_DURATION:

361,734✔

4219

        code = tlvDecodeI64(pTlv, &pNode->trueForDuration);

361,734✔

4220

        break;

361,734✔

4226

  return code;

361,734✔

4231

static int32_t physiCountWindowNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

1,635,765✔

4232

  const SCountWindowPhysiNode* pNode = (const SCountWindowPhysiNode*)pObj;

1,635,765✔

4234

  int32_t code = tlvEncodeObj(pEncoder, PHY_COUNT_CODE_WINDOW, physiWindowNodeToMsg, &pNode->window);

1,635,765✔

4235

  if (TSDB_CODE_SUCCESS == code) {

1,637,304✔

4236

    code = tlvEncodeI64(pEncoder, PHY_COUNT_CODE_WINDOW_COUNT, pNode->windowCount);

1,637,304✔

4238

  if (TSDB_CODE_SUCCESS == code) {

1,637,304✔

4239

    code = tlvEncodeI64(pEncoder, PHY_COUNT_CODE_WINDOW_SLIDING, pNode->windowSliding);

1,637,221✔

4242

  return code;

1,637,304✔

4245

static int32_t msgToPhysiCountWindowNode(STlvDecoder* pDecoder, void* pObj) {

286,012✔

4246

  SCountWindowPhysiNode* pNode = (SCountWindowPhysiNode*)pObj;

286,012✔

4248

  int32_t code = TSDB_CODE_SUCCESS;

286,012✔

4249

  STlv*   pTlv = NULL;

286,012✔

4250

  tlvForEach(pDecoder, pTlv, code) {

1,144,048✔

4251

    switch (pTlv->type) {

858,036✔

4252

      case PHY_COUNT_CODE_WINDOW:

286,012✔

4253

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiWindowNode, &pNode->window);

286,012✔

4254

        break;

286,012✔

4255

      case PHY_COUNT_CODE_WINDOW_COUNT:

286,012✔

4256

        code = tlvDecodeI64(pTlv, &pNode->windowCount);

286,012✔

4257

        break;

286,012✔

4258

      case PHY_COUNT_CODE_WINDOW_SLIDING:

286,012✔

4259

        code = tlvDecodeI64(pTlv, &pNode->windowSliding);

286,012✔

4260

        break;

286,012✔

4266

  return code;

286,012✔

4318

static int32_t physiPartitionNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

10,484,999✔

4319

  const SPartitionPhysiNode* pNode = (const SPartitionPhysiNode*)pObj;

10,484,999✔

4321

  int32_t code = tlvEncodeObj(pEncoder, PHY_PARTITION_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

10,484,999✔

4322

  if (TSDB_CODE_SUCCESS == code) {

10,496,403✔

4323

    code = tlvEncodeObj(pEncoder, PHY_PARTITION_CODE_EXPR, nodeListToMsg, pNode->pExprs);

10,496,403✔

4325

  if (TSDB_CODE_SUCCESS == code) {

10,494,020✔

4326

    code = tlvEncodeObj(pEncoder, PHY_PARTITION_CODE_KEYS, nodeListToMsg, pNode->pPartitionKeys);

10,493,954✔

4328

  if (TSDB_CODE_SUCCESS == code) {

10,497,543✔

4329

    code = tlvEncodeObj(pEncoder, PHY_PARTITION_CODE_TARGETS, nodeListToMsg, pNode->pTargets);

10,497,543✔

4331

  if (TSDB_CODE_SUCCESS == code) {

10,497,878✔

4332

    code = tlvEncodeBool(pEncoder, PHY_PARTITION_CODE_HAS_OUTPUT_TS_ORDER, pNode->needBlockOutputTsOrder);

10,497,380✔

4334

  if (TSDB_CODE_SUCCESS == code) {

10,498,945✔

4335

    code = tlvEncodeI32(pEncoder, PHY_PARTITION_CODE_TS_SLOTID, pNode->tsSlotId);

10,498,519✔

4338

  return code;

10,498,288✔

4341

static int32_t msgToPhysiPartitionNode(STlvDecoder* pDecoder, void* pObj) {

3,021,094✔

4342

  SPartitionPhysiNode* pNode = (SPartitionPhysiNode*)pObj;

3,021,094✔

4344

  int32_t code = TSDB_CODE_SUCCESS;

3,021,094✔

4345

  STlv*   pTlv = NULL;

3,021,094✔

4346

  tlvForEach(pDecoder, pTlv, code) {

18,216,635✔

4347

    switch (pTlv->type) {

15,194,736✔

4348

      case PHY_PARTITION_CODE_BASE_NODE:

3,021,492✔

4349

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

3,021,492✔

4350

        break;

3,022,291✔

4351

      case PHY_PARTITION_CODE_EXPR:

84,086✔

4352

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pExprs);

84,086✔

4353

        break;

84,086✔

4354

      case PHY_PARTITION_CODE_KEYS:

3,021,890✔

4355

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pPartitionKeys);

3,021,890✔

4356

        break;

3,022,291✔

4357

      case PHY_PARTITION_CODE_TARGETS:

3,022,291✔

4358

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pTargets);

3,022,291✔

4359

        break;

3,022,291✔

4360

      case PHY_PARTITION_CODE_HAS_OUTPUT_TS_ORDER:

3,022,291✔

4361

        code = tlvDecodeBool(pTlv, &pNode->needBlockOutputTsOrder);

3,022,291✔

4362

        break;

3,022,291✔

4363

      case PHY_PARTITION_CODE_TS_SLOTID:

3,022,180✔

4364

        code = tlvDecodeI32(pTlv, &pNode->tsSlotId);

3,022,180✔

4365

        break;

3,022,291✔

4371

  return code;

3,024,062✔

4376

static int32_t physiIndefRowsFuncNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

3,197,371✔

4377

  const SIndefRowsFuncPhysiNode* pNode = (const SIndefRowsFuncPhysiNode*)pObj;

3,197,371✔

4379

  int32_t code = tlvEncodeObj(pEncoder, PHY_INDEF_ROWS_FUNC_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

3,197,371✔

4380

  if (TSDB_CODE_SUCCESS == code) {

3,198,657✔

4381

    code = tlvEncodeObj(pEncoder, PHY_INDEF_ROWS_FUNC_CODE_EXPRS, nodeListToMsg, pNode->pExprs);

3,198,657✔

4383

  if (TSDB_CODE_SUCCESS == code) {

3,199,035✔

4384

    code = tlvEncodeObj(pEncoder, PHY_INDEF_ROWS_FUNC_CODE_FUNCS, nodeListToMsg, pNode->pFuncs);

3,199,035✔

4387

  return code;

3,199,035✔

4390

static int32_t msgToPhysiIndefRowsFuncNode(STlvDecoder* pDecoder, void* pObj) {

3,172,195✔

4391

  SIndefRowsFuncPhysiNode* pNode = (SIndefRowsFuncPhysiNode*)pObj;

3,172,195✔

4393

  int32_t code = TSDB_CODE_SUCCESS;

3,172,195✔

4394

  STlv*   pTlv = NULL;

3,172,195✔

4395

  tlvForEach(pDecoder, pTlv, code) {

9,539,962✔

4396

    switch (pTlv->type) {

6,367,767✔

4397

      case PHY_INDEF_ROWS_FUNC_CODE_BASE_NODE:

3,171,664✔

4398

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

3,171,664✔

4399

        break;

3,172,195✔

4400

      case PHY_INDEF_ROWS_FUNC_CODE_EXPRS:

23,377✔

4401

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pExprs);

23,377✔

4402

        break;

23,377✔

4403

      case PHY_INDEF_ROWS_FUNC_CODE_FUNCS:

3,172,726✔

4404

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pFuncs);

3,172,726✔

4405

        break;

3,172,195✔

4411

  return code;

3,172,195✔

4428

static int32_t physiInterpFuncNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

3,447,009✔

4429

  const SInterpFuncPhysiNode* pNode = (const SInterpFuncPhysiNode*)pObj;

3,447,009✔

4431

  int32_t code = tlvEncodeObj(pEncoder, PHY_INERP_FUNC_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

3,447,009✔

4432

  if (TSDB_CODE_SUCCESS == code) {

3,447,431✔

4433

    code = tlvEncodeObj(pEncoder, PHY_INERP_FUNC_CODE_EXPR, nodeListToMsg, pNode->pExprs);

3,447,431✔

4435

  if (TSDB_CODE_SUCCESS == code) {

3,447,009✔

4436

    code = tlvEncodeObj(pEncoder, PHY_INERP_FUNC_CODE_FUNCS, nodeListToMsg, pNode->pFuncs);

3,447,009✔

4438

  if (TSDB_CODE_SUCCESS == code) {

3,447,431✔

4439

    code = tlvEncodeObj(pEncoder, PHY_INERP_FUNC_CODE_TIME_RANGE, timeWindowToMsg, &pNode->timeRange);

3,447,431✔

4441

  if (TSDB_CODE_SUCCESS == code) {

3,447,431✔

4442

    code = tlvEncodeObj(pEncoder, PHY_INERP_FUNC_CODE_TIME_RANGE_EXPR, nodeToMsg, pNode->pTimeRange);

3,447,431✔

4444

  if (TSDB_CODE_SUCCESS == code) {

3,447,009✔

4445

    code = tlvEncodeI64(pEncoder, PHY_INERP_FUNC_CODE_INTERVAL, pNode->interval);

3,447,009✔

4447

  if (TSDB_CODE_SUCCESS == code) {

3,447,431✔

4448

    code = tlvEncodeI8(pEncoder, PHY_INERP_FUNC_CODE_INTERVAL_UNIT, pNode->intervalUnit);

3,447,431✔

4450

  if (TSDB_CODE_SUCCESS == code) {

3,447,431✔

4451

    code = tlvEncodeEnum(pEncoder, PHY_INERP_FUNC_CODE_FILL_MODE, pNode->fillMode);

3,447,431✔

4453

  if (TSDB_CODE_SUCCESS == code) {

3,447,431✔

4454

    code = tlvEncodeObj(pEncoder, PHY_INERP_FUNC_CODE_FILL_VALUES, nodeToMsg, pNode->pFillValues);

3,447,431✔

4456

  if (TSDB_CODE_SUCCESS == code) {

3,447,431✔

4457

    code = tlvEncodeObj(pEncoder, PHY_INERP_FUNC_CODE_TIME_SERIES, nodeToMsg, pNode->pTimeSeries);

3,447,431✔

4459

  if (TSDB_CODE_SUCCESS == code) {

3,447,431✔

4460

    code = tlvEncodeI64(pEncoder, PHY_INTERP_FUNC_CODE_SURROUNDING_TIME, pNode->surroundingTime);

3,447,431✔

4463

  return code;

3,447,431✔

4466

static int32_t msgToPhysiInterpFuncNode(STlvDecoder* pDecoder, void* pObj) {

3,435,330✔

4467

  SInterpFuncPhysiNode* pNode = (SInterpFuncPhysiNode*)pObj;

3,435,330✔

4469

  int32_t code = TSDB_CODE_SUCCESS;

3,435,330✔

4470

  STlv*   pTlv = NULL;

3,435,330✔

4471

  tlvForEach(pDecoder, pTlv, code) {

32,667,122✔

4472

    switch (pTlv->type) {

29,231,285✔

4473

      case PHY_INERP_FUNC_CODE_BASE_NODE:

3,435,330✔

4474

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

3,435,330✔

4475

        break;

3,435,837✔

4476

      case PHY_INERP_FUNC_CODE_EXPR:

90,430✔

4477

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pExprs);

90,430✔

4478

        break;

90,430✔

4479

      case PHY_INERP_FUNC_CODE_FUNCS:

3,434,823✔

4480

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pFuncs);

3,434,823✔

4481

        break;

3,435,837✔

4482

      case PHY_INERP_FUNC_CODE_TIME_RANGE:

3,435,837✔

4483

        code = tlvDecodeObjFromTlv(pTlv, msgToTimeWindow, &pNode->timeRange);

3,435,837✔

4484

        break;

3,435,837✔

4488

      case PHY_INERP_FUNC_CODE_INTERVAL:

3,435,837✔

4489

        code = tlvDecodeI64(pTlv, &pNode->interval);

3,435,837✔

4490

        break;

3,435,837✔

4491

      case PHY_INERP_FUNC_CODE_INTERVAL_UNIT:

3,435,837✔

4492

        code = tlvDecodeI8(pTlv, &pNode->intervalUnit);

3,435,837✔

4493

        break;

3,435,837✔

4494

      case PHY_INERP_FUNC_CODE_FILL_MODE:

3,435,837✔

4495

        code = tlvDecodeEnum(pTlv, &pNode->fillMode, sizeof(pNode->fillMode));

3,435,837✔

4496

        break;

3,435,837✔

4497

      case PHY_INERP_FUNC_CODE_FILL_VALUES:

1,654,159✔

4498

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pFillValues);

1,654,159✔

4499

        break;

1,654,159✔

4500

      case PHY_INERP_FUNC_CODE_TIME_SERIES:

3,435,837✔

4501

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pTimeSeries);

3,435,837✔

4502

        break;

3,435,837✔

4503

      case PHY_INTERP_FUNC_CODE_SURROUNDING_TIME:

3,437,358✔

4504

        code = tlvDecodeI64(pTlv, &pNode->surroundingTime);

3,437,358✔

4505

        break;

3,435,837✔

4511

  return code;

3,436,344✔

4560

static int32_t physicDataSinkNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

522,366,218✔

4561

  const SDataSinkNode* pNode = (const SDataSinkNode*)pObj;

522,366,218✔

4562

  return tlvEncodeObj(pEncoder, PHY_DATA_SINK_CODE_INPUT_DESC, nodeToMsg, pNode->pInputDataBlockDesc);

522,366,218✔

4565

static int32_t msgToPhysicDataSinkNode(STlvDecoder* pDecoder, void* pObj) {

372,699,409✔

4566

  SDataSinkNode* pNode = (SDataSinkNode*)pObj;

372,699,409✔

4568

  int32_t code = TSDB_CODE_SUCCESS;

372,699,409✔

4569

  STlv*   pTlv = NULL;

372,699,409✔

4570

  tlvForEach(pDecoder, pTlv, code) {

745,509,901✔

4571

    switch (pTlv->type) {

372,784,378✔

4572

      case PHY_DATA_SINK_CODE_INPUT_DESC:

372,778,722✔

4573

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pInputDataBlockDesc);

372,778,722✔

4574

        break;

372,780,295✔

4580

  return code;

372,815,098✔

4586

static int32_t physiDispatchNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

520,051,153✔

4587

  const SDataDispatcherNode* pNode = (const SDataDispatcherNode*)pObj;

520,051,153✔

4588

  int32_t                    code = tlvEncodeObj(pEncoder, PHY_DISPATCH_CODE_SINK, physicDataSinkNodeToMsg, &pNode->sink);

520,051,153✔

4589

  if (TSDB_CODE_SUCCESS == code) {

520,834,416✔

4590

    code = tlvEncodeBool(pEncoder, PHY_DISPATCH_DYNAMIC_SCHEMA, pNode->dynamicSchema);

520,839,827✔

4592

  return code;

520,912,801✔

4595

static int32_t msgToPhysiDispatchNode(STlvDecoder* pDecoder, void* pObj) {

370,370,911✔

4596

  SDataDispatcherNode* pNode = (SDataDispatcherNode*)pObj;

370,370,911✔

4598

  int32_t code = TSDB_CODE_SUCCESS;

370,370,911✔

4599

  STlv*   pTlv = NULL;

370,370,911✔

4600

  tlvForEach(pDecoder, pTlv, code) {

1,111,289,674✔

4601

    switch (pTlv->type) {

740,880,484✔

4602

      case PHY_DISPATCH_CODE_SINK:

370,428,225✔

4603

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysicDataSinkNode, &pNode->sink);

370,428,225✔

4604

        break;

370,440,843✔

4605

      case PHY_DISPATCH_DYNAMIC_SCHEMA:

370,451,404✔

4606

        code = tlvDecodeBool(pTlv, &pNode->dynamicSchema);

370,451,404✔

4607

        break;

370,445,700✔

4613

  return code;

370,478,715✔

4628

static int32_t physiQueryInsertNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

523,837✔

4629

  const SQueryInserterNode* pNode = (const SQueryInserterNode*)pObj;

523,837✔

4631

  int32_t code = tlvEncodeObj(pEncoder, PHY_QUERY_INSERT_CODE_SINK, physicDataSinkNodeToMsg, &pNode->sink);

523,837✔

4632

  if (TSDB_CODE_SUCCESS == code) {

523,837✔

4633

    code = tlvEncodeObj(pEncoder, PHY_QUERY_INSERT_CODE_COLS, nodeListToMsg, pNode->pCols);

523,837✔

4635

  if (TSDB_CODE_SUCCESS == code) {

523,837✔

4636

    code = tlvEncodeU64(pEncoder, PHY_QUERY_INSERT_CODE_TABLE_ID, pNode->tableId);

523,837✔

4638

  if (TSDB_CODE_SUCCESS == code) {

523,837✔

4639

    code = tlvEncodeU64(pEncoder, PHY_QUERY_INSERT_CODE_STABLE_ID, pNode->stableId);

523,837✔

4641

  if (TSDB_CODE_SUCCESS == code) {

523,837✔

4642

    code = tlvEncodeI8(pEncoder, PHY_QUERY_INSERT_CODE_TABLE_TYPE, pNode->tableType);

523,837✔

4644

  if (TSDB_CODE_SUCCESS == code) {

523,837✔

4645

    code = tlvEncodeCStr(pEncoder, PHY_QUERY_INSERT_CODE_TABLE_NAME, pNode->tableName);

523,837✔

4647

  if (TSDB_CODE_SUCCESS == code) {

523,837✔

4648

    code = tlvEncodeI32(pEncoder, PHY_QUERY_INSERT_CODE_VG_ID, pNode->vgId);

523,837✔

4650

  if (TSDB_CODE_SUCCESS == code) {

523,837✔

4651

    code = tlvEncodeObj(pEncoder, PHY_QUERY_INSERT_CODE_EP_SET, epSetToMsg, &pNode->epSet);

523,837✔

4653

  if (TSDB_CODE_SUCCESS == code) {

523,837✔

4654

    code = tlvEncodeBool(pEncoder, PHY_QUERY_INSERT_CODE_EXPLAIN, pNode->explain);

523,837✔

4657

  return code;

523,837✔

4660

static int32_t msgToPhysiQueryInsertNode(STlvDecoder* pDecoder, void* pObj) {

523,249✔

4661

  SQueryInserterNode* pNode = (SQueryInserterNode*)pObj;

523,249✔

4663

  int32_t code = TSDB_CODE_SUCCESS;

523,249✔

4664

  STlv*   pTlv = NULL;

523,249✔

4665

  tlvForEach(pDecoder, pTlv, code) {

5,232,490✔

4666

    switch (pTlv->type) {

4,709,241✔

4667

      case PHY_QUERY_INSERT_CODE_SINK:

523,249✔

4668

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysicDataSinkNode, &pNode->sink);

523,249✔

4669

        break;

523,249✔

4670

      case PHY_QUERY_INSERT_CODE_COLS:

523,249✔

4671

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pCols);

523,249✔

4672

        break;

523,249✔

4673

      case PHY_QUERY_INSERT_CODE_TABLE_ID:

523,249✔

4674

        code = tlvDecodeU64(pTlv, &pNode->tableId);

523,249✔

4675

        break;

523,249✔

4676

      case PHY_QUERY_INSERT_CODE_STABLE_ID:

523,249✔

4677

        code = tlvDecodeU64(pTlv, &pNode->stableId);

523,249✔

4678

        break;

523,249✔

4679

      case PHY_QUERY_INSERT_CODE_TABLE_TYPE:

523,249✔

4680

        code = tlvDecodeI8(pTlv, &pNode->tableType);

523,249✔

4681

        break;

523,249✔

4682

      case PHY_QUERY_INSERT_CODE_TABLE_NAME:

523,249✔

4683

        code = tlvDecodeCStr(pTlv, pNode->tableName, sizeof(pNode->tableName));

523,249✔

4684

        break;

523,249✔

4685

      case PHY_QUERY_INSERT_CODE_VG_ID:

523,249✔

4686

        code = tlvDecodeI32(pTlv, &pNode->vgId);

523,249✔

4687

        break;

523,249✔

4688

      case PHY_QUERY_INSERT_CODE_EP_SET:

523,249✔

4689

        code = tlvDecodeObjFromTlv(pTlv, msgToEpSet, &pNode->epSet);

523,249✔

4690

        break;

523,249✔

4691

      case PHY_QUERY_INSERT_CODE_EXPLAIN:

523,249✔

4692

        code = tlvDecodeBool(pTlv, &pNode->explain);

523,249✔

4693

        break;

523,249✔

4699

  return code;

523,249✔

4714

static int32_t physiDeleteNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

1,813,395✔

4715

  const SDataDeleterNode* pNode = (const SDataDeleterNode*)pObj;

1,813,395✔

4717

  int32_t code = tlvEncodeObj(pEncoder, PHY_DELETER_CODE_SINK, physicDataSinkNodeToMsg, &pNode->sink);

1,813,395✔

4718

  if (TSDB_CODE_SUCCESS == code) {

1,813,395✔

4719

    code = tlvEncodeU64(pEncoder, PHY_DELETER_CODE_TABLE_ID, pNode->tableId);

1,813,395✔

4721

  if (TSDB_CODE_SUCCESS == code) {

1,813,395✔

4722

    code = tlvEncodeI8(pEncoder, PHY_DELETER_CODE_TABLE_TYPE, pNode->tableType);

1,813,395✔

4724

  if (TSDB_CODE_SUCCESS == code) {

1,813,395✔

4725

    code = tlvEncodeCStr(pEncoder, PHY_DELETER_CODE_TABLE_FNAME, pNode->tableFName);

1,813,395✔

4727

  if (TSDB_CODE_SUCCESS == code) {

1,813,395✔

4728

    code = tlvEncodeCStr(pEncoder, PHY_DELETER_CODE_TS_COL_NAME, pNode->tsColName);

1,813,395✔

4730

  if (TSDB_CODE_SUCCESS == code) {

1,813,395✔

4731

    code = tlvEncodeObj(pEncoder, PHY_DELETER_CODE_DELETE_TIME_RANGE, timeWindowToMsg, &pNode->deleteTimeRange);

1,813,395✔

4733

  if (TSDB_CODE_SUCCESS == code) {

1,813,395✔

4734

    code = tlvEncodeObj(pEncoder, PHY_DELETER_CODE_AFFECTED_ROWS, nodeToMsg, pNode->pAffectedRows);

1,813,395✔

4736

  if (TSDB_CODE_SUCCESS == code) {

1,813,395✔

4737

    code = tlvEncodeObj(pEncoder, PHY_DELETER_CODE_START_TS, nodeToMsg, pNode->pStartTs);

1,813,395✔

4739

  if (TSDB_CODE_SUCCESS == code) {

1,813,395✔

4740

    code = tlvEncodeObj(pEncoder, PHY_DELETER_CODE_END_TS, nodeToMsg, pNode->pEndTs);

1,813,395✔

4743

  return code;

1,813,395✔

4746

static int32_t msgToPhysiDeleteNode(STlvDecoder* pDecoder, void* pObj) {

1,813,441✔

4747

  SDataDeleterNode* pNode = (SDataDeleterNode*)pObj;

1,813,441✔

4749

  int32_t code = TSDB_CODE_SUCCESS;

1,813,441✔

4750

  STlv*   pTlv = NULL;

1,813,441✔

4751

  tlvForEach(pDecoder, pTlv, code) {

18,134,410✔

4752

    switch (pTlv->type) {

16,320,969✔

4753

      case PHY_DELETER_CODE_SINK:

1,813,441✔

4754

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysicDataSinkNode, &pNode->sink);

1,813,441✔

4755

        break;

1,813,441✔

4756

      case PHY_DELETER_CODE_TABLE_ID:

1,813,441✔

4757

        code = tlvDecodeU64(pTlv, &pNode->tableId);

1,813,441✔

4758

        break;

1,813,441✔

4759

      case PHY_DELETER_CODE_TABLE_TYPE:

1,813,441✔

4760

        code = tlvDecodeI8(pTlv, &pNode->tableType);

1,813,441✔

4761

        break;

1,813,441✔

4762

      case PHY_DELETER_CODE_TABLE_FNAME:

1,813,441✔

4763

        code = tlvDecodeCStr(pTlv, pNode->tableFName, sizeof(pNode->tableFName));

1,813,441✔

4764

        break;

1,813,441✔

4765

      case PHY_DELETER_CODE_TS_COL_NAME:

1,813,441✔

4766

        code = tlvDecodeCStr(pTlv, pNode->tsColName, sizeof(pNode->tsColName));

1,813,441✔

4767

        break;

1,813,441✔

4768

      case PHY_DELETER_CODE_DELETE_TIME_RANGE:

1,813,441✔

4769

        code = tlvDecodeObjFromTlv(pTlv, msgToTimeWindow, &pNode->deleteTimeRange);

1,813,441✔

4770

        break;

1,813,441✔

4771

      case PHY_DELETER_CODE_AFFECTED_ROWS:

1,813,441✔

4772

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pAffectedRows);

1,813,441✔

4773

        break;

1,813,441✔

4774

      case PHY_DELETER_CODE_START_TS:

1,813,441✔

4775

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pStartTs);

1,813,441✔

4776

        break;

1,813,441✔

4777

      case PHY_DELETER_CODE_END_TS:

1,813,441✔

4778

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pEndTs);

1,813,441✔

4779

        break;

1,813,441✔

4785

  return code;

1,813,441✔

4797

static int32_t physiGroupCacheNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

1,224,721✔

4798

  const SGroupCachePhysiNode* pNode = (const SGroupCachePhysiNode*)pObj;

1,224,721✔

4800

  int32_t code = tlvEncodeObj(pEncoder, PHY_GROUP_CACHE_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

1,224,721✔

4801

  if (TSDB_CODE_SUCCESS == code) {

1,224,721✔

4802

    code = tlvEncodeObj(pEncoder, PHY_GROUP_CACHE_CODE_GROUP_COLUMNS, nodeListToMsg, pNode->pGroupCols);

1,224,721✔

4804

  if (TSDB_CODE_SUCCESS == code) {

1,224,721✔

4805

    code = tlvEncodeBool(pEncoder, PHY_GROUP_CACHE_CODE_GROUP_COLS_MAY_BE_NULL, pNode->grpColsMayBeNull);

1,224,721✔

4807

  if (TSDB_CODE_SUCCESS == code) {

1,224,721✔

4808

    code = tlvEncodeBool(pEncoder, PHY_GROUP_CACHE_CODE_GROUP_BY_UID, pNode->grpByUid);

1,224,721✔

4810

  if (TSDB_CODE_SUCCESS == code) {

1,224,721✔

4811

    code = tlvEncodeBool(pEncoder, PHY_GROUP_CACHE_CODE_GLOBAL_GROUP, pNode->globalGrp);

1,224,721✔

4813

  if (TSDB_CODE_SUCCESS == code) {

1,224,721✔

4814

    code = tlvEncodeBool(pEncoder, PHY_GROUP_CACHE_CODE_BATCH_FETCH, pNode->batchFetch);

1,224,721✔

4817

  return code;

1,224,721✔

4820

static int32_t msgToPhysiGroupCacheNode(STlvDecoder* pDecoder, void* pObj) {

1,224,471✔

4821

  SGroupCachePhysiNode* pNode = (SGroupCachePhysiNode*)pObj;

1,224,471✔

4823

  int32_t code = TSDB_CODE_SUCCESS;

1,224,471✔

4824

  STlv*   pTlv = NULL;

1,224,471✔

4825

  tlvForEach(pDecoder, pTlv, code) {

7,346,826✔

4826

    switch (pTlv->type) {

6,122,355✔

4827

      case PHY_GROUP_CACHE_CODE_BASE_NODE:

1,224,471✔

4828

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

1,224,471✔

4829

        break;

1,224,471✔

4833

      case PHY_GROUP_CACHE_CODE_GROUP_COLS_MAY_BE_NULL:

1,224,471✔

4834

        code = tlvDecodeBool(pTlv, &pNode->grpColsMayBeNull);

1,224,471✔

4835

        break;

1,224,471✔

4836

      case PHY_GROUP_CACHE_CODE_GROUP_BY_UID:

1,224,471✔

4837

        code = tlvDecodeBool(pTlv, &pNode->grpByUid);

1,224,471✔

4838

        break;

1,224,471✔

4839

      case PHY_GROUP_CACHE_CODE_GLOBAL_GROUP:

1,224,471✔

4840

        code = tlvDecodeBool(pTlv, &pNode->globalGrp);

1,224,471✔

4841

        break;

1,224,471✔

4842

      case PHY_GROUP_CACHE_CODE_BATCH_FETCH:

1,224,471✔

4843

        code = tlvDecodeBool(pTlv, &pNode->batchFetch);

1,224,471✔

4844

        break;

1,224,471✔

4850

  return code;

1,224,471✔

4887

static int32_t physiDynQueryCtrlNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

5,550,499✔

4888

  const SDynQueryCtrlPhysiNode* pNode = (const SDynQueryCtrlPhysiNode*)pObj;

5,550,499✔

4890

  int32_t code = tlvEncodeObj(pEncoder, PHY_DYN_QUERY_CTRL_CODE_BASE_NODE, physiNodeToMsg, &pNode->node);

5,550,499✔

4891

  if (TSDB_CODE_SUCCESS == code) {

5,550,499✔

4892

    code = tlvEncodeEnum(pEncoder, PHY_DYN_QUERY_CTRL_CODE_QUERY_TYPE, pNode->qType);

5,550,499✔

4894

  if (TSDB_CODE_SUCCESS == code) {

5,550,499✔

4895

    switch (pNode->qType) {

5,550,499✔

4896

      case DYN_QTYPE_STB_HASH: {

1,224,721✔

4897

        code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_BATCH_FETCH, pNode->stbJoin.batchFetch);

1,224,721✔

4898

        if (TSDB_CODE_SUCCESS == code) {

1,224,721✔

4899

          code = tlvEncodeEnum(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT0, pNode->stbJoin.vgSlot[0]);

1,224,721✔

4901

        if (TSDB_CODE_SUCCESS == code) {

1,224,721✔

4902

          code = tlvEncodeEnum(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT1, pNode->stbJoin.vgSlot[1]);

1,224,721✔

4904

        if (TSDB_CODE_SUCCESS == code) {

1,224,721✔

4905

          code = tlvEncodeEnum(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_UID_SLOT0, pNode->stbJoin.uidSlot[0]);

1,224,721✔

4907

        if (TSDB_CODE_SUCCESS == code) {

1,224,721✔

4908

          code = tlvEncodeEnum(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_UID_SLOT1, pNode->stbJoin.uidSlot[1]);

1,224,721✔

4910

        if (TSDB_CODE_SUCCESS == code) {

1,224,721✔

4911

          code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_SRC_SCAN0, pNode->stbJoin.srcScan[0]);

1,224,721✔

4913

        if (TSDB_CODE_SUCCESS == code) {

1,224,721✔

4914

          code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_SRC_SCAN1, pNode->stbJoin.srcScan[1]);

1,224,721✔

4916

        break;

1,224,721✔

4918

      case DYN_QTYPE_VTB_WINDOW: {

622,955✔

4919

        code = tlvEncodeI32(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_WSTART_SLOTID, pNode->vtbWindow.wstartSlotId);

622,955✔

4920

        if (TSDB_CODE_SUCCESS == code) {

622,955✔

4921

          code = tlvEncodeI32(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_WEND_SLOTID, pNode->vtbWindow.wendSlotId);

622,955✔

4923

        if (TSDB_CODE_SUCCESS == code) {

622,955✔

4924

          code = tlvEncodeI32(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_WDURATION_SLOTID, pNode->vtbWindow.wdurationSlotId);

622,955✔

4926

        if (TSDB_CODE_SUCCESS == code) {

622,955✔

4927

          code = tlvEncodeObj(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_TARGETS, nodeListToMsg, pNode->vtbWindow.pTargets);

622,955✔

4929

        if (TSDB_CODE_SUCCESS == code) {

622,955✔

4930

          code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_IS_VSTB, pNode->vtbWindow.isVstb);

622,955✔

4932

        if (TSDB_CODE_SUCCESS == code) {

622,955✔

4933

          code = tlvEncodeI32(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_STATE_EXTEND_OPTION, pNode->vtbWindow.extendOption);

622,955✔

4941

        code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_SCAN_ALL_COLS, pNode->vtbScan.scanAllCols);

4,325,778✔

4942

        if (TSDB_CODE_SUCCESS == code) {

4,325,778✔

4943

          code = tlvEncodeU64(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_SUID, pNode->vtbScan.suid);

4,325,778✔

4945

        if (TSDB_CODE_SUCCESS == code) {

4,325,778✔

4946

          code = tlvEncodeCStr(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_DBNAME, pNode->vtbScan.dbName);

4,325,778✔

4948

        if (TSDB_CODE_SUCCESS == code) {

4,325,778✔

4949

          code = tlvEncodeCStr(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_STBNAME, pNode->vtbScan.tbName);

4,325,778✔

4951

        if (TSDB_CODE_SUCCESS == code) {

4,325,778✔

4952

          code = tlvEncodeI32(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_ACCOUNT_ID, pNode->vtbScan.accountId);

4,325,778✔

4954

        if (TSDB_CODE_SUCCESS == code) {

4,325,778✔

4955

          code = tlvEncodeObj(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_EP_SET, epSetToMsg, &pNode->vtbScan.mgmtEpSet);

4,325,778✔

4957

        if (TSDB_CODE_SUCCESS == code) {

4,325,778✔

4958

          code = tlvEncodeObj(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_SCAN_COLS, nodeListToMsg, pNode->vtbScan.pScanCols);

4,325,778✔

4960

        if (TSDB_CODE_SUCCESS == code) {

4,325,778✔

4961

          code = tlvEncodeU64(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_UID, pNode->vtbScan.uid);

4,325,778✔

4963

        if (TSDB_CODE_SUCCESS == code) {

4,325,778✔

4964

          code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_IS_SUPER_TABLE, pNode->vtbScan.isSuperTable);

4,325,778✔

4966

        if (TSDB_CODE_SUCCESS == code) {

4,325,778✔

4967

          code = tlvEncodeI32(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_RVERSION, pNode->vtbScan.rversion);

4,325,778✔

4969

        if (TSDB_CODE_SUCCESS == code) {

4,325,778✔

4970

          code = tlvEncodeObj(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_ORG_VG_IDS, nodeListToMsg, pNode->vtbScan.pOrgVgIds);

4,325,778✔

4972

        if (TSDB_CODE_SUCCESS == code) {

4,325,778✔

4973

          code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_BATCH_PROCESS_CHILD, pNode->vtbScan.batchProcessChild);

4,325,778✔

4975

        if (TSDB_CODE_SUCCESS == code) {

4,325,778✔

4976

          code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_HAS_PARTITION, pNode->vtbScan.hasPartition);

4,325,778✔

4978

        break;

4,325,778✔

4984

  if (TSDB_CODE_SUCCESS == code) {

5,550,499✔

4985

    code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_DYN_TBNAME, pNode->dynTbname);

5,550,499✔

4987

  return code;

5,550,499✔

4990

static int32_t msgToPhysiDynQueryCtrlNode(STlvDecoder* pDecoder, void* pObj) {

3,681,059✔

4991

  SDynQueryCtrlPhysiNode* pNode = (SDynQueryCtrlPhysiNode*)pObj;

3,681,059✔

4993

  int32_t code = TSDB_CODE_SUCCESS;

3,681,059✔

4994

  STlv*   pTlv = NULL;

3,681,059✔

4995

  tlvForEach(pDecoder, pTlv, code) {

58,606,615✔

4996

    switch (pTlv->type) {

54,925,556✔

4997

      case PHY_DYN_QUERY_CTRL_CODE_BASE_NODE:

3,681,059✔

4998

        code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node);

3,681,059✔

4999

        break;

3,681,059✔

5000

      case PHY_DYN_QUERY_CTRL_CODE_QUERY_TYPE:

3,681,059✔

5001

        code = tlvDecodeEnum(pTlv, &pNode->qType, sizeof(pNode->qType));

3,681,059✔

5002

        break;

3,681,059✔

5003

      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_BATCH_FETCH:

1,224,471✔

5004

        code = tlvDecodeBool(pTlv, &pNode->stbJoin.batchFetch);

1,224,471✔

5005

        break;

1,224,471✔

5006

      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT0:

1,224,471✔

5007

        code = tlvDecodeEnum(pTlv, &pNode->stbJoin.vgSlot[0], sizeof(pNode->stbJoin.vgSlot[0]));

1,224,471✔

5008

        break;

1,224,471✔

5009

      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT1:

1,224,471✔

5010

        code = tlvDecodeEnum(pTlv, &pNode->stbJoin.vgSlot[1], sizeof(pNode->stbJoin.vgSlot[1]));

1,224,471✔

5011

        break;

1,224,471✔

5012

      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_UID_SLOT0:

1,224,471✔

5013

        code = tlvDecodeEnum(pTlv, &pNode->stbJoin.uidSlot[0], sizeof(pNode->stbJoin.uidSlot[0]));

1,224,471✔

5014

        break;

1,224,471✔

5015

      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_UID_SLOT1:

1,224,471✔

5016

        code = tlvDecodeEnum(pTlv, &pNode->stbJoin.uidSlot[1], sizeof(pNode->stbJoin.uidSlot[1]));

1,224,471✔

5017

        break;

1,224,471✔

5018

      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_SRC_SCAN0:

1,224,471✔

5019

        code = tlvDecodeBool(pTlv, &pNode->stbJoin.srcScan[0]);

1,224,471✔

5020

        break;

1,224,471✔

5021

      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_SRC_SCAN1:

1,224,471✔

5022

        code = tlvDecodeBool(pTlv, &pNode->stbJoin.srcScan[1]);

1,224,471✔

5023

        break;

1,224,471✔

5024

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_SCAN_ALL_COLS:

2,456,588✔

5025

        code = tlvDecodeBool(pTlv, &pNode->vtbScan.scanAllCols);

2,456,588✔

5026

        break;

2,456,588✔

5027

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_SUID:

2,456,588✔

5028

        code = tlvDecodeU64(pTlv, &pNode->vtbScan.suid);

2,456,588✔

5029

        break;

2,456,588✔

5030

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_DBNAME:

2,456,588✔

5031

        code = tlvDecodeCStr(pTlv, pNode->vtbScan.dbName, sizeof(pNode->vtbScan.dbName));

2,456,588✔

5032

        break;

2,456,588✔

5033

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_STBNAME:

2,456,588✔

5034

        code = tlvDecodeCStr(pTlv, pNode->vtbScan.tbName, sizeof(pNode->vtbScan.tbName));

2,456,588✔

5035

        break;

2,456,588✔

5036

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_ACCOUNT_ID:

2,456,588✔

5037

        code = tlvDecodeI32(pTlv, &pNode->vtbScan.accountId);

2,456,588✔

5038

        break;

2,456,588✔

5039

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_EP_SET:

2,456,588✔

5040

        code = tlvDecodeObjFromTlv(pTlv, msgToEpSet, &pNode->vtbScan.mgmtEpSet);

2,456,588✔

5041

        break;

2,456,588✔

5042

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_SCAN_COLS:

2,456,588✔

5043

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->vtbScan.pScanCols);

2,456,588✔

5044

        break;

2,456,588✔

5045

      case PHY_DYN_QUERY_CTRL_CODE_DYN_TBNAME:

3,681,059✔

5046

        code = tlvDecodeBool(pTlv, &pNode->dynTbname);

3,681,059✔

5047

        break;

3,681,059✔

5048

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_UID:

2,456,588✔

5049

        code = tlvDecodeU64(pTlv, &pNode->vtbScan.uid);

2,456,588✔

5050

        break;

2,456,588✔

5051

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_IS_SUPER_TABLE:

2,456,588✔

5052

        code = tlvDecodeBool(pTlv, &pNode->vtbScan.isSuperTable);

2,456,588✔

5053

        break;

2,456,588✔

5054

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_RVERSION:

2,456,588✔

5055

        code = tlvDecodeI32(pTlv, &pNode->vtbScan.rversion);

2,456,588✔

5056

        break;

2,456,588✔

5057

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_ORG_VG_IDS:

2,151,056✔

5058

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->vtbScan.pOrgVgIds);

2,151,056✔

5059

        break;

2,151,056✔

5060

      case PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_WSTART_SLOTID:

613,495✔

5061

        code = tlvDecodeI32(pTlv, &pNode->vtbWindow.wstartSlotId);

613,495✔

5062

        break;

613,495✔

5063

      case PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_WEND_SLOTID:

613,495✔

5064

        code = tlvDecodeI32(pTlv, &pNode->vtbWindow.wendSlotId);

613,495✔

5065

        break;

613,495✔

5066

      case PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_WDURATION_SLOTID:

613,495✔

5067

        code = tlvDecodeI32(pTlv, &pNode->vtbWindow.wdurationSlotId);

613,495✔

5068

        break;

613,495✔

5069

      case PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_TARGETS:

613,495✔

5070

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->vtbWindow.pTargets);

613,495✔

5071

        break;

613,495✔

5072

      case PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_IS_VSTB:

613,495✔

5073

        code = tlvDecodeBool(pTlv, &pNode->vtbWindow.isVstb);

613,495✔

5074

        break;

613,495✔

5075

      case PHY_DYN_QUERY_CTRL_CODE_VTB_WINDOW_STATE_EXTEND_OPTION:

613,495✔

5076

        code = tlvDecodeI32(pTlv, (int32_t*)&pNode->vtbWindow.extendOption);

613,495✔

5077

        break;

613,495✔

5078

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_BATCH_PROCESS_CHILD:

2,456,588✔

5079

        code = tlvDecodeBool(pTlv, &pNode->vtbScan.batchProcessChild);

2,456,588✔

5080

        break;

2,456,588✔

5081

      case PHY_DYN_QUERY_CTRL_CODE_VTB_SCAN_HAS_PARTITION:

2,456,588✔

5082

        code = tlvDecodeBool(pTlv, &pNode->vtbScan.hasPartition);

2,456,588✔

5083

        break;

2,456,588✔

5089

  return code;

3,681,059✔

5096

static int32_t subplanIdInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {

522,805,170✔

5097

  const SSubplanId* pNode = (const SSubplanId*)pObj;

522,805,170✔

5099

  int32_t code = tlvEncodeValueU64(pEncoder, pNode->queryId);

522,805,170✔

5100

  if (TSDB_CODE_SUCCESS == code) {

521,915,423✔

5101

    code = tlvEncodeValueI32(pEncoder, pNode->groupId);

522,000,561✔

5103

  if (TSDB_CODE_SUCCESS == code) {

522,705,474✔

5104

    code = tlvEncodeValueI32(pEncoder, pNode->subplanId);

522,723,220✔

5107

  return code;

522,948,803✔

5124

static int32_t msgToSubplanIdInline(STlvDecoder* pDecoder, void* pObj) {

372,716,310✔

5125

  SSubplanId* pNode = (SSubplanId*)pObj;

372,716,310✔

5127

  int32_t code = tlvDecodeValueU64(pDecoder, &pNode->queryId);

372,716,310✔

5128

  if (TSDB_CODE_SUCCESS == code) {

372,631,976✔

5129

    code = tlvDecodeValueI32(pDecoder, &pNode->groupId);

372,641,802✔

5131

  if (TSDB_CODE_SUCCESS == code) {

372,701,414✔

5132

    code = tlvDecodeValueI32(pDecoder, &pNode->subplanId);

372,701,414✔

5135

  return code;

372,655,136✔

5170

static int32_t subplanInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {

522,794,119✔

5171

  const SSubplan* pNode = (const SSubplan*)pObj;

522,794,119✔

5173

  int32_t code = subplanIdInlineToMsg(&pNode->id, pEncoder);

522,794,119✔

5174

  if (TSDB_CODE_SUCCESS == code) {

522,944,272✔

5175

    code = tlvEncodeValueEnum(pEncoder, pNode->subplanType);

522,949,568✔

5177

  if (TSDB_CODE_SUCCESS == code) {

522,988,559✔

5178

    code = tlvEncodeValueI32(pEncoder, pNode->msgType);

523,014,260✔

5180

  if (TSDB_CODE_SUCCESS == code) {

522,895,128✔

5181

    code = tlvEncodeValueI32(pEncoder, pNode->level);

522,925,754✔

5183

  if (TSDB_CODE_SUCCESS == code) {

523,017,052✔

5184

    code = tlvEncodeValueCStr(pEncoder, pNode->dbFName);

522,998,997✔

5186

  if (TSDB_CODE_SUCCESS == code) {

522,924,636✔

5187

    code = tlvEncodeValueCStr(pEncoder, pNode->user);

522,912,415✔

5189

  if (TSDB_CODE_SUCCESS == code) {

523,073,291✔

5190

    code = queryNodeAddrInlineToMsg(&pNode->execNode, pEncoder);

523,067,316✔

5192

  if (TSDB_CODE_SUCCESS == code) {

523,059,969✔

5193

    code = tlvEncodeValueBool(pEncoder, pNode->showRewrite);

523,054,684✔

5195

  if (TSDB_CODE_SUCCESS == code) {

523,081,602✔

5196

    code = tlvEncodeValueI32(pEncoder, pNode->rowsThreshold);

523,022,885✔

5198

  if (TSDB_CODE_SUCCESS == code) {

522,998,794✔

5199

    code = tlvEncodeValueBool(pEncoder, pNode->dynamicRowThreshold);

522,946,833✔

5201

  if (TSDB_CODE_SUCCESS == code) {

522,978,739✔

5202

    code = tlvEncodeValueBool(pEncoder, pNode->isView);

522,928,835✔

5204

  if (TSDB_CODE_SUCCESS == code) {

522,981,012✔

5205

    code = tlvEncodeValueBool(pEncoder, pNode->isAudit);

522,941,229✔

5207

  if (TSDB_CODE_SUCCESS == code) {

523,102,449✔

5208

    code = tlvEncodeValueBool(pEncoder, pNode->processOneBlock);

523,016,605✔

5210

  if (TSDB_CODE_SUCCESS == code) {

523,058,182✔

5211

    code = tlvEncodeValueBool(pEncoder, pNode->dynTbname);

522,988,560✔

5213

  return code;

523,086,032✔

5216

static int32_t subplanToMsg(const void* pObj, STlvEncoder* pEncoder) {

522,815,231✔

5217

  const SSubplan* pNode = (const SSubplan*)pObj;

522,815,231✔

5219

  int32_t code = tlvEncodeObj(pEncoder, SUBPLAN_CODE_INLINE_ATTRS, subplanInlineToMsg, pNode);

522,815,231✔

5220

  if (TSDB_CODE_SUCCESS == code) {

522,645,344✔

5221

    code = tlvEncodeObj(pEncoder, SUBPLAN_CODE_ROOT_NODE, nodeToMsg, pNode->pNode);

522,669,143✔

5223

  if (TSDB_CODE_SUCCESS == code) {

522,996,148✔

5224

    code = tlvEncodeObj(pEncoder, SUBPLAN_CODE_DATA_SINK, nodeToMsg, pNode->pDataSink);

522,932,286✔

5226

  if (TSDB_CODE_SUCCESS == code) {

523,270,987✔

5227

    code = tlvEncodeObj(pEncoder, SUBPLAN_CODE_TAG_COND, nodeToMsg, pNode->pTagCond);

523,209,526✔

5229

  if (TSDB_CODE_SUCCESS == code) {

523,080,382✔

5230

    code = tlvEncodeObj(pEncoder, SUBPLAN_CODE_TAG_INDEX_COND, nodeToMsg, pNode->pTagIndexCond);

523,020,554✔

5233

  return code;

522,555,287✔

5236

static int32_t msgToSubplanInline(STlvDecoder* pDecoder, void* pObj) {

372,715,763✔

5237

  SSubplan* pNode = (SSubplan*)pObj;

372,715,763✔

5239

  int32_t code = msgToSubplanIdInline(pDecoder, &pNode->id);

372,715,763✔

5240

  if (TSDB_CODE_SUCCESS == code) {

372,656,542✔

5241

    code = tlvDecodeValueEnum(pDecoder, &pNode->subplanType, sizeof(pNode->subplanType));

372,657,371✔

5243

  if (TSDB_CODE_SUCCESS == code) {

372,685,091✔

5244

    code = tlvDecodeValueI32(pDecoder, &pNode->msgType);

372,685,091✔

5246

  if (TSDB_CODE_SUCCESS == code) {

372,760,894✔

5247

    code = tlvDecodeValueI32(pDecoder, &pNode->level);

372,760,894✔

5249

  if (TSDB_CODE_SUCCESS == code) {

372,767,607✔

5250

    code = tlvDecodeValueCStr(pDecoder, pNode->dbFName);

372,767,607✔

5252

  if (TSDB_CODE_SUCCESS == code) {

372,758,571✔

5253

    code = tlvDecodeValueCStr(pDecoder, pNode->user);

372,758,571✔

5255

  if (TSDB_CODE_SUCCESS == code) {

372,765,186✔

5256

    code = msgToQueryNodeAddrInline(pDecoder, &pNode->execNode);

372,765,186✔

5258

  if (TSDB_CODE_SUCCESS == code) {

372,661,652✔

5259

    code = tlvDecodeValueBool(pDecoder, &pNode->showRewrite);

372,661,652✔

5261

  if (TSDB_CODE_SUCCESS == code) {

372,702,017✔

5262

    code = tlvDecodeValueI32(pDecoder, &pNode->rowsThreshold);

372,702,017✔

5264

  if (TSDB_CODE_SUCCESS == code) {

372,769,454✔

5265

    code = tlvDecodeValueBool(pDecoder, &pNode->dynamicRowThreshold);

372,769,454✔

5267

  if (TSDB_CODE_SUCCESS == code) {

372,764,210✔

5268

    code = tlvDecodeValueBool(pDecoder, &pNode->isView);

372,764,210✔

5270

  if (TSDB_CODE_SUCCESS == code) {

372,767,280✔

5271

    code = tlvDecodeValueBool(pDecoder, &pNode->isAudit);

372,767,280✔

5273

  if (TSDB_CODE_SUCCESS == code) {

372,764,873✔

5274

    code = tlvDecodeValueBool(pDecoder, &pNode->processOneBlock);

372,764,873✔

5276

  if (TSDB_CODE_SUCCESS == code) {

372,759,089✔

5277

    code = tlvDecodeValueBool(pDecoder, &pNode->dynTbname);

372,759,089✔

5279

  return code;

372,760,163✔

5282

static int32_t msgToSubplan(STlvDecoder* pDecoder, void* pObj) {

372,715,584✔

5283

  SSubplan* pNode = (SSubplan*)pObj;

372,715,584✔

5285

  int32_t code = TSDB_CODE_SUCCESS;

372,715,584✔

5286

  STlv*   pTlv = NULL;

372,715,584✔

5287

  tlvForEach(pDecoder, pTlv, code) {

1,511,224,552✔

5288

    switch (pTlv->type) {

1,138,490,877✔

5289

      case SUBPLAN_CODE_INLINE_ATTRS:

372,688,047✔

5290

        code = tlvDecodeObjFromTlv(pTlv, msgToSubplanInline, pNode);

372,688,047✔

5291

        break;

372,758,494✔

5292

      case SUBPLAN_CODE_ROOT_NODE:

372,779,700✔

5293

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pNode);

372,779,700✔

5294

        break;

372,745,142✔

5295

      case SUBPLAN_CODE_DATA_SINK:

372,771,971✔

5296

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pDataSink);

372,771,971✔

5297

        break;

372,768,388✔

5298

      case SUBPLAN_CODE_TAG_COND:

15,784,073✔

5299

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pTagCond);

15,784,073✔

5300

        break;

15,782,027✔

5301

      case SUBPLAN_CODE_TAG_INDEX_COND:

4,473,813✔

5302

        code = msgToNodeFromTlv(pTlv, (void**)&pNode->pTagIndexCond);

4,473,813✔

5303

        break;

4,431,474✔

5309

  return code;

372,883,745✔

5314

static int32_t queryPlanInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,352✔

5315

  const SQueryPlan* pNode = (const SQueryPlan*)pObj;

2,352✔

5317

  int32_t code = tlvEncodeValueU64(pEncoder, pNode->queryId);

2,352✔

5318

  if (TSDB_CODE_SUCCESS == code) {

2,352✔

5319

    code = tlvEncodeValueI32(pEncoder, pNode->numOfSubplans);

2,352✔

5322

  return code;

2,352✔

5325

static int32_t queryPlanToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,352✔

5326

  const SQueryPlan* pNode = (const SQueryPlan*)pObj;

2,352✔

5328

  int32_t code = tlvEncodeObj(pEncoder, QUERY_PLAN_CODE_INLINE_ATTRS, queryPlanInlineToMsg, pNode);

2,352✔

5329

  if (TSDB_CODE_SUCCESS == code) {

2,352✔

5330

    code = tlvEncodeObj(pEncoder, QUERY_PLAN_CODE_SUBPLANS, nodeListToMsg, pNode->pSubplans);

2,352✔

5333

  return code;

2,352✔

5336

static int32_t msgToQueryPlanInline(STlvDecoder* pDecoder, void* pObj) {

1,176✔

5337

  SQueryPlan* pNode = (SQueryPlan*)pObj;

1,176✔

5339

  int32_t code = tlvDecodeValueU64(pDecoder, &pNode->queryId);

1,176✔

5340

  if (TSDB_CODE_SUCCESS == code) {

1,176✔

5341

    code = tlvDecodeValueI32(pDecoder, &pNode->numOfSubplans);

1,176✔

5344

  return code;

1,176✔

5347

static int32_t msgToQueryPlan(STlvDecoder* pDecoder, void* pObj) {

1,176✔

5348

  SQueryPlan* pNode = (SQueryPlan*)pObj;

1,176✔

5350

  int32_t code = TSDB_CODE_SUCCESS;

1,176✔

5351

  STlv*   pTlv = NULL;

1,176✔

5352

  tlvForEach(pDecoder, pTlv, code) {

3,528✔

5353

    switch (pTlv->type) {

2,352✔

5354

      case QUERY_PLAN_CODE_INLINE_ATTRS:

1,176✔

5355

        code = tlvDecodeObjFromTlv(pTlv, msgToQueryPlanInline, pNode);

1,176✔

5356

        break;

1,176✔

5357

      case QUERY_PLAN_CODE_SUBPLANS:

1,176✔

5358

        code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pSubplans);

1,176✔

5359

        break;

1,176✔

5365

  return code;

1,176✔

5368

static int32_t specificNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,147,483,647✔

5370

  int32_t code = TSDB_CODE_SUCCESS;

2,147,483,647✔

5371

  switch (nodeType(pObj)) {

2,147,483,647✔

5372

    case QUERY_NODE_COLUMN:

2,147,483,647✔

5373

      code = columnNodeToMsg(pObj, pEncoder);

2,147,483,647✔

5374

      break;

2,147,483,647✔

5375

    case QUERY_NODE_VALUE:

461,806,849✔

5376

      code = valueNodeToMsg(pObj, pEncoder);

461,806,849✔

5377

      break;

461,863,169✔

5378

    case QUERY_NODE_OPERATOR:

318,225,387✔

5379

      code = operatorNodeToMsg(pObj, pEncoder);

318,225,387✔

5380

      break;

318,277,609✔

5381

    case QUERY_NODE_LOGIC_CONDITION:

48,348,588✔

5382

      code = logicConditionNodeToMsg(pObj, pEncoder);

48,348,588✔

5383

      break;

48,381,654✔

5384

    case QUERY_NODE_FUNCTION:

639,210,361✔

5385

      code = functionNodeToMsg(pObj, pEncoder);

639,210,361✔

5386

      break;

639,193,786✔

5387

    case QUERY_NODE_ORDER_BY_EXPR:

93,816,974✔

5388

      code = orderByExprNodeToMsg(pObj, pEncoder);

93,816,974✔

5389

      break;

93,825,433✔

5390

    case QUERY_NODE_LIMIT:

41,015,041✔

5391

      code = limitNodeToMsg(pObj, pEncoder);

41,015,041✔

5392

      break;

41,035,318✔

5393

    case QUERY_NODE_NODE_LIST:

10,923,429✔

5394

      code = nodeListNodeToMsg(pObj, pEncoder);

10,923,429✔

5395

      break;

10,933,334✔

5396

    case QUERY_NODE_TARGET:

2,147,483,647✔

5397

      code = targetNodeToMsg(pObj, pEncoder);

2,147,483,647✔

5398

      break;

2,147,483,647✔

5402

    case QUERY_NODE_DATABLOCK_DESC:

1,608,974,947✔

5403

      code = dataBlockDescNodeToMsg(pObj, pEncoder);

1,608,974,947✔

5404

      break;

1,610,670,346✔

5405

    case QUERY_NODE_SLOT_DESC:

2,147,483,647✔

5406

      code = slotDescNodeToMsg(pObj, pEncoder);

2,147,483,647✔

5407

      break;

2,147,483,647✔

5408

    case QUERY_NODE_DOWNSTREAM_SOURCE:

255,867,242✔

5409

      code = downstreamSourceNodeToMsg(pObj, pEncoder);

255,867,242✔

5410

      break;

255,868,559✔

5411

    case QUERY_NODE_LEFT_VALUE:

7,492,339✔

5412

      break;

7,492,339✔

5413

    case QUERY_NODE_WHEN_THEN:

7,074,532✔

5414

      code = whenThenNodeToMsg(pObj, pEncoder);

7,074,532✔

5415

      break;

7,074,452✔

5416

    case QUERY_NODE_CASE_WHEN:

6,931,080✔

5417

      code = caseWhenNodeToMsg(pObj, pEncoder);

6,931,080✔

5418

      break;

6,931,824✔

5419

    case QUERY_NODE_WINDOW_OFFSET:

330,511✔

5420

      code = windowOffsetNodeToMsg(pObj, pEncoder);

330,511✔

5421

      break;

330,511✔

5422

    case QUERY_NODE_REMOTE_VALUE:

59,136,500✔

5423

      code = remoteValueNodeToMsg(pObj, pEncoder);

59,136,500✔

5424

      break;

59,133,017✔

5425

    case QUERY_NODE_REMOTE_VALUE_LIST:

18,059,930✔

5426

      code = remoteValueListNodeToMsg(pObj, pEncoder);

18,059,930✔

5427

      break;

18,062,811✔

5428

    case QUERY_NODE_REMOTE_ROW:

22,910,223✔

5429

      code = remoteRowNodeToMsg(pObj, pEncoder);

22,910,223✔

5430

      break;

22,909,719✔

5431

    case QUERY_NODE_REMOTE_ZERO_ROWS:

1,311,098✔

5432

      code = remoteZeroRowsNodeToMsg(pObj, pEncoder);

1,311,098✔

5433

      break;

1,310,754✔

5434

    case QUERY_NODE_REMOTE_TABLE:

401,449✔

5435

      code = remoteTableNodeToMsg(pObj, pEncoder);

401,449✔

5436

      break;

401,449✔

5437

    case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN:

14,350,982✔

5438

      code = physiTagScanNodeToMsg(pObj, pEncoder);

14,350,982✔

5439

      break;

14,334,571✔

5440

    case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN:

5,532✔

5441

      code = physiScanNodeToMsg(pObj, pEncoder);

5,532✔

5442

      break;

5,532✔

5443

    case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN:

1,853,330✔

5445

      code = physiLastRowScanNodeToMsg(pObj, pEncoder);

1,853,330✔

5446

      break;

1,857,030✔

5447

    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:

378,131,498✔

5450

      code = physiTableScanNodeToMsg(pObj, pEncoder);

378,131,498✔

5451

      break;

377,253,957✔

5452

    case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN:

40,019,082✔

5453

      code = physiSysTableScanNodeToMsg(pObj, pEncoder);

40,019,082✔

5454

      break;

40,039,052✔

5455

    case QUERY_NODE_PHYSICAL_PLAN_PROJECT:

207,103,297✔

5456

      code = physiProjectNodeToMsg(pObj, pEncoder);

207,103,297✔

5457

      break;

207,251,686✔

5458

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN:

15,856,775✔

5459

      code = physiMergeJoinNodeToMsg(pObj, pEncoder);

15,856,775✔

5460

      break;

15,856,841✔

5461

    case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN:

1,225,529✔

5462

      code = physiHashJoinNodeToMsg(pObj, pEncoder);

1,225,529✔

5463

      break;

1,225,529✔

5464

    case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG:

159,477,426✔

5465

      code = physiAggNodeToMsg(pObj, pEncoder);

159,477,426✔

5466

      break;

159,502,899✔

5467

    case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE:

144,181,476✔

5468

      code = physiExchangeNodeToMsg(pObj, pEncoder);

144,181,476✔

5469

      break;

144,179,795✔

5470

    case QUERY_NODE_PHYSICAL_PLAN_MERGE:

18,474,546✔

5471

      code = physiMergeNodeToMsg(pObj, pEncoder);

18,474,546✔

5472

      break;

18,474,828✔

5473

    case QUERY_NODE_PHYSICAL_PLAN_SORT:

54,086,184✔

5475

      code = physiSortNodeToMsg(pObj, pEncoder);

54,086,184✔

5476

      break;

54,103,122✔

5477

    case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL:

13,486,062✔

5479

      code = physiIntervalNodeToMsg(pObj, pEncoder);

13,486,062✔

5480

      break;

13,486,747✔

5481

    case QUERY_NODE_PHYSICAL_PLAN_FILL:

498,639✔

5482

      code = physiFillNodeToMsg(pObj, pEncoder);

498,639✔

5483

      break;

499,056✔

5484

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION:

2,394,420✔

5485

      code = physiSessionWindowNodeToMsg(pObj, pEncoder);

2,394,420✔

5486

      break;

2,394,499✔

5487

    case QUERY_NODE_PHYSICAL_PLAN_EXTERNAL_WINDOW:

1,454,930✔

5490

      code = physiExternalWindowNodeToMsg(pObj, pEncoder);

1,454,930✔

5491

      break;

1,454,526✔

5492

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE:

2,435,462✔

5493

      code = physiStateWindowNodeToMsg(pObj, pEncoder);

2,435,462✔

5494

      break;

2,435,462✔

5495

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT:

1,790,153✔

5496

      code = physiEventWindowNodeToMsg(pObj, pEncoder);

1,790,153✔

5497

      break;

1,790,334✔

5498

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_COUNT:

1,635,692✔

5499

      code = physiCountWindowNodeToMsg(pObj, pEncoder);

1,635,692✔

5500

      break;

1,636,794✔

5504

    case QUERY_NODE_PHYSICAL_PLAN_PARTITION:

10,488,849✔

5505

      code = physiPartitionNodeToMsg(pObj, pEncoder);

10,488,849✔

5506

      break;

10,494,687✔

5507

    case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC:

3,197,371✔

5508

      code = physiIndefRowsFuncNodeToMsg(pObj, pEncoder);

3,197,371✔

5509

      break;

3,199,035✔

5510

    case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC:

3,447,009✔

5511

      code = physiInterpFuncNodeToMsg(pObj, pEncoder);

3,447,009✔

5512

      break;

3,447,009✔

5517

    case QUERY_NODE_PHYSICAL_PLAN_DISPATCH:

520,132,060✔

5518

      code = physiDispatchNodeToMsg(pObj, pEncoder);

520,132,060✔

5519

      break;

520,342,521✔

5520

    case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT:

523,837✔

5521

      code = physiQueryInsertNodeToMsg(pObj, pEncoder);

523,837✔

5522

      break;

523,837✔

5523

    case QUERY_NODE_PHYSICAL_PLAN_DELETE:

1,813,395✔

5524

      code = physiDeleteNodeToMsg(pObj, pEncoder);

1,813,395✔

5525

      break;

1,813,395✔

5526

    case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE:

1,224,721✔

5527

      code = physiGroupCacheNodeToMsg(pObj, pEncoder);

1,224,721✔

5528

      break;

1,224,721✔

5529

    case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL:

5,550,499✔

5530

      code = physiDynQueryCtrlNodeToMsg(pObj, pEncoder);

5,550,499✔

5531

      break;

5,550,499✔

5532

    case QUERY_NODE_PHYSICAL_PLAN_VIRTUAL_TABLE_SCAN:

4,463,924✔

5533

      code = physiVirtualTableScanNodeToMsg(pObj, pEncoder);

4,463,924✔

5534

      break;

4,463,924✔

5535

    case QUERY_NODE_PHYSICAL_SUBPLAN:

522,899,009✔

5536

      code = subplanToMsg(pObj, pEncoder);

522,899,009✔

5537

      break;

522,745,513✔

5538

    case QUERY_NODE_PHYSICAL_PLAN:

2,352✔

5539

      code = queryPlanToMsg(pObj, pEncoder);

2,352✔

5540

      break;

2,352✔

5544

  if (TSDB_CODE_SUCCESS != code) {

2,147,483,647✔

5548

  return code;

2,147,483,647✔

5551

static int32_t msgToSpecificNode(STlvDecoder* pDecoder, void* pObj) {

2,147,483,647✔

5552

  int32_t code = TSDB_CODE_SUCCESS;

2,147,483,647✔

5553

  switch (nodeType(pObj)) {

2,147,483,647✔

5554

    case QUERY_NODE_COLUMN:

2,147,483,647✔

5555

      code = msgToColumnNode(pDecoder, pObj);

2,147,483,647✔

5556

      break;

2,147,483,647✔

5557

    case QUERY_NODE_VALUE:

385,407,251✔

5558

      code = msgToValueNode(pDecoder, pObj);

385,407,251✔

5559

      break;

385,368,224✔

5560

    case QUERY_NODE_OPERATOR:

262,410,145✔

5561

      code = msgToOperatorNode(pDecoder, pObj);

262,410,145✔

5562

      break;

262,401,869✔

5563

    case QUERY_NODE_LOGIC_CONDITION:

45,323,735✔

5564

      code = msgToLogicConditionNode(pDecoder, pObj);

45,323,735✔

5565

      break;

45,329,348✔

5566

    case QUERY_NODE_FUNCTION:

517,532,409✔

5567

      code = msgToFunctionNode(pDecoder, pObj);

517,532,409✔

5568

      break;

517,523,850✔

5569

    case QUERY_NODE_ORDER_BY_EXPR:

62,400,489✔

5570

      code = msgToOrderByExprNode(pDecoder, pObj);

62,400,489✔

5571

      break;

62,405,068✔

5572

    case QUERY_NODE_LIMIT:

34,772,014✔

5573

      code = msgToLimitNode(pDecoder, pObj);

34,772,014✔

5574

      break;

34,770,495✔

5575

    case QUERY_NODE_NODE_LIST:

7,430,653✔

5576

      code = msgToNodeListNode(pDecoder, pObj);

7,430,653✔

5577

      break;

7,432,166✔

5578

    case QUERY_NODE_TARGET:

2,147,483,647✔

5579

      code = msgToTargetNode(pDecoder, pObj);

2,147,483,647✔

5580

      break;

2,147,483,647✔

5584

    case QUERY_NODE_DATABLOCK_DESC:

1,155,738,972✔

5585

      code = msgToDataBlockDescNode(pDecoder, pObj);

1,155,738,972✔

5586

      break;

1,155,789,187✔

5587

    case QUERY_NODE_SLOT_DESC:

2,147,483,647✔

5588

      code = msgToSlotDescNode(pDecoder, pObj);

2,147,483,647✔

5589

      break;

2,147,483,647✔

5590

    case QUERY_NODE_DOWNSTREAM_SOURCE:

193,657,574✔

5591

      code = msgToDownstreamSourceNode(pDecoder, pObj);

193,657,574✔

5592

    case QUERY_NODE_LEFT_VALUE:

201,134,902✔

5593

      break;

201,134,902✔

5594

    case QUERY_NODE_WHEN_THEN:

1,636,231✔

5595

      code = msgToWhenThenNode(pDecoder, pObj);

1,636,231✔

5596

      break;

1,636,231✔

5597

    case QUERY_NODE_CASE_WHEN:

1,494,374✔

5598

      code = msgToCaseWhenNode(pDecoder, pObj);

1,494,374✔

5599

      break;

1,494,374✔

5600

    case QUERY_NODE_WINDOW_OFFSET:

331,963✔

5601

      code = msgToWindowOffsetNode(pDecoder, pObj);

331,963✔

5602

      break;

331,963✔

5603

    case QUERY_NODE_REMOTE_VALUE:

4,883,346✔

5604

      code = msgToRemoteValueNode(pDecoder, pObj);

4,883,346✔

5605

      break;

4,882,228✔

5606

    case QUERY_NODE_REMOTE_VALUE_LIST:

11,779,294✔

5607

      code = msgToRemoteValueListNode(pDecoder, pObj);

11,779,294✔

5608

      break;

11,779,294✔

5609

    case QUERY_NODE_REMOTE_ROW:

21,370,781✔

5610

      code = msgToRemoteRowNode(pDecoder, pObj);

21,370,781✔

5611

      break;

21,370,781✔

5612

    case QUERY_NODE_REMOTE_ZERO_ROWS:

382,995✔

5613

      code = msgToRemoteZeroRowsNode(pDecoder, pObj);

382,995✔

5614

      break;

382,995✔

5615

    case QUERY_NODE_REMOTE_TABLE:

398,164✔

5616

      code = msgToRemoteTableNode(pDecoder, pObj);

398,164✔

5617

      break;

398,567✔

5618

    case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN:

8,118,253✔

5619

      code = msgToPhysiTagScanNode(pDecoder, pObj);

8,118,253✔

5620

      break;

8,117,275✔

5621

    case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN:

5,537✔

5622

      code = msgToPhysiScanNode(pDecoder, pObj);

5,537✔

5623

      break;

5,537✔

5624

    case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN:

1,850,591✔

5626

      code = msgToPhysiLastRowScanNode(pDecoder, pObj);

1,850,591✔

5627

      break;

1,850,591✔

5628

    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:

274,343,457✔

5631

      code = msgToPhysiTableScanNode(pDecoder, pObj);

274,343,457✔

5632

      break;

274,347,296✔

5633

    case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN:

25,428,351✔

5634

      code = msgToPhysiSysTableScanNode(pDecoder, pObj);

25,428,351✔

5635

      break;

25,423,748✔

5636

    case QUERY_NODE_PHYSICAL_PLAN_PROJECT:

146,489,288✔

5637

      code = msgToPhysiProjectNode(pDecoder, pObj);

146,489,288✔

5638

      break;

146,501,705✔

5639

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN:

13,000,999✔

5640

      code = msgToPhysiMergeJoinNode(pDecoder, pObj);

13,000,999✔

5641

      break;

13,000,999✔

5642

    case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN:

1,225,277✔

5643

      code = msgToPhysiHashJoinNode(pDecoder, pObj);

1,225,277✔

5644

      break;

1,225,277✔

5645

    case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG:

123,874,985✔

5646

      code = msgToPhysiAggNode(pDecoder, pObj);

123,874,985✔

5647

      break;

123,882,140✔

5648

    case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE:

112,223,574✔

5649

      code = msgToPhysiExchangeNode(pDecoder, pObj);

112,223,574✔

5650

      break;

112,221,994✔

5651

    case QUERY_NODE_PHYSICAL_PLAN_MERGE:

14,023,488✔

5652

      code = msgToPhysiMergeNode(pDecoder, pObj);

14,023,488✔

5653

      break;

14,023,488✔

5654

    case QUERY_NODE_PHYSICAL_PLAN_SORT:

33,786,365✔

5656

      code = msgToPhysiSortNode(pDecoder, pObj);

33,786,365✔

5657

      break;

33,789,962✔

5658

    case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL:

5,739,707✔

5660

      code = msgToPhysiIntervalNode(pDecoder, pObj);

5,739,707✔

5661

      break;

5,740,200✔

5662

    case QUERY_NODE_PHYSICAL_PLAN_FILL:

494,431✔

5663

      code = msgToPhysiFillNode(pDecoder, pObj);

494,431✔

5664

      break;

494,431✔

5665

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION:

585,551✔

5666

      code = msgToPhysiSessionWindowNode(pDecoder, pObj);

585,551✔

5667

      break;

585,551✔

5668

    case QUERY_NODE_PHYSICAL_PLAN_EXTERNAL_WINDOW:

1,436,826✔

5671

      code = msgToPhysiExternalWindowNode(pDecoder, pObj);

1,436,826✔

5672

      break;

1,436,423✔

5673

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE:

1,067,240✔

5674

      code = msgToPhysiStateWindowNode(pDecoder, pObj);

1,067,240✔

5675

      break;

1,067,240✔

5676

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT:

361,734✔

5677

      code = msgToPhysiEventWindowNode(pDecoder, pObj);

361,734✔

5678

      break;

361,734✔

5679

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_COUNT:

286,012✔

5680

      code = msgToPhysiCountWindowNode(pDecoder, pObj);

286,012✔

5681

      break;

286,012✔

5685

    case QUERY_NODE_PHYSICAL_PLAN_PARTITION:

3,021,492✔

5686

      code = msgToPhysiPartitionNode(pDecoder, pObj);

3,021,492✔

5687

      break;

3,021,893✔

5688

    case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC:

3,172,195✔

5689

      code = msgToPhysiIndefRowsFuncNode(pDecoder, pObj);

3,172,195✔

5690

      break;

3,172,195✔

5691

    case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC:

3,435,330✔

5692

      code = msgToPhysiInterpFuncNode(pDecoder, pObj);

3,435,330✔

5693

      break;

3,435,837✔

5698

    case QUERY_NODE_PHYSICAL_PLAN_DISPATCH:

370,377,054✔

5699

      code = msgToPhysiDispatchNode(pDecoder, pObj);

370,377,054✔

5700

      break;

370,395,963✔

5701

    case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT:

523,249✔

5702

      code = msgToPhysiQueryInsertNode(pDecoder, pObj);

523,249✔

5703

      break;

523,249✔

5704

    case QUERY_NODE_PHYSICAL_PLAN_DELETE:

1,813,441✔

5705

      code = msgToPhysiDeleteNode(pDecoder, pObj);

1,813,441✔

5706

      break;

1,812,275✔

5707

    case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE:

1,224,471✔

5708

      code = msgToPhysiGroupCacheNode(pDecoder, pObj);

1,224,471✔

5709

      break;

1,224,471✔

5710

    case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL:

3,681,059✔

5711

      code = msgToPhysiDynQueryCtrlNode(pDecoder, pObj);

3,681,059✔

5712

      break;

3,681,059✔

5713

    case QUERY_NODE_PHYSICAL_PLAN_VIRTUAL_TABLE_SCAN:

4,060,966✔

5714

      code = msgToPhysiVirtualTableScanNode(pDecoder, pObj);

4,060,966✔

5715

      break;

4,060,966✔

5716

    case QUERY_NODE_PHYSICAL_SUBPLAN:

372,716,647✔

5717

      code = msgToSubplan(pDecoder, pObj);

372,716,647✔

5718

      break;

372,754,504✔

5719

    case QUERY_NODE_PHYSICAL_PLAN:

1,176✔

5720

      code = msgToQueryPlan(pDecoder, pObj);

1,176✔

5721

      break;

1,176✔

5725

  if (TSDB_CODE_SUCCESS != code) {

2,147,483,647✔

5728

  return code;

2,147,483,647✔

5731

static int32_t nodeToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,147,483,647✔

5732

  return tlvEncodeObj(pEncoder, nodeType(pObj), specificNodeToMsg, pObj);

2,147,483,647✔

5735

static int32_t msgToNode(STlvDecoder* pDecoder, void** pObj) {

2,147,483,647✔

5736

  return tlvDecodeDynObj(pDecoder, (FMakeObject)nodesMakeNode, msgToSpecificNode, pObj);

2,147,483,647✔

5739

static int32_t msgToNodeFromTlv(STlv* pTlv, void** pObj) {

2,147,483,647✔

5740

  STlvDecoder decoder = {.bufSize = pTlv->len, .offset = 0, .pBuf = pTlv->value};

2,147,483,647✔

5741

  return msgToNode(&decoder, pObj);

2,147,483,647✔

5744

static int32_t nodeListToMsg(const void* pObj, STlvEncoder* pEncoder) {

2,147,483,647✔

5745

  const SNodeList* pList = (const SNodeList*)pObj;

2,147,483,647✔

5747

  SNode* pNode = NULL;

2,147,483,647✔

5748

  FOREACH(pNode, pList) {

2,147,483,647✔

5749

    int32_t code = nodeToMsg(pNode, pEncoder);

2,147,483,647✔

5750

    if (TSDB_CODE_SUCCESS != code) {

2,147,483,647✔

5755

  return TSDB_CODE_SUCCESS;

2,147,483,647✔

5764

static int32_t SArrayToMsg(const void* pObj, STlvEncoder* pEncoder) {

144,180,487✔

5765

  const SArray* pArray = (const SArray*)pObj;

144,180,487✔

5766

  int32_t code = TSDB_CODE_SUCCESS;

144,180,487✔

5767

  if (TSDB_CODE_SUCCESS == code) {

144,180,487✔

5768

    code = tlvEncodeI32(pEncoder, SARRAY_CODE_CAPACITY, pArray->capacity);

144,182,204✔

5770

  if (TSDB_CODE_SUCCESS == code) {

144,184,869✔

5771

    code = tlvEncodeI32(pEncoder, SARRAY_CODE_ELEMSIZE, pArray->elemSize);

144,185,635✔

5773

  if (TSDB_CODE_SUCCESS == code) {

144,181,145✔

5774

    code = tlvEncodeI32(pEncoder, SARRAY_CODE_SIZE, pArray->size);

144,181,983✔

5776

  if (TSDB_CODE_SUCCESS == code && pArray->capacity * pArray->elemSize > 0 && pArray->pData != NULL) {

144,185,606✔

5777

    code = tlvEncodeBinary(pEncoder, SARRAY_CODE_PDATA, pArray->pData, pArray->capacity * pArray->elemSize);

144,183,812✔

5779

  return code;

144,184,530✔

5783

static int32_t msgToNodeList(STlvDecoder* pDecoder, void** pObj) {

2,147,483,647✔

5784

  SNodeList* pList = NULL;

2,147,483,647✔

5785

  int32_t code = TSDB_CODE_SUCCESS;

2,147,483,647✔

5786

  code = nodesMakeList(&pList);

2,147,483,647✔

5788

  while (TSDB_CODE_SUCCESS == code && !tlvDecodeEnd(pDecoder)) {

2,147,483,647✔

5789

    SNode* pNode = NULL;

2,147,483,647✔

5790

    code = msgToNode(pDecoder, (void**)&pNode);

2,147,483,647✔

5791

    if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

5792

      code = nodesListAppend(pList, pNode);

2,147,483,647✔

5795

  if (TSDB_CODE_SUCCESS == code) {

2,147,483,647✔

5796

    *pObj = pList;

2,147,483,647✔

5800

  return code;

2,147,483,647✔

5803

static int32_t msgToSArray(STlv* pTlv, void** pObj){

112,222,500✔

5804

  SArray* pArray = NULL;

112,222,500✔

5805

  uint32_t capacity = 0;

112,222,500✔

5806

  uint32_t elemSize = 0;

112,223,031✔

5807

  uint32_t actualSize;

112,222,446✔

5808

  int32_t decodeFieldNum = 0;;

112,223,031✔

5809

  int32_t code = TSDB_CODE_SUCCESS;

112,223,031✔

5810

  STlvDecoder decoder = {.bufSize = pTlv->len, .offset = 0, .pBuf = pTlv->value};

112,223,031✔

5811

  STlv*   pTlvTemp = NULL;

112,222,500✔

5812

  STlv*   pDataTlv = NULL;

112,223,574✔

5814

  tlvForEach(&decoder, pTlvTemp, code) {

561,113,703✔

5815

    switch (pTlvTemp->type) {

448,892,058✔

5816

      case SARRAY_CODE_CAPACITY:

112,222,122✔

5817

        code = tlvDecodeI32(pTlvTemp, &capacity);

112,222,122✔

5818

        break;

112,223,196✔

5819

      case SARRAY_CODE_ELEMSIZE:

112,223,009✔

5820

        code = tlvDecodeI32(pTlvTemp, &elemSize);

112,223,009✔

5821

        break;

112,223,009✔

5822

      case SARRAY_CODE_SIZE:

112,225,498✔

5823

        code = tlvDecodeI32(pTlvTemp, &actualSize);

112,225,498✔

5824

        break;

112,223,009✔

5825

      case SARRAY_CODE_PDATA:

112,221,429✔

5826

        if (decodeFieldNum < 3) {

112,221,429✔

5830

        pArray = taosArrayInit(capacity, elemSize);

112,221,429✔

5831

        if (NULL == pArray) {

112,223,031✔

5834

        pArray->size = actualSize;

112,223,031✔

5835

        if (TSDB_CODE_SUCCESS != code || pTlvTemp == NULL) {

112,221,451✔

5836

          taosArrayDestroy(pArray);

378✔

5839

        code = tlvDecodeBinary(pTlvTemp, pArray->pData);

112,221,073✔

5840

        break;

112,220,915✔

5844

    decodeFieldNum++;

448,890,129✔

5847

  if (pDataTlv != NULL) {

112,223,735✔

5859

  *pObj = pArray;

112,223,735✔

5860

  return code;

112,221,451✔

5864

static int32_t msgToNodeListFromTlv(STlv* pTlv, void** pObj) {

2,147,483,647✔

5865

  STlvDecoder decoder = {.bufSize = pTlv->len, .offset = 0, .pBuf = pTlv->value};

2,147,483,647✔

5866

  return msgToNodeList(&decoder, pObj);

2,147,483,647✔

5869

int32_t nodesNodeToMsg(const SNode* pNode, char** pMsg, int32_t* pLen) {

522,927,152✔

5870

  if (NULL == pNode || NULL == pMsg || NULL == pLen) {

522,927,152✔

5875

  STlvEncoder encoder;

399,960,483✔

5876

  int32_t     code = initTlvEncoder(&encoder);

523,199,884✔

5877

  if (TSDB_CODE_SUCCESS == code) {

522,298,996✔

5878

    code = nodeToMsg(pNode, &encoder);

522,345,053✔

5880

  if (TSDB_CODE_SUCCESS == code) {

523,037,504✔

5881

    endTlvEncode(&encoder, pMsg, pLen);

523,042,484✔

5883

  clearTlvEncoder(&encoder);

522,432,538✔

5885

  terrno = code;

522,444,953✔

5886

  return code;

522,828,122✔

5889

int32_t nodesMsgToNode(const char* pMsg, int32_t len, SNode** pNode) {

372,801,902✔

5890

  if (NULL == pMsg || NULL == pNode) {

372,801,902✔

5894

  STlvDecoder decoder = {.bufSize = len, .offset = 0, .pBuf = pMsg};

372,826,576✔

5895

  int32_t     code = msgToNode(&decoder, (void**)pNode);

372,829,181✔

5896

  if (TSDB_CODE_SUCCESS != code) {

372,813,792✔

5901

  terrno = code;

372,813,792✔

5902

  return code;

372,759,333✔

taosdata / TDengine / #5011

Source File
Press 'n' to go to next uncovered line, 'b' for previous

taosdata / TDengine / #5011

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