taosdata/TDengine | Build 4986 | source/libs/command/src/explain.c | Coveralls

43

char* qExplainGetDynQryCtrlType(const SDynQueryCtrlPhysiNode* pDyn) {

×

44

  if (NULL == pDyn) {

×

45

    return "unknown task";

×

48

  switch (pDyn->qType) {

×

49

    case DYN_QTYPE_STB_HASH:

×

50

      return "STable Join";

×

51

    case DYN_QTYPE_VTB_SCAN:

×

52

      return "Virtual Stable Scan";

×

53

    case DYN_QTYPE_VTB_WINDOW:

×

54

      return "Virtual Table Window";

×

55

    case DYN_QTYPE_VTB_INTERVAL:

×

56

      return "Virtual Stable Interval";

×

57

    case DYN_QTYPE_VTB_AGG:

×

58

      return "Virtual Stable Agg";

×

59

    case DYN_QTYPE_VTB_TS_SCAN:

×

60

      return "Virtual Stable Ts Scan";

×

61

    default:

×

62

      break;

×

65

  return "unknown task";

×

68

char* qExplainGetAsofOpStr(int32_t opType) {

×

69

  switch (opType) {

×

70

    case OP_TYPE_GREATER_THAN:

×

71

      return ">";

×

72

    case OP_TYPE_GREATER_EQUAL:

×

73

      return ">=";

×

74

    case OP_TYPE_LOWER_THAN:

×

75

      return "<";

×

76

    case OP_TYPE_LOWER_EQUAL:

×

77

      return "<=";

×

78

    case OP_TYPE_EQUAL:

×

79

      return "=";

×

80

    default:

×

81

      return "UNKNOWN";

×

85

char* qExplainGetTimerangeTargetStr(int32_t target) {

×

87

  if (target <= 0 || target > 3) {

×

88

    return "Unknown";

×

91

  return targetName[target];

×

94

void qExplainFreeResNode(SExplainResNode *resNode) {

×

95

  if (NULL == resNode) {

×

96

    return;

×

99

  taosArrayDestroy(resNode->pExecInfo);

×

101

  SNode *node = NULL;

×

102

  FOREACH(node, resNode->pChildren) { qExplainFreeResNode((SExplainResNode *)node); }

×

103

  nodesClearList(resNode->pChildren);

×

105

  taosMemoryFreeClear(resNode);

×

108

void qExplainFreePlanCtx(SExplainPlanCtx* pCtx, bool isAnalyze) {

×

109

  if (isAnalyze && pCtx->groupHash) {

×

110

    void *pIter = taosHashIterate(pCtx->groupHash, NULL);

×

111

    while (pIter) {

×

112

      SExplainGroup *group = (SExplainGroup *)pIter;

×

113

      if (group->nodeExecInfo) {

×

114

        int32_t num = taosArrayGetSize(group->nodeExecInfo);

×

115

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

×

116

          SExplainRsp *rsp = taosArrayGet(group->nodeExecInfo, i);

×

117

          tFreeSExplainRsp(rsp);

×

119

        taosArrayDestroy(group->nodeExecInfo);

×

122

      pIter = taosHashIterate(pCtx->groupHash, pIter);

×

126

  taosHashCleanup(pCtx->groupHash);

×

127

×

134

  int32_t rowSize = taosArrayGetSize(pCtx->rows);

×

135

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

×

136

    SQueryExplainRowInfo *row = taosArrayGet(pCtx->rows, i);

×

137

    taosMemoryFreeClear(row->buf);

×

140

  qExplainFreePlanCtx(&pCtx->planCtx, EXPLAIN_MODE_ANALYZE == pCtx->mode);

×

141

  if (pCtx->subPlanCtxs) {

×

142

    int32_t subNum = taosArrayGetSize(pCtx->subPlanCtxs);

×

143

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

×

144

      SExplainPlanCtx *pSub = taosArrayGet(pCtx->subPlanCtxs, i);

×

145

      qExplainFreePlanCtx(pSub, EXPLAIN_MODE_ANALYZE == pCtx->mode);

×

147

    taosArrayDestroy(pCtx->subPlanCtxs);

×

150

  taosArrayDestroy(pCtx->rows);

×

151

  taosMemoryFreeClear(pCtx->tbuf);

×

152

  taosMemoryFree(pCtx);

×

155

static int32_t qExplainInitCtx(SExplainCtx **pCtx, bool verbose, double ratio, EExplainMode mode) {

×

156

  int32_t      code = 0;

×

157

  SExplainCtx *ctx = taosMemoryCalloc(1, sizeof(SExplainCtx));

×

158

  if (NULL == ctx) {

×

159

    qError("calloc SExplainCtx failed");

×

160

    QRY_ERR_JRET(terrno);

×

163

  SArray *rows = taosArrayInit(10, sizeof(SQueryExplainRowInfo));

×

164

  if (NULL == rows) {

×

165

    qError("taosArrayInit SQueryExplainRowInfo failed");

×

166

    QRY_ERR_JRET(terrno);

×

169

  char *tbuf = taosMemoryMalloc(TSDB_EXPLAIN_RESULT_ROW_SIZE);

×

170

  if (NULL == tbuf) {

×

171

    qError("malloc size %d failed", TSDB_EXPLAIN_RESULT_ROW_SIZE);

×

172

    QRY_ERR_JRET(terrno);

×

175

  ctx->mode = mode;

×

176

  ctx->verbose = verbose;

×

177

  ctx->ratio = ratio;

×

178

  ctx->tbuf = tbuf;

×

179

  ctx->rows = rows;

×

181

  *pCtx = ctx;

×

183

  return TSDB_CODE_SUCCESS;

×

185

_return:

×

187

  taosArrayDestroy(rows);

×

188

  taosMemoryFree(ctx);

×

190

  QRY_RET(code);

×

193

static int32_t qExplainGenerateResChildren(SSubplan *plan, SPhysiNode *pNode, SExplainGroup *group, SNodeList **pChildren) {

×

194

  int32_t    tlen = 0;

×

195

  SNodeList *pPhysiChildren = pNode->pChildren;

×

197

  if (pPhysiChildren) {

×

198

    int32_t code = nodesMakeList(pChildren);

×

199

    if (NULL == *pChildren) {

×

200

      qError("nodesMakeList failed");

×

201

      QRY_ERR_RET(code);

×

205

  SNode           *node = NULL;

×

206

  SExplainResNode *pResNode = NULL;

×

207

  FOREACH(node, pPhysiChildren) {

×

208

    QRY_ERR_RET(qExplainGenerateResNode(plan, (SPhysiNode *)node, group, &pResNode));

×

209

    QRY_ERR_RET(nodesListAppend(*pChildren, (SNode *)pResNode));

×

212

  return TSDB_CODE_SUCCESS;

×

215

static int32_t qExplainGenerateResNodeExecInfo(SPhysiNode *pNode, SArray **pExecInfo, SExplainGroup *group) {

×

216

  *pExecInfo = taosArrayInit(group->nodeNum, sizeof(SExplainExecInfo));

×

217

  if (NULL == (*pExecInfo)) {

×

218

    qError("taosArrayInit %d explainExecInfo failed", group->nodeNum);

×

219

    return terrno;

×

222

  SExplainRsp *rsp = NULL;

×

223

  if (group->singleChannel) {

×

224

    if (0 == group->physiPlanExecIdx) {

×

225

      group->nodeIdx = 0;

×

228

    rsp = taosArrayGet(group->nodeExecInfo, group->nodeIdx++);

×

229

    if (group->physiPlanExecIdx >= rsp->numOfPlans) {

×

230

      qError("physiPlanIdx %d exceed plan num %d", group->physiPlanExecIdx, rsp->numOfPlans);

×

231

      return TSDB_CODE_APP_ERROR;

×

234

    if(taosArrayPush(*pExecInfo, rsp->subplanInfo + group->physiPlanExecIdx) == NULL) return terrno;

×

236

    for (int32_t i = 0; i < group->nodeNum; ++i) {

×

237

      rsp = taosArrayGet(group->nodeExecInfo, i);

×

238

      if (group->physiPlanExecIdx >= rsp->numOfPlans) {

×

239

        qError("physiPlanIdx %d exceed plan num %d", group->physiPlanExecIdx, rsp->numOfPlans);

×

240

        return TSDB_CODE_APP_ERROR;

×

243

      if(taosArrayPush(*pExecInfo, rsp->subplanInfo + group->physiPlanExecIdx) == NULL) return terrno;

×

247

  ++group->physiPlanExecIdx;

×

249

  return TSDB_CODE_SUCCESS;

×

252

static int32_t qExplainGenerateResNode(SSubplan *plan, SPhysiNode *pNode, SExplainGroup *group, SExplainResNode **pResNode) {

×

253

  if (NULL == pNode) {

×

254

    *pResNode = NULL;

×

255

    qError("physical node is NULL");

×

256

    return TSDB_CODE_APP_ERROR;

×

259

  SExplainResNode *resNode = taosMemoryCalloc(1, sizeof(SExplainResNode));

×

260

  if (NULL == resNode) {

×

261

    qError("calloc SPhysiNodeExplainRes failed");

×

262

    return terrno;

×

265

  int32_t code = 0;

×

266

  resNode->pNode = pNode;

×

267

  resNode->pPlan = plan;

×

269

  if (group->nodeExecInfo) {

×

270

    QRY_ERR_JRET(qExplainGenerateResNodeExecInfo(pNode, &resNode->pExecInfo, group));

×

273

  QRY_ERR_JRET(qExplainGenerateResChildren(plan, pNode, group, &resNode->pChildren));

×

275

  *pResNode = resNode;

×

277

  return TSDB_CODE_SUCCESS;

×

279

_return:

×

281

  qExplainFreeResNode(resNode);

×

283

  QRY_RET(code);

×

286

static int32_t qExplainBufAppendExecInfo(SArray *pExecInfo, char *tbuf, int32_t *len) {

×

287

  int32_t          tlen = *len;

×

288

  int32_t          nodeNum = taosArrayGetSize(pExecInfo);

×

289

  SExplainExecInfo maxExecInfo = {0};

×

291

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

×

292

    SExplainExecInfo *execInfo = taosArrayGet(pExecInfo, i);

×

293

    if (execInfo->startupCost > maxExecInfo.startupCost) {

×

294

      maxExecInfo.startupCost = execInfo->startupCost;

×

296

    if (execInfo->totalCost > maxExecInfo.totalCost) {

×

297

      maxExecInfo.totalCost = execInfo->totalCost;

×

299

    if (execInfo->numOfRows > maxExecInfo.numOfRows) {

×

300

      maxExecInfo.numOfRows = execInfo->numOfRows;

×

304

  EXPLAIN_ROW_APPEND(EXPLAIN_EXECINFO_FORMAT, maxExecInfo.startupCost, maxExecInfo.totalCost, maxExecInfo.numOfRows);

×

306

  *len = tlen;

×

308

  return TSDB_CODE_SUCCESS;

×

311

static int32_t qExplainBufAppendVerboseExecInfo(SArray *pExecInfo, char *tbuf, int32_t *len) {

×

312

  int32_t          tlen = 0;

×

313

  bool             gotVerbose = false;

×

314

  int32_t          nodeNum = taosArrayGetSize(pExecInfo);

×

315

  SExplainExecInfo maxExecInfo = {0};

×

317

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

×

318

    SExplainExecInfo *execInfo = taosArrayGet(pExecInfo, i);

×

319

    if (execInfo->verboseInfo) {

×

320

      gotVerbose = true;

×

324

  if (gotVerbose) {

×

325

    EXPLAIN_ROW_APPEND("exec verbose info");

×

328

  *len = tlen;

×

330

  return TSDB_CODE_SUCCESS;

×

333

static int32_t qExplainResAppendRow(SExplainCtx *ctx, char *tbuf, int32_t len, int32_t level) {

×

334

  SQueryExplainRowInfo row = {0};

×

335

  row.buf = taosMemoryMalloc(len);

×

336

  if (NULL == row.buf) {

×

337

    qError("taosMemoryMalloc %d failed", len);

×

338

    QRY_ERR_RET(terrno);

×

341

  memcpy(row.buf, tbuf, len);

×

342

  row.level = level;

×

343

  row.len = len;

×

344

  ctx->dataSize += row.len;

×

346

  if (NULL == taosArrayPush(ctx->rows, &row)) {

×

347

    qError("taosArrayPush row to explain res rows failed");

×

348

    taosMemoryFree(row.buf);

×

349

    QRY_ERR_RET(terrno);

×

352

  return TSDB_CODE_SUCCESS;

×

355

static uint8_t qExplainGetIntervalPrecision(SIntervalPhysiNode *pIntNode) {

×

356

  return ((SColumnNode *)pIntNode->window.pTspk)->node.resType.precision;

×

359

static char* qExplainGetScanMode(STableScanPhysiNode* pScan) {

×

360

  bool isGroupByTbname = false;

×

361

  bool isGroupByTag = false;

×

362

  bool seq = false;

×

363

  bool groupOrder = false;

×

364

  if (pScan->pGroupTags && LIST_LENGTH(pScan->pGroupTags) == 1) {

×

365

    SNode* p = nodesListGetNode(pScan->pGroupTags, 0);

×

366

    if (QUERY_NODE_FUNCTION == nodeType(p) && (strcmp(((struct SFunctionNode*)p)->functionName, "tbname") == 0)) {

×

367

      isGroupByTbname = true;

×

371

  isGroupByTag = (NULL != pScan->pGroupTags) && !isGroupByTbname;

×

372

  if ((((!isGroupByTag) || isGroupByTbname) && pScan->groupSort) || (isGroupByTag && (pScan->groupSort || pScan->scan.groupOrderScan))) {

×

373

    return "seq_grp_order";

×

376

  if ((isGroupByTbname && (pScan->groupSort || pScan->scan.groupOrderScan)) || (isGroupByTag && (pScan->groupSort || pScan->scan.groupOrderScan))) {

×

377

    return "grp_order";

×

380

  return "ts_order";

×

383

static char* qExplainGetScanDataLoad(STableScanPhysiNode* pScan) {

×

384

  switch (pScan->dataRequired) {

×

385

    case FUNC_DATA_REQUIRED_DATA_LOAD:

×

386

      return "data";

×

387

    case FUNC_DATA_REQUIRED_SMA_LOAD:

×

388

      return "sma";

×

389

    case FUNC_DATA_REQUIRED_NOT_LOAD:

×

390

      return "no";

×

391

    default:

×

392

      break;

×

395

  return "unknown";

×

398

static EDealRes qExplainVerifyIndex(SNode* pNode, void* pContext) {

×

399

  if (NULL == pNode) {

×

400

    return DEAL_RES_CONTINUE;

×

403

  switch (nodeType(pNode)) {

×

404

    case QUERY_NODE_COLUMN:

×

408

      break;

×

409

    case QUERY_NODE_OPERATOR: {

×

410

      SOperatorNode* pOp = (SOperatorNode*)pNode;

×

411

      if ((pOp->opType >= OP_TYPE_GREATER_THAN && pOp->opType <= OP_TYPE_EQUAL) || (OP_TYPE_IN == pOp->opType)) {

×

417

      *(bool*)pContext = false;

×

418

      return DEAL_RES_END;

×

421

  return DEAL_RES_CONTINUE;

×

424

static bool qExplainCouldApplyTagIndex(SSubplan* pPlan) {

×

425

  if (NULL == pPlan->pTagIndexCond) {

×

426

    return false;

×

429

  bool couldApply = true;

×

430

  nodesWalkExpr(pPlan->pTagIndexCond, qExplainVerifyIndex, &couldApply);

×

432

  return couldApply;

×

435

static int32_t qExplainResNodeToRowsImpl(SExplainResNode *pResNode, SExplainCtx *ctx, int32_t *pLevel) {

×

436

  int32_t     tlen = 0;

×

437

  bool        isVerboseLine = false;

×

438

  char       *tbuf = ctx->tbuf;

×

439

  bool        verbose = ctx->verbose;

×

440

  SPhysiNode *pNode = pResNode->pNode;

×

441

  if (NULL == pNode) {

×

442

    qError("pyhsical node in explain res node is NULL");

×

443

    return TSDB_CODE_APP_ERROR;

×

446

  if (0 == *pLevel && ctx->currPlanId >= 0) {

×

447

    EXPLAIN_SUB_PLAN_LINE(ctx->currPlanId + 1);

×

448

    QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, *pLevel + 1));

×

449

    *pLevel += 2;

×

452

  int32_t level = *pLevel;

×

454

  switch (pNode->type) {

×

455

    case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN: {

×

456

      STagScanPhysiNode *pTagScanNode = (STagScanPhysiNode *)pNode;

×

457

      EXPLAIN_ROW_NEW(level, EXPLAIN_TAG_SCAN_FORMAT, pTagScanNode->scan.tableName.tname);

×

458

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

459

      if (pResNode->pExecInfo) {

×

460

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

461

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

463

      if (pTagScanNode->scan.pScanPseudoCols) {

×

464

        EXPLAIN_ROW_APPEND(EXPLAIN_PSEUDO_COLUMNS_FORMAT, pTagScanNode->scan.pScanPseudoCols->length);

×

465

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

467

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pTagScanNode->scan.node.pOutputDataBlockDesc->totalRowSize);

×

468

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

469

      EXPLAIN_ROW_END();

×

470

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

472

      if (verbose) {

×

473

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

474

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

476

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

477

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pTagScanNode->scan.node.pOutputDataBlockDesc->outputRowSize);

×

478

        EXPLAIN_ROW_APPEND_LIMIT(pTagScanNode->scan.node.pLimit);

×

479

        EXPLAIN_ROW_APPEND_SLIMIT(pTagScanNode->scan.node.pSlimit);

×

480

        EXPLAIN_ROW_END();

×

481

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

483

        if (pResNode->pExecInfo) {

×

484

          QRY_ERR_RET(qExplainBufAppendVerboseExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

485

          if (tlen) {

×

486

            EXPLAIN_ROW_END();

×

487

            QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

491

        if (pTagScanNode->scan.node.pConditions) {

×

492

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

493

          QRY_ERR_RET(nodesNodeToSQL(pTagScanNode->scan.node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

495

          EXPLAIN_ROW_END();

×

496

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

499

        if (qExplainCouldApplyTagIndex(pResNode->pPlan)) {

×

500

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_TAG_INDEX_FORMAT);

×

501

          QRY_ERR_RET(nodesNodeToSQL(pResNode->pPlan->pTagIndexCond, tbuf + VARSTR_HEADER_SIZE,

×

503

          EXPLAIN_ROW_END();

×

504

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

507

      break;

×

509

    case QUERY_NODE_PHYSICAL_PLAN_VIRTUAL_TABLE_SCAN: {

×

510

      SVirtualScanPhysiNode *pVirtualTableScanNode = (SVirtualScanPhysiNode *)pNode;

×

511

      EXPLAIN_ROW_NEW(level, EXPLAIN_VIRTUAL_TABLE_SCAN_FORMAT, pVirtualTableScanNode->scan.tableName.tname);

×

512

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

513

      if (pResNode->pExecInfo) {

×

514

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

515

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

517

      EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, pVirtualTableScanNode->scan.pScanCols->length);

×

518

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

519

      if (pVirtualTableScanNode->scan.pScanPseudoCols) {

×

520

        EXPLAIN_ROW_APPEND(EXPLAIN_PSEUDO_COLUMNS_FORMAT, pVirtualTableScanNode->scan.pScanPseudoCols->length);

×

521

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

523

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pVirtualTableScanNode->scan.node.pOutputDataBlockDesc->totalRowSize);

×

524

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

525

      EXPLAIN_ROW_END();

×

526

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

528

      if (verbose) {

×

529

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

530

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

532

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

533

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pVirtualTableScanNode->scan.node.pOutputDataBlockDesc->outputRowSize);

×

534

        EXPLAIN_ROW_APPEND_LIMIT(pVirtualTableScanNode->scan.node.pLimit);

×

535

        EXPLAIN_ROW_APPEND_SLIMIT(pVirtualTableScanNode->scan.node.pSlimit);

×

536

        EXPLAIN_ROW_END();

×

537

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

539

        if (pResNode->pExecInfo) {

×

540

          QRY_ERR_RET(qExplainBufAppendVerboseExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

541

          if (tlen) {

×

542

            EXPLAIN_ROW_END();

×

543

            QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

547

        if (pVirtualTableScanNode->scan.node.pConditions) {

×

548

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

549

          QRY_ERR_RET(nodesNodeToSQL(pVirtualTableScanNode->scan.node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

551

          EXPLAIN_ROW_END();

×

552

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

555

      break;

×

557

    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN:

×

560

      STableScanPhysiNode *pTblScanNode = (STableScanPhysiNode *)pNode;

×

561

      EXPLAIN_ROW_NEW(level,

×

565

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

566

      if (pResNode->pExecInfo) {

×

567

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

568

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

571

      EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, pTblScanNode->scan.pScanCols->length);

×

572

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

573

      if (pTblScanNode->scan.pScanPseudoCols) {

×

574

        EXPLAIN_ROW_APPEND(EXPLAIN_PSEUDO_COLUMNS_FORMAT, pTblScanNode->scan.pScanPseudoCols->length);

×

575

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

577

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pTblScanNode->scan.node.pOutputDataBlockDesc->totalRowSize);

×

578

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

579

      EXPLAIN_ROW_APPEND(EXPLAIN_SCAN_ORDER_FORMAT, pTblScanNode->scanSeq[0], pTblScanNode->scanSeq[1]);

×

580

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

581

      EXPLAIN_ROW_APPEND(EXPLAIN_SCAN_MODE_FORMAT, qExplainGetScanMode(pTblScanNode));

×

582

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

583

      EXPLAIN_ROW_APPEND(EXPLAIN_SCAN_DATA_LOAD_FORMAT, qExplainGetScanDataLoad(pTblScanNode));

×

584

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

585

      EXPLAIN_ROW_END();

×

586

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

589

      if (EXPLAIN_MODE_ANALYZE == ctx->mode) {

×

590

        EXPLAIN_ROW_NEW(level + 1, "I/O: ");

×

592

        int32_t                      nodeNum = taosArrayGetSize(pResNode->pExecInfo);

×

593

        struct STableScanAnalyzeInfo info = {0};

×

595

        int32_t maxIndex = 0;

×

596

        int32_t totalRows = 0;

×

597

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

×

598

          SExplainExecInfo      *execInfo = taosArrayGet(pResNode->pExecInfo, i);

×

599

          STableScanAnalyzeInfo *pScanInfo = (STableScanAnalyzeInfo *)execInfo->verboseInfo;

×

601

          info.totalBlocks += pScanInfo->totalBlocks;

×

602

          info.loadBlocks += pScanInfo->loadBlocks;

×

603

          info.totalRows += pScanInfo->totalRows;

×

604

          info.skipBlocks += pScanInfo->skipBlocks;

×

605

          info.filterTime += pScanInfo->filterTime;

×

606

          info.loadBlockStatis += pScanInfo->loadBlockStatis;

×

607

          info.totalCheckedRows += pScanInfo->totalCheckedRows;

×

608

          info.filterOutBlocks += pScanInfo->filterOutBlocks;

×

610

          if (pScanInfo->totalRows > totalRows) {

×

611

            totalRows = pScanInfo->totalRows;

×

612

            maxIndex = i;

×

616

        EXPLAIN_ROW_APPEND("total_blocks=%.1f", ((double)info.totalBlocks) / nodeNum);

×

617

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

619

        EXPLAIN_ROW_APPEND("load_blocks=%.1f", ((double)info.loadBlocks) / nodeNum);

×

620

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

622

        EXPLAIN_ROW_APPEND("load_block_SMAs=%.1f", ((double)info.loadBlockStatis) / nodeNum);

×

623

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

625

        EXPLAIN_ROW_APPEND("total_rows=%.1f", ((double)info.totalRows) / nodeNum);

×

626

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

628

        EXPLAIN_ROW_APPEND("check_rows=%.1f", ((double)info.totalCheckedRows) / nodeNum);

×

629

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

630

        EXPLAIN_ROW_END();

×

632

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

636

        SExplainExecInfo      *execInfo = taosArrayGet(pResNode->pExecInfo, maxIndex);

×

637

        STableScanAnalyzeInfo *p1 = (STableScanAnalyzeInfo *)execInfo->verboseInfo;

×

639

        EXPLAIN_ROW_NEW(level + 1, " ");

×

640

        EXPLAIN_ROW_APPEND("max_row_task=%d, total_rows:%" PRId64 ", ep:%s (cost=%.3f..%.3f)", maxIndex, p1->totalRows,

×

642

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

643

        EXPLAIN_ROW_END();

×

645

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

648

      if (verbose) {

×

649

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

650

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

652

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

653

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pTblScanNode->scan.node.pOutputDataBlockDesc->outputRowSize);

×

654

        EXPLAIN_ROW_APPEND_LIMIT(pTblScanNode->scan.node.pLimit);

×

655

        EXPLAIN_ROW_APPEND_SLIMIT(pTblScanNode->scan.node.pSlimit);

×

656

        EXPLAIN_ROW_END();

×

657

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

659

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_TIMERANGE_FORMAT, pTblScanNode->scanRange.skey,

×

661

        EXPLAIN_ROW_END();

×

662

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

664

        if (NULL != pTblScanNode->pGroupTags) {

×

665

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_PARTITION_KETS_FORMAT);

×

666

          EXPLAIN_ROW_APPEND(EXPLAIN_PARTITIONS_FORMAT, pTblScanNode->pGroupTags->length);

×

667

          EXPLAIN_ROW_END();

×

668

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

671

        if (pTblScanNode->scan.node.pConditions) {

×

672

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

673

          QRY_ERR_RET(nodesNodeToSQL(pTblScanNode->scan.node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

675

          EXPLAIN_ROW_END();

×

676

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

679

        if (pTblScanNode->pPrimaryCond) {

×

680

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_PRIMARY_FILTER_FORMAT);

×

681

          QRY_ERR_RET(nodesNodeToSQL(pTblScanNode->pPrimaryCond, tbuf + VARSTR_HEADER_SIZE,

×

683

          EXPLAIN_ROW_END();

×

684

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

687

        if (qExplainCouldApplyTagIndex(pResNode->pPlan)) {

×

688

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_TAG_INDEX_FORMAT);

×

689

          QRY_ERR_RET(nodesNodeToSQL(pResNode->pPlan->pTagIndexCond, tbuf + VARSTR_HEADER_SIZE,

×

691

          EXPLAIN_ROW_END();

×

692

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

695

      break;

×

697

    case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN: {

×

698

      SSystemTableScanPhysiNode *pSTblScanNode = (SSystemTableScanPhysiNode *)pNode;

×

699

      EXPLAIN_ROW_NEW(level, EXPLAIN_SYSTBL_SCAN_FORMAT, pSTblScanNode->scan.tableName.tname);

×

700

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

701

      if (pResNode->pExecInfo) {

×

702

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

703

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

705

      EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, pSTblScanNode->scan.pScanCols->length);

×

706

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

707

      if (pSTblScanNode->scan.pScanPseudoCols) {

×

708

        EXPLAIN_ROW_APPEND(EXPLAIN_PSEUDO_COLUMNS_FORMAT, pSTblScanNode->scan.pScanPseudoCols->length);

×

709

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

711

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pSTblScanNode->scan.node.pOutputDataBlockDesc->totalRowSize);

×

712

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

713

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

714

      EXPLAIN_ROW_END();

×

715

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

717

      if (verbose) {

×

718

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

719

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

721

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

722

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pSTblScanNode->scan.node.pOutputDataBlockDesc->outputRowSize);

×

723

        EXPLAIN_ROW_APPEND_LIMIT(pSTblScanNode->scan.node.pLimit);

×

724

        EXPLAIN_ROW_APPEND_SLIMIT(pSTblScanNode->scan.node.pSlimit);

×

725

        EXPLAIN_ROW_END();

×

726

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

728

        if (pSTblScanNode->scan.node.pConditions) {

×

729

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

730

          QRY_ERR_RET(nodesNodeToSQL(pSTblScanNode->scan.node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

732

          EXPLAIN_ROW_END();

×

733

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

736

      break;

×

738

    case QUERY_NODE_PHYSICAL_PLAN_PROJECT: {

×

739

      SProjectPhysiNode *pPrjNode = (SProjectPhysiNode *)pNode;

×

740

      EXPLAIN_ROW_NEW(level, EXPLAIN_PROJECTION_FORMAT);

×

741

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

742

      if (pResNode->pExecInfo) {

×

743

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

744

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

746

      EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, pPrjNode->pProjections->length);

×

747

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

748

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pPrjNode->node.pOutputDataBlockDesc->totalRowSize);

×

749

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

750

      EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pPrjNode->node.inputTsOrder));

×

751

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

752

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

753

      EXPLAIN_ROW_END();

×

754

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

756

      if (verbose) {

×

757

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

758

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

760

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

761

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pPrjNode->node.pOutputDataBlockDesc->outputRowSize);

×

762

        EXPLAIN_ROW_APPEND_LIMIT(pPrjNode->node.pLimit);

×

763

        EXPLAIN_ROW_APPEND_SLIMIT(pPrjNode->node.pSlimit);

×

764

        EXPLAIN_ROW_END();

×

765

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

767

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

768

        EXPLAIN_ROW_APPEND(EXPLAIN_IGNORE_GROUPID_FORMAT, pPrjNode->ignoreGroupId ? "true" : "false");

×

769

        EXPLAIN_ROW_END();

×

770

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

772

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_MERGEBLOCKS_FORMAT, pPrjNode->mergeDataBlock? "True":"False");

×

773

        EXPLAIN_ROW_END();

×

774

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

776

        if (pPrjNode->node.pConditions) {

×

777

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

778

          QRY_ERR_RET(nodesNodeToSQL(pPrjNode->node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

780

          EXPLAIN_ROW_END();

×

781

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

784

      break;

×

786

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN: {

×

787

      SSortMergeJoinPhysiNode *pJoinNode = (SSortMergeJoinPhysiNode *)pNode;

×

788

      EXPLAIN_ROW_NEW(level, EXPLAIN_JOIN_FORMAT, gJoinTypeStr[pJoinNode->joinType][pJoinNode->subType]);

×

789

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

790

      if (pResNode->pExecInfo) {

×

791

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

792

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

794

      EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, pJoinNode->pTargets->length);

×

795

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

796

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pJoinNode->node.pOutputDataBlockDesc->totalRowSize);

×

797

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

798

      EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pJoinNode->node.inputTsOrder));

×

799

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

800

      EXPLAIN_ROW_APPEND(EXPLAIN_JOIN_ALGO, "Merge");

×

801

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

802

      EXPLAIN_ROW_END();

×

803

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

805

      if (verbose) {

×

806

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

807

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

809

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

810

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pJoinNode->node.pOutputDataBlockDesc->outputRowSize);

×

811

        EXPLAIN_ROW_APPEND_LIMIT(pJoinNode->node.pLimit);

×

812

        EXPLAIN_ROW_APPEND_SLIMIT(pJoinNode->node.pSlimit);

×

813

        EXPLAIN_ROW_END();

×

814

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

816

        if (IS_ASOF_JOIN(pJoinNode->subType) || IS_WINDOW_JOIN(pJoinNode->subType)) {

×

817

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_JOIN_PARAM_FORMAT);

×

818

          if (IS_ASOF_JOIN(pJoinNode->subType)) {

×

819

            EXPLAIN_ROW_APPEND(EXPLAIN_ASOF_OP_FORMAT, qExplainGetAsofOpStr(pJoinNode->asofOpType));

×

820

            EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

822

          if (NULL != pJoinNode->pWindowOffset) {

×

823

            SWindowOffsetNode* pWinOffset = (SWindowOffsetNode*)pJoinNode->pWindowOffset;

×

824

            SValueNode* pStart = (SValueNode*)pWinOffset->pStartOffset;

×

825

            SValueNode* pEnd = (SValueNode*)pWinOffset->pEndOffset;

×

826

            EXPLAIN_ROW_APPEND(EXPLAIN_WIN_OFFSET_FORMAT, pStart->literal, pEnd->literal);

×

827

            EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

829

          if (NULL != pJoinNode->pJLimit && NULL != ((SLimitNode*)pJoinNode->pJLimit)->limit) {

×

830

            SLimitNode* pJLimit = (SLimitNode*)pJoinNode->pJLimit;

×

831

            EXPLAIN_ROW_APPEND(EXPLAIN_JLIMIT_FORMAT, pJLimit->limit->datum.i);

×

832

            EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

834

          if (IS_WINDOW_JOIN(pJoinNode->subType)) {

×

835

            EXPLAIN_ROW_APPEND(EXPLAIN_SEQ_WIN_GRP_FORMAT, pJoinNode->seqWinGroup);

×

836

            EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

839

          EXPLAIN_ROW_APPEND(EXPLAIN_GRP_JOIN_FORMAT, pJoinNode->grpJoin);

×

840

          EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

841

          EXPLAIN_ROW_END();

×

843

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

846

        if (pJoinNode->node.pConditions) {

×

847

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

848

          QRY_ERR_RET(nodesNodeToSQL(pJoinNode->node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

850

          EXPLAIN_ROW_END();

×

851

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

854

        if (NULL != pJoinNode->pPrimKeyCond) {

×

855

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_PRIM_CONDITIONS_FORMAT);

×

856

          QRY_ERR_RET(nodesNodeToSQL(pJoinNode->pPrimKeyCond, tbuf + VARSTR_HEADER_SIZE, TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen));

×

857

          EXPLAIN_ROW_END();

×

858

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

861

        if (NULL != pJoinNode->pEqLeft && pJoinNode->pEqLeft->length > 0) {

×

862

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_JOIN_EQ_LEFT_FORMAT);

×

863

          SNode* pCol = NULL;

×

864

          FOREACH(pCol, pJoinNode->pEqLeft) {

×

865

            EXPLAIN_ROW_APPEND("`%s`.`%s` ", ((SColumnNode*)pCol)->tableAlias, ((SColumnNode*)pCol)->colName);

×

867

          EXPLAIN_ROW_END();

×

868

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

871

        if (NULL != pJoinNode->pEqRight && pJoinNode->pEqRight->length > 0) {

×

872

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_JOIN_EQ_RIGHT_FORMAT);

×

873

          SNode* pCol = NULL;

×

874

          FOREACH(pCol, pJoinNode->pEqRight) {

×

875

            EXPLAIN_ROW_APPEND("`%s`.`%s` ", ((SColumnNode*)pCol)->tableAlias, ((SColumnNode*)pCol)->colName);

×

877

          EXPLAIN_ROW_END();

×

878

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

881

        if (NULL != pJoinNode->pFullOnCond) {

×

882

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_ON_CONDITIONS_FORMAT);

×

883

          QRY_ERR_RET(

×

885

          EXPLAIN_ROW_END();

×

886

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

889

        if (NULL != pJoinNode->pColOnCond) {

×

890

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_COL_ON_CONDITIONS_FORMAT);

×

891

          QRY_ERR_RET(

×

893

          EXPLAIN_ROW_END();

×

894

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

897

      break;

×

899

    case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG: {

×

900

      SAggPhysiNode *pAggNode = (SAggPhysiNode *)pNode;

×

901

      EXPLAIN_ROW_NEW(level, EXPLAIN_AGG_FORMAT, (pAggNode->pGroupKeys ? "GroupAggregate" : "Aggregate"));

×

902

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

903

      if (pResNode->pExecInfo) {

×

904

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

905

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

907

      if (pAggNode->pAggFuncs) {

×

908

        EXPLAIN_ROW_APPEND(EXPLAIN_FUNCTIONS_FORMAT, pAggNode->pAggFuncs->length);

×

909

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

911

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pAggNode->node.pOutputDataBlockDesc->totalRowSize);

×

912

      if (pAggNode->pGroupKeys) {

×

913

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

914

        EXPLAIN_ROW_APPEND(EXPLAIN_GROUPS_FORMAT, pAggNode->pGroupKeys->length);

×

916

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

917

      EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pAggNode->node.inputTsOrder));

×

918

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

919

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

920

      EXPLAIN_ROW_END();

×

921

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

923

      if (verbose) {

×

924

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

925

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

927

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

928

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pAggNode->node.pOutputDataBlockDesc->outputRowSize);

×

929

        EXPLAIN_ROW_APPEND_LIMIT(pAggNode->node.pLimit);

×

930

        EXPLAIN_ROW_APPEND_SLIMIT(pAggNode->node.pSlimit);

×

931

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

932

        EXPLAIN_ROW_APPEND(EXPLAIN_PLAN_BLOCKING, !pAggNode->node.forceCreateNonBlockingOptr);

×

933

        EXPLAIN_ROW_END();

×

934

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

936

        if (pAggNode->node.pConditions) {

×

937

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

938

          QRY_ERR_RET(nodesNodeToSQL(pAggNode->node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

940

          EXPLAIN_ROW_END();

×

941

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

944

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_MERGEBLOCKS_FORMAT, pAggNode->mergeDataBlock? "True":"False");

×

945

        EXPLAIN_ROW_END();

×

946

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

948

      break;

×

950

    case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC: {

×

951

      SIndefRowsFuncPhysiNode *pIndefNode = (SIndefRowsFuncPhysiNode *)pNode;

×

952

      EXPLAIN_ROW_NEW(level, EXPLAIN_INDEF_ROWS_FORMAT);

×

953

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

954

      if (pResNode->pExecInfo) {

×

955

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

956

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

958

      if (pIndefNode->pFuncs) {

×

959

        EXPLAIN_ROW_APPEND(EXPLAIN_FUNCTIONS_FORMAT, pIndefNode->pFuncs->length);

×

960

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

962

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pIndefNode->node.pOutputDataBlockDesc->totalRowSize);

×

963

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

964

      EXPLAIN_ROW_END();

×

965

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

967

      if (verbose) {

×

968

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

969

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

971

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

972

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pIndefNode->node.pOutputDataBlockDesc->outputRowSize);

×

973

        EXPLAIN_ROW_APPEND_LIMIT(pIndefNode->node.pLimit);

×

974

        EXPLAIN_ROW_APPEND_SLIMIT(pIndefNode->node.pSlimit);

×

975

        EXPLAIN_ROW_END();

×

976

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

978

        if (pIndefNode->node.pConditions) {

×

979

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

980

          QRY_ERR_RET(nodesNodeToSQL(pIndefNode->node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

982

          EXPLAIN_ROW_END();

×

983

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

986

      break;

×

988

    case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE: {

×

989

      SExchangePhysiNode *pExchNode = (SExchangePhysiNode *)pNode;

×

990

      int32_t nodeNum = 0;

×

991

      for (int32_t i = pExchNode->srcStartGroupId; i <= pExchNode->srcEndGroupId; ++i) {

×

992

        SExplainGroup      *group = taosHashGet(ctx->pCurrPlanCtx->groupHash, &pExchNode->srcStartGroupId, sizeof(pExchNode->srcStartGroupId));

×

993

        if (NULL == group) {

×

994

          qError("exchange src group %d not in groupHash", pExchNode->srcStartGroupId);

×

995

          QRY_ERR_RET(TSDB_CODE_APP_ERROR);

×

998

        nodeNum += group->nodeNum;

×

1001

      EXPLAIN_ROW_NEW(level, EXPLAIN_EXCHANGE_FORMAT, pExchNode->singleSrc ? 1 : nodeNum);

×

1002

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

1003

      if (pResNode->pExecInfo) {

×

1004

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

1005

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1007

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pExchNode->node.pOutputDataBlockDesc->totalRowSize);

×

1008

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

1009

      EXPLAIN_ROW_END();

×

1010

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1012

      if (verbose) {

×

1013

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

1014

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

1016

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1017

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pExchNode->node.pOutputDataBlockDesc->outputRowSize);

×

1018

        EXPLAIN_ROW_APPEND_LIMIT(pExchNode->node.pLimit);

×

1019

        EXPLAIN_ROW_APPEND_SLIMIT(pExchNode->node.pSlimit);

×

1020

        EXPLAIN_ROW_END();

×

1021

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1023

        if (pExchNode->node.pConditions) {

×

1024

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

1025

          QRY_ERR_RET(nodesNodeToSQL(pExchNode->node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

1027

          EXPLAIN_ROW_END();

×

1028

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1032

      for (int32_t i = pExchNode->srcStartGroupId; i <= pExchNode->srcEndGroupId; ++i) {

×

1033

        int32_t nlevel = level + 1;

×

1034

        QRY_ERR_RET(qExplainAppendGroupResRows(ctx, i, &nlevel, pExchNode->grpSingleChannel));

×

1036

      break;

×

1038

    case QUERY_NODE_PHYSICAL_PLAN_SORT: {

×

1039

      SSortPhysiNode *pSortNode = (SSortPhysiNode *)pNode;

×

1040

      EXPLAIN_ROW_NEW(level, EXPLAIN_SORT_FORMAT);

×

1041

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1042

      EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pSortNode->node.inputTsOrder));

×

1043

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1044

      EXPLAIN_ROW_APPEND(EXPLAIN_OUTPUT_ORDER_TYPE_FORMAT, EXPLAIN_ORDER_STRING(pSortNode->node.outputTsOrder));

×

1045

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1046

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

1047

      if (pResNode->pExecInfo) {

×

1048

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

1049

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1052

      SDataBlockDescNode *pDescNode = pSortNode->node.pOutputDataBlockDesc;

×

1053

      EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, nodesGetOutputNumFromSlotList(pDescNode->pSlots));

×

1054

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1055

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pDescNode->totalRowSize);

×

1056

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

1057

      EXPLAIN_ROW_END();

×

1058

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1060

      if (pResNode->pExecInfo) {

×

1062

        EXPLAIN_ROW_NEW(level + 1, "Sort Key: ");

×

1063

        for (int32_t i = 0; i < LIST_LENGTH(pSortNode->pSortKeys); ++i) {

×

1064

          SOrderByExprNode *ptn = (SOrderByExprNode *)nodesListGetNode(pSortNode->pSortKeys, i);

×

1065

          EXPLAIN_ROW_APPEND("%s ", nodesGetNameFromColumnNode(ptn->pExpr));

×

1068

        EXPLAIN_ROW_END();

×

1069

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1072

        EXPLAIN_ROW_NEW(level + 1, "Sort Method: ");

×

1074

        int32_t           nodeNum = taosArrayGetSize(pResNode->pExecInfo);

×

1075

        SExplainExecInfo *execInfo = taosArrayGet(pResNode->pExecInfo, 0);

×

1076

        SSortExecInfo    *pExecInfo = (SSortExecInfo *)execInfo->verboseInfo;

×

1077

        EXPLAIN_ROW_APPEND("%s", pExecInfo->sortMethod == SORT_QSORT_T ? "quicksort" : "merge sort");

×

1078

        if (pExecInfo->sortBuffer > 1024 * 1024) {

×

1079

          EXPLAIN_ROW_APPEND("  Buffers:%.2f Mb", pExecInfo->sortBuffer / (1024 * 1024.0));

×

1080

        } else if (pExecInfo->sortBuffer > 1024) {

×

1081

          EXPLAIN_ROW_APPEND("  Buffers:%.2f Kb", pExecInfo->sortBuffer / (1024.0));

×

1083

          EXPLAIN_ROW_APPEND("  Buffers:%d b", pExecInfo->sortBuffer);

×

1086

        EXPLAIN_ROW_APPEND("  loops:%d", pExecInfo->loops);

×

1087

        EXPLAIN_ROW_END();

×

1088

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1091

      if (verbose) {

×

1092

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

1093

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

1095

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1096

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pSortNode->node.pOutputDataBlockDesc->outputRowSize);

×

1097

        EXPLAIN_ROW_APPEND_LIMIT(pSortNode->node.pLimit);

×

1098

        EXPLAIN_ROW_APPEND_SLIMIT(pSortNode->node.pSlimit);

×

1099

        EXPLAIN_ROW_END();

×

1100

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1102

        if (pSortNode->node.pConditions) {

×

1103

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

1104

          QRY_ERR_RET(nodesNodeToSQL(pSortNode->node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

1106

          EXPLAIN_ROW_END();

×

1107

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1110

      break;

×

1112

    case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL: {

×

1113

      SIntervalPhysiNode *pIntNode = (SIntervalPhysiNode *)pNode;

×

1114

      EXPLAIN_ROW_NEW(level, EXPLAIN_INTERVAL_FORMAT, nodesGetNameFromColumnNode(pIntNode->window.pTspk));

×

1115

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

1116

      if (pResNode->pExecInfo) {

×

1117

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

1118

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1120

      EXPLAIN_ROW_APPEND(EXPLAIN_FUNCTIONS_FORMAT, LIST_LENGTH(pIntNode->window.pFuncs));

×

1121

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1122

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pIntNode->window.node.pOutputDataBlockDesc->totalRowSize);

×

1123

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1124

      EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pIntNode->window.node.inputTsOrder));

×

1125

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1126

      EXPLAIN_ROW_APPEND(EXPLAIN_OUTPUT_ORDER_TYPE_FORMAT, EXPLAIN_ORDER_STRING(pIntNode->window.node.outputTsOrder));

×

1127

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1128

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

1129

      EXPLAIN_ROW_END();

×

1130

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1132

      if (verbose) {

×

1133

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

1134

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

1136

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1137

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pIntNode->window.node.pOutputDataBlockDesc->outputRowSize);

×

1138

        EXPLAIN_ROW_APPEND_LIMIT(pIntNode->window.node.pLimit);

×

1139

        EXPLAIN_ROW_APPEND_SLIMIT(pIntNode->window.node.pSlimit);

×

1140

        EXPLAIN_ROW_END();

×

1141

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1142

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_TIMERANGE_FORMAT, pIntNode->timeRange.skey, pIntNode->timeRange.ekey);

×

1143

        EXPLAIN_ROW_END();

×

1144

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1145

        uint8_t precision = qExplainGetIntervalPrecision(pIntNode);

×

1146

        int64_t time1 = -1;

×

1147

        int64_t time2 = -1;

×

1148

        int32_t code = TSDB_CODE_SUCCESS;

×

1149

        INVERAL_TIME_FROM_PRECISION_TO_UNIT(pIntNode->interval, pIntNode->intervalUnit, precision, time1);

×

1150

        QRY_ERR_RET(code);

×

1151

        INVERAL_TIME_FROM_PRECISION_TO_UNIT(pIntNode->sliding, pIntNode->slidingUnit, precision, time2);

×

1152

        QRY_ERR_RET(code);

×

1153

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_TIME_WINDOWS_FORMAT,

×

1158

        EXPLAIN_ROW_END();

×

1159

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1161

        if (pIntNode->window.node.pConditions) {

×

1162

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

1163

          QRY_ERR_RET(nodesNodeToSQL(pIntNode->window.node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

1165

          EXPLAIN_ROW_END();

×

1166

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1169

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_MERGEBLOCKS_FORMAT, pIntNode->window.mergeDataBlock? "True":"False");

×

1170

        EXPLAIN_ROW_END();

×

1171

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1173

      break;

×

1175

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL: {

×

1176

      SMergeAlignedIntervalPhysiNode *pIntNode = (SMergeAlignedIntervalPhysiNode *)pNode;

×

1177

      EXPLAIN_ROW_NEW(level, EXPLAIN_MERGE_ALIGNED_INTERVAL_FORMAT, nodesGetNameFromColumnNode(pIntNode->window.pTspk));

×

1178

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

1179

      if (pResNode->pExecInfo) {

×

1180

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

1181

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1183

      EXPLAIN_ROW_APPEND(EXPLAIN_FUNCTIONS_FORMAT, LIST_LENGTH(pIntNode->window.pFuncs));

×

1184

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1185

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pIntNode->window.node.pOutputDataBlockDesc->totalRowSize);

×

1186

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1187

      EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pIntNode->window.node.inputTsOrder));

×

1188

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1189

      EXPLAIN_ROW_APPEND(EXPLAIN_OUTPUT_ORDER_TYPE_FORMAT, EXPLAIN_ORDER_STRING(pIntNode->window.node.outputTsOrder));

×

1190

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

1191

      EXPLAIN_ROW_END();

×

1192

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1194

      if (verbose) {

×

1195

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

1196

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

1198

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1199

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pIntNode->window.node.pOutputDataBlockDesc->outputRowSize);

×

1200

        EXPLAIN_ROW_APPEND_LIMIT(pIntNode->window.node.pLimit);

×

1201

        EXPLAIN_ROW_APPEND_SLIMIT(pIntNode->window.node.pSlimit);

×

1202

        EXPLAIN_ROW_END();

×

1203

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1204

        uint8_t precision = qExplainGetIntervalPrecision(pIntNode);

×

1205

        int64_t time1 = -1;

×

1206

        int64_t time2 = -1;

×

1207

        int32_t code = TSDB_CODE_SUCCESS;

×

1208

        INVERAL_TIME_FROM_PRECISION_TO_UNIT(pIntNode->interval, pIntNode->intervalUnit, precision, time1);

×

1209

        QRY_ERR_RET(code);

×

1210

        INVERAL_TIME_FROM_PRECISION_TO_UNIT(pIntNode->sliding, pIntNode->slidingUnit, precision, time2);

×

1211

        QRY_ERR_RET(code);

×

1212

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_TIME_WINDOWS_FORMAT,

×

1217

        EXPLAIN_ROW_END();

×

1218

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1220

        if (pIntNode->window.node.pConditions) {

×

1221

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

1222

          QRY_ERR_RET(nodesNodeToSQL(pIntNode->window.node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

1224

          EXPLAIN_ROW_END();

×

1225

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1228

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_MERGEBLOCKS_FORMAT, pIntNode->window.mergeDataBlock? "True":"False");

×

1229

        EXPLAIN_ROW_END();

×

1230

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1232

      break;

×

1234

    case QUERY_NODE_PHYSICAL_PLAN_FILL: {

×

1235

      SFillPhysiNode *pFillNode = (SFillPhysiNode *)pNode;

×

1236

      EXPLAIN_ROW_NEW(level, EXPLAIN_FILL_FORMAT);

×

1237

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

1238

      if (pResNode->pExecInfo) {

×

1239

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

1240

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1242

      EXPLAIN_ROW_APPEND(EXPLAIN_MODE_FORMAT, nodesGetFillModeString(pFillNode->mode));

×

1243

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1244

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pFillNode->node.pOutputDataBlockDesc->totalRowSize);

×

1245

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1246

      EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pFillNode->node.inputTsOrder));

×

1247

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1248

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

1249

      EXPLAIN_ROW_END();

×

1250

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1252

      if (verbose) {

×

1253

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

1254

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

1256

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1257

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pFillNode->node.pOutputDataBlockDesc->outputRowSize);

×

1258

        EXPLAIN_ROW_APPEND_LIMIT(pFillNode->node.pLimit);

×

1259

        EXPLAIN_ROW_APPEND_SLIMIT(pFillNode->node.pSlimit);

×

1260

        EXPLAIN_ROW_END();

×

1261

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1262

        if (pFillNode->pValues) {

×

1263

          SNodeListNode *pValues = (SNodeListNode *)pFillNode->pValues;

×

1264

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILL_VALUE_FORMAT);

×

1265

          SNode  *tNode = NULL;

×

1266

          int32_t i = 0;

×

1267

          FOREACH(tNode, pValues->pNodeList) {

×

1268

            if (i) {

×

1269

              EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1271

            SValueNode *tValue = (SValueNode *)tNode;

×

1272

            char       *value = nodesGetStrValueFromNode(tValue);

×

1273

            EXPLAIN_ROW_APPEND(EXPLAIN_STRING_TYPE_FORMAT, value);

×

1274

            taosMemoryFree(value);

×

1275

            ++i;

×

1278

          EXPLAIN_ROW_END();

×

1279

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1282

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_TIMERANGE_FORMAT, pFillNode->timeRange.skey, pFillNode->timeRange.ekey);

×

1283

        EXPLAIN_ROW_END();

×

1284

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1286

        if (pFillNode->node.pConditions) {

×

1287

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

1288

          QRY_ERR_RET(nodesNodeToSQL(pFillNode->node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

1290

          EXPLAIN_ROW_END();

×

1291

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1294

      break;

×

1296

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION: {

×

1297

      SSessionWinodwPhysiNode *pSessNode = (SSessionWinodwPhysiNode *)pNode;

×

1298

      EXPLAIN_ROW_NEW(level, EXPLAIN_SESSION_FORMAT);

×

1299

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

1300

      if (pResNode->pExecInfo) {

×

1301

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

1302

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1304

      EXPLAIN_ROW_APPEND(EXPLAIN_FUNCTIONS_FORMAT, LIST_LENGTH(pSessNode->window.pFuncs));

×

1305

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1306

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pSessNode->window.node.pOutputDataBlockDesc->totalRowSize);

×

1307

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

1308

      EXPLAIN_ROW_END();

×

1309

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1311

      if (verbose) {

×

1312

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

1313

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

1315

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1316

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pSessNode->window.node.pOutputDataBlockDesc->outputRowSize);

×

1317

        EXPLAIN_ROW_APPEND_LIMIT(pSessNode->window.node.pLimit);

×

1318

        EXPLAIN_ROW_APPEND_SLIMIT(pSessNode->window.node.pSlimit);

×

1319

        EXPLAIN_ROW_END();

×

1320

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1322

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_WINDOW_FORMAT, pSessNode->gap);

×

1323

        EXPLAIN_ROW_END();

×

1324

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1326

        if (pSessNode->window.node.pConditions) {

×

1327

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

1328

          QRY_ERR_RET(nodesNodeToSQL(pSessNode->window.node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

1330

          EXPLAIN_ROW_END();

×

1331

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1334

      break;

×

1336

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE: {

×

1337

      SStateWindowPhysiNode *pStateNode = (SStateWindowPhysiNode *)pNode;

×

1339

      EXPLAIN_ROW_NEW(level, EXPLAIN_STATE_WINDOW_FORMAT,

×

1341

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

1342

      if (pResNode->pExecInfo) {

×

1343

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

1344

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1347

      EXPLAIN_ROW_APPEND(EXPLAIN_FUNCTIONS_FORMAT, LIST_LENGTH(pStateNode->window.pFuncs));

×

1348

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1349

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pStateNode->window.node.pOutputDataBlockDesc->totalRowSize);

×

1350

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

1351

      EXPLAIN_ROW_END();

×

1352

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1354

      if (verbose) {

×

1355

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

1356

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

1358

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1359

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pStateNode->window.node.pOutputDataBlockDesc->outputRowSize);

×

1360

        EXPLAIN_ROW_APPEND_LIMIT(pStateNode->window.node.pLimit);

×

1361

        EXPLAIN_ROW_APPEND_SLIMIT(pStateNode->window.node.pSlimit);

×

1362

        EXPLAIN_ROW_END();

×

1363

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1365

        EXPLAIN_ROW_END();

×

1366

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1368

        if (pStateNode->window.node.pConditions) {

×

1369

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

1370

          QRY_ERR_RET(nodesNodeToSQL(pStateNode->window.node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

1372

          EXPLAIN_ROW_END();

×

1373

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1376

      break;

×

1378

    case QUERY_NODE_PHYSICAL_PLAN_PARTITION: {

×

1379

      SPartitionPhysiNode *pPartNode = (SPartitionPhysiNode *)pNode;

×

1381

      SNode *p = nodesListGetNode(pPartNode->pPartitionKeys, 0);

×

1382

      EXPLAIN_ROW_NEW(level, EXPLAIN_PARITION_FORMAT, nodesGetNameFromColumnNode(p));

×

1383

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

1384

      if (pResNode->pExecInfo) {

×

1385

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

1386

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1388

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pPartNode->node.pOutputDataBlockDesc->totalRowSize);

×

1390

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

1391

      EXPLAIN_ROW_END();

×

1392

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1394

      if (verbose) {

×

1395

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

1396

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

1398

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1399

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pPartNode->node.pOutputDataBlockDesc->outputRowSize);

×

1400

        EXPLAIN_ROW_APPEND_LIMIT(pPartNode->node.pLimit);

×

1401

        EXPLAIN_ROW_APPEND_SLIMIT(pPartNode->node.pSlimit);

×

1402

        EXPLAIN_ROW_END();

×

1403

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1405

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_PARTITION_KETS_FORMAT);

×

1406

        EXPLAIN_ROW_APPEND(EXPLAIN_PARTITIONS_FORMAT, pPartNode->pPartitionKeys->length);

×

1407

        EXPLAIN_ROW_END();

×

1408

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1410

        if (pPartNode->node.pConditions) {

×

1411

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

1412

          QRY_ERR_RET(nodesNodeToSQL(pPartNode->node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

1414

          EXPLAIN_ROW_END();

×

1415

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1418

      break;

×

1420

    case QUERY_NODE_PHYSICAL_PLAN_MERGE: {

×

1421

      SMergePhysiNode *pMergeNode = (SMergePhysiNode *)pNode;

×

1422

      EXPLAIN_ROW_NEW(level, EXPLAIN_MERGE_FORMAT);

×

1423

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

1424

      if (pResNode->pExecInfo) {

×

1425

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

1426

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1429

      SDataBlockDescNode *pDescNode = pMergeNode->node.pOutputDataBlockDesc;

×

1430

      EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, nodesGetOutputNumFromSlotList(pDescNode->pSlots));

×

1431

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1432

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pDescNode->totalRowSize);

×

1433

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1434

      EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pMergeNode->node.inputTsOrder));

×

1435

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1436

      EXPLAIN_ROW_APPEND(EXPLAIN_OUTPUT_ORDER_TYPE_FORMAT, EXPLAIN_ORDER_STRING(pMergeNode->node.outputTsOrder));

×

1437

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1438

      EXPLAIN_ROW_APPEND(EXPLAIN_MERGE_MODE_FORMAT, EXPLAIN_MERGE_MODE_STRING(pMergeNode->type));

×

1439

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

1440

      EXPLAIN_ROW_END();

×

1441

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1443

      if (EXPLAIN_MODE_ANALYZE == ctx->mode) {

×

1444

        if (MERGE_TYPE_SORT == pMergeNode->type) {

×

1446

          EXPLAIN_ROW_NEW(level + 1, "Sort Method: ");

×

1448

          int32_t           nodeNum = taosArrayGetSize(pResNode->pExecInfo);

×

1449

          SExplainExecInfo *execInfo = taosArrayGet(pResNode->pExecInfo, 0);

×

1450

          SSortExecInfo    *pExecInfo = (SSortExecInfo *)execInfo->verboseInfo;

×

1451

          EXPLAIN_ROW_APPEND("%s", pExecInfo->sortMethod == SORT_QSORT_T ? "quicksort" : "merge sort");

×

1452

          if (pExecInfo->sortBuffer > 1024 * 1024) {

×

1453

            EXPLAIN_ROW_APPEND("  Buffers:%.2f Mb", pExecInfo->sortBuffer / (1024 * 1024.0));

×

1454

          } else if (pExecInfo->sortBuffer > 1024) {

×

1455

            EXPLAIN_ROW_APPEND("  Buffers:%.2f Kb", pExecInfo->sortBuffer / (1024.0));

×

1457

            EXPLAIN_ROW_APPEND("  Buffers:%d b", pExecInfo->sortBuffer);

×

1460

          EXPLAIN_ROW_APPEND("  loops:%d", pExecInfo->loops);

×

1461

          EXPLAIN_ROW_END();

×

1462

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1466

      if (verbose) {

×

1467

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

1468

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

1470

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1471

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pMergeNode->node.pOutputDataBlockDesc->outputRowSize);

×

1472

        EXPLAIN_ROW_APPEND_LIMIT(pMergeNode->node.pLimit);

×

1473

        EXPLAIN_ROW_APPEND_SLIMIT(pMergeNode->node.pSlimit);

×

1474

        EXPLAIN_ROW_END();

×

1475

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1477

        if (MERGE_TYPE_SORT == pMergeNode->type) {

×

1478

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

1479

          EXPLAIN_ROW_APPEND(EXPLAIN_IGNORE_GROUPID_FORMAT, pMergeNode->ignoreGroupId ? "true" : "false");

×

1480

          EXPLAIN_ROW_END();

×

1481

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1483

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_MERGE_KEYS_FORMAT);

×

1484

          if (pMergeNode->groupSort) {

×

1485

            EXPLAIN_ROW_APPEND(EXPLAIN_STRING_TYPE_FORMAT, "_group_id asc");

×

1486

            if (LIST_LENGTH(pMergeNode->pMergeKeys) > 0) {

×

1487

              EXPLAIN_ROW_APPEND(EXPLAIN_COMMA_FORMAT);

×

1490

          for (int32_t i = 0; i < LIST_LENGTH(pMergeNode->pMergeKeys); ++i) {

×

1491

            SOrderByExprNode *ptn = (SOrderByExprNode *)nodesListGetNode(pMergeNode->pMergeKeys, i);

×

1492

            EXPLAIN_ROW_APPEND(EXPLAIN_STRING_TYPE_FORMAT, nodesGetNameFromColumnNode(ptn->pExpr));

×

1493

            EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1494

            EXPLAIN_ROW_APPEND(EXPLAIN_STRING_TYPE_FORMAT, EXPLAIN_ORDER_STRING(ptn->order));

×

1495

            if (i != LIST_LENGTH(pMergeNode->pMergeKeys) - 1) {

×

1496

              EXPLAIN_ROW_APPEND(EXPLAIN_COMMA_FORMAT);

×

1499

          EXPLAIN_ROW_END();

×

1500

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1503

        if (pMergeNode->node.pConditions) {

×

1504

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

1505

          QRY_ERR_RET(nodesNodeToSQL(pMergeNode->node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

1507

          EXPLAIN_ROW_END();

×

1508

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1511

      break;

×

1513

    case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN: {

×

1514

      SBlockDistScanPhysiNode *pDistScanNode = (SBlockDistScanPhysiNode *)pNode;

×

1515

      EXPLAIN_ROW_NEW(level, EXPLAIN_DISTBLK_SCAN_FORMAT, pDistScanNode->tableName.tname);

×

1516

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

1517

      if (pResNode->pExecInfo) {

×

1518

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

1519

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1521

      EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, pDistScanNode->pScanCols->length);

×

1522

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1523

      if (pDistScanNode->pScanPseudoCols) {

×

1524

        EXPLAIN_ROW_APPEND(EXPLAIN_PSEUDO_COLUMNS_FORMAT, pDistScanNode->pScanPseudoCols->length);

×

1525

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1527

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pDistScanNode->node.pOutputDataBlockDesc->totalRowSize);

×

1528

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1529

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

1530

      EXPLAIN_ROW_END();

×

1531

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1533

      if (verbose) {

×

1534

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

1535

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

1537

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1538

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pDistScanNode->node.pOutputDataBlockDesc->outputRowSize);

×

1539

        EXPLAIN_ROW_APPEND_LIMIT(pDistScanNode->node.pLimit);

×

1540

        EXPLAIN_ROW_APPEND_SLIMIT(pDistScanNode->node.pSlimit);

×

1541

        EXPLAIN_ROW_END();

×

1542

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1544

        if (pDistScanNode->node.pConditions) {

×

1545

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

1546

          QRY_ERR_RET(nodesNodeToSQL(pDistScanNode->node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

1548

          EXPLAIN_ROW_END();

×

1549

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1552

      break;

×

1554

    case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN: {

×

1555

      SLastRowScanPhysiNode *pLastRowNode = (SLastRowScanPhysiNode *)pNode;

×

1556

      EXPLAIN_ROW_NEW(level, EXPLAIN_LASTROW_SCAN_FORMAT, pLastRowNode->scan.tableName.tname);

×

1557

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

1558

      if (pResNode->pExecInfo) {

×

1559

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

1560

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1562

      EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, pLastRowNode->scan.pScanCols->length);

×

1563

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1564

      if (pLastRowNode->scan.pScanPseudoCols) {

×

1565

        EXPLAIN_ROW_APPEND(EXPLAIN_PSEUDO_COLUMNS_FORMAT, pLastRowNode->scan.pScanPseudoCols->length);

×

1566

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1568

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pLastRowNode->scan.node.pOutputDataBlockDesc->totalRowSize);

×

1569

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1570

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

1571

      EXPLAIN_ROW_END();

×

1572

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1574

      if (verbose) {

×

1575

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

1576

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

1578

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1579

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pLastRowNode->scan.node.pOutputDataBlockDesc->outputRowSize);

×

1580

        EXPLAIN_ROW_APPEND_LIMIT(pLastRowNode->scan.node.pLimit);

×

1581

        EXPLAIN_ROW_APPEND_SLIMIT(pLastRowNode->scan.node.pSlimit);

×

1582

        EXPLAIN_ROW_END();

×

1583

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1585

        if (pLastRowNode->scan.node.pConditions) {

×

1586

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

1587

          QRY_ERR_RET(nodesNodeToSQL(pLastRowNode->scan.node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

1589

          EXPLAIN_ROW_END();

×

1590

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1593

        if (qExplainCouldApplyTagIndex(pResNode->pPlan)) {

×

1594

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_TAG_INDEX_FORMAT);

×

1595

          QRY_ERR_RET(nodesNodeToSQL(pResNode->pPlan->pTagIndexCond, tbuf + VARSTR_HEADER_SIZE,

×

1597

          EXPLAIN_ROW_END();

×

1598

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1601

      break;

×

1603

    case QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN: {

×

1604

      STableCountScanPhysiNode *pLastRowNode = (STableCountScanPhysiNode *)pNode;

×

1605

      char *dbname = pLastRowNode->scan.tableName.dbname;

×

1606

      char *tbname = pLastRowNode->scan.tableName.tname;

×

1607

      if (dbname[0] != '\0' && tbname[0] != '\0') {

×

1609

        snprintf(name, sizeof(name), "%s.%s", dbname, tbname);

×

1610

        EXPLAIN_ROW_NEW(level, EXPLAIN_TABLE_COUNT_SCAN_FORMAT, name);

×

1611

      } else if (dbname[0] != '\0') {

×

1612

        EXPLAIN_ROW_NEW(level, EXPLAIN_TABLE_COUNT_SCAN_FORMAT, dbname);

×

1613

      } else if (tbname[0] != '\0') {

×

1614

        EXPLAIN_ROW_NEW(level, EXPLAIN_TABLE_COUNT_SCAN_FORMAT, tbname);

×

1616

        EXPLAIN_ROW_NEW(level, EXPLAIN_TABLE_COUNT_SCAN_FORMAT, TSDB_INS_TABLE_TABLES);

×

1618

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

1619

      if (pResNode->pExecInfo) {

×

1620

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

1621

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1623

      EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, LIST_LENGTH(pLastRowNode->scan.pScanCols));

×

1624

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1625

      if (pLastRowNode->scan.pScanPseudoCols) {

×

1626

        EXPLAIN_ROW_APPEND(EXPLAIN_PSEUDO_COLUMNS_FORMAT, pLastRowNode->scan.pScanPseudoCols->length);

×

1627

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1629

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pLastRowNode->scan.node.pOutputDataBlockDesc->totalRowSize);

×

1630

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1631

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

1632

      EXPLAIN_ROW_END();

×

1633

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1635

      if (verbose) {

×

1636

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

1637

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

1639

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1640

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pLastRowNode->scan.node.pOutputDataBlockDesc->outputRowSize);

×

1641

        EXPLAIN_ROW_APPEND_LIMIT(pLastRowNode->scan.node.pLimit);

×

1642

        EXPLAIN_ROW_APPEND_SLIMIT(pLastRowNode->scan.node.pSlimit);

×

1643

        EXPLAIN_ROW_END();

×

1644

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1646

        if (pLastRowNode->scan.node.pConditions) {

×

1647

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

1648

          QRY_ERR_RET(nodesNodeToSQL(pLastRowNode->scan.node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

1650

          EXPLAIN_ROW_END();

×

1651

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1654

      break;

×

1656

    case QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT: {

×

1657

      SGroupSortPhysiNode *pSortNode = (SGroupSortPhysiNode *)pNode;

×

1658

      EXPLAIN_ROW_NEW(level, EXPLAIN_GROUP_SORT_FORMAT);

×

1659

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

1660

      if (pResNode->pExecInfo) {

×

1661

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

1662

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1665

      SDataBlockDescNode *pDescNode = pSortNode->node.pOutputDataBlockDesc;

×

1666

      EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, nodesGetOutputNumFromSlotList(pDescNode->pSlots));

×

1667

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1668

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pDescNode->totalRowSize);

×

1669

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

1670

      EXPLAIN_ROW_END();

×

1671

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1673

      if (EXPLAIN_MODE_ANALYZE == ctx->mode) {

×

1675

        EXPLAIN_ROW_NEW(level + 1, "Sort Key: ");

×

1676

        if (pResNode->pExecInfo) {

×

1677

          for (int32_t i = 0; i < LIST_LENGTH(pSortNode->pSortKeys); ++i) {

×

1678

            SOrderByExprNode *ptn = (SOrderByExprNode *)nodesListGetNode(pSortNode->pSortKeys, i);

×

1679

            EXPLAIN_ROW_APPEND("%s ", nodesGetNameFromColumnNode(ptn->pExpr));

×

1683

        EXPLAIN_ROW_END();

×

1684

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1687

        EXPLAIN_ROW_NEW(level + 1, "Sort Method: ");

×

1689

        int32_t           nodeNum = taosArrayGetSize(pResNode->pExecInfo);

×

1690

        SExplainExecInfo *execInfo = taosArrayGet(pResNode->pExecInfo, 0);

×

1691

        SSortExecInfo    *pExecInfo = (SSortExecInfo *)execInfo->verboseInfo;

×

1692

        EXPLAIN_ROW_APPEND("%s", pExecInfo->sortMethod == SORT_QSORT_T ? "quicksort" : "merge sort");

×

1693

        if (pExecInfo->sortBuffer > 1024 * 1024) {

×

1694

          EXPLAIN_ROW_APPEND("  Buffers:%.2f Mb", pExecInfo->sortBuffer / (1024 * 1024.0));

×

1695

        } else if (pExecInfo->sortBuffer > 1024) {

×

1696

          EXPLAIN_ROW_APPEND("  Buffers:%.2f Kb", pExecInfo->sortBuffer / (1024.0));

×

1698

          EXPLAIN_ROW_APPEND("  Buffers:%d b", pExecInfo->sortBuffer);

×

1701

        EXPLAIN_ROW_APPEND("  loops:%d", pExecInfo->loops);

×

1702

        EXPLAIN_ROW_END();

×

1703

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1706

      if (verbose) {

×

1707

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

1708

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

1710

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1711

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pSortNode->node.pOutputDataBlockDesc->outputRowSize);

×

1712

        EXPLAIN_ROW_APPEND_LIMIT(pSortNode->node.pLimit);

×

1713

        EXPLAIN_ROW_APPEND_SLIMIT(pSortNode->node.pSlimit);

×

1714

        EXPLAIN_ROW_END();

×

1715

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1717

        if (pSortNode->node.pConditions) {

×

1718

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

1719

          QRY_ERR_RET(nodesNodeToSQL(pSortNode->node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

1721

          EXPLAIN_ROW_END();

×

1722

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1725

      break;

×

1727

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_INTERVAL: {

×

1728

      SMergeIntervalPhysiNode *pIntNode = (SMergeIntervalPhysiNode *)pNode;

×

1729

      EXPLAIN_ROW_NEW(level, EXPLAIN_MERGE_INTERVAL_FORMAT, nodesGetNameFromColumnNode(pIntNode->window.pTspk));

×

1730

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

1731

      if (pResNode->pExecInfo) {

×

1732

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

1733

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1735

      EXPLAIN_ROW_APPEND(EXPLAIN_FUNCTIONS_FORMAT, LIST_LENGTH(pIntNode->window.pFuncs));

×

1736

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

1737

      EXPLAIN_ROW_END();

×

1738

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1740

      if (verbose) {

×

1741

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

1742

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

1744

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1745

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pIntNode->window.node.pOutputDataBlockDesc->outputRowSize);

×

1746

        EXPLAIN_ROW_APPEND_LIMIT(pIntNode->window.node.pLimit);

×

1747

        EXPLAIN_ROW_APPEND_SLIMIT(pIntNode->window.node.pSlimit);

×

1748

        EXPLAIN_ROW_END();

×

1749

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1750

        uint8_t precision = qExplainGetIntervalPrecision(pIntNode);

×

1751

        int64_t time1 = -1;

×

1752

        int64_t time2 = -1;

×

1753

        int32_t code = TSDB_CODE_SUCCESS;

×

1754

        INVERAL_TIME_FROM_PRECISION_TO_UNIT(pIntNode->interval, pIntNode->intervalUnit, precision, time1);

×

1755

        QRY_ERR_RET(code);

×

1756

        INVERAL_TIME_FROM_PRECISION_TO_UNIT(pIntNode->sliding, pIntNode->slidingUnit, precision, time2);

×

1757

        QRY_ERR_RET(code);

×

1758

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_TIME_WINDOWS_FORMAT,

×

1763

        EXPLAIN_ROW_END();

×

1764

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1766

        if (pIntNode->window.node.pConditions) {

×

1767

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

1768

          QRY_ERR_RET(nodesNodeToSQL(pIntNode->window.node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

1770

          EXPLAIN_ROW_END();

×

1771

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1774

      break;

×

1776

    case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC: {

×

1777

      SInterpFuncPhysiNode *pInterpNode = (SInterpFuncPhysiNode *)pNode;

×

1778

      EXPLAIN_ROW_NEW(level, EXPLAIN_INTERP_FORMAT);

×

1779

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

1780

      if (pResNode->pExecInfo) {

×

1781

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

1782

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1784

      if (pInterpNode->pFuncs) {

×

1785

        EXPLAIN_ROW_APPEND(EXPLAIN_FUNCTIONS_FORMAT, pInterpNode->pFuncs->length);

×

1786

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1789

      EXPLAIN_ROW_APPEND(EXPLAIN_MODE_FORMAT, nodesGetFillModeString(pInterpNode->fillMode));

×

1790

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1792

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

1793

      EXPLAIN_ROW_END();

×

1794

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1796

      if (verbose) {

×

1797

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

1798

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

1800

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1801

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pInterpNode->node.pOutputDataBlockDesc->outputRowSize);

×

1802

        EXPLAIN_ROW_APPEND_LIMIT(pInterpNode->node.pLimit);

×

1803

        EXPLAIN_ROW_APPEND_SLIMIT(pInterpNode->node.pSlimit);

×

1804

        EXPLAIN_ROW_END();

×

1805

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1806

        if (pInterpNode->pFillValues) {

×

1807

          SNodeListNode *pValues = (SNodeListNode *)pInterpNode->pFillValues;

×

1808

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILL_VALUE_FORMAT);

×

1809

          SNode  *tNode = NULL;

×

1810

          int32_t i = 0;

×

1811

          FOREACH(tNode, pValues->pNodeList) {

×

1812

            if (i) {

×

1813

              EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1815

            SValueNode *tValue = (SValueNode *)tNode;

×

1816

            char       *value = nodesGetStrValueFromNode(tValue);

×

1817

            EXPLAIN_ROW_APPEND(EXPLAIN_STRING_TYPE_FORMAT, value);

×

1818

            taosMemoryFree(value);

×

1819

            ++i;

×

1822

          EXPLAIN_ROW_END();

×

1823

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1826

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_INTERVAL_VALUE_FORMAT, pInterpNode->interval, pInterpNode->intervalUnit);

×

1827

        EXPLAIN_ROW_END();

×

1829

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_TIMERANGE_FORMAT, pInterpNode->timeRange.skey, pInterpNode->timeRange.ekey);

×

1830

        EXPLAIN_ROW_END();

×

1831

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1833

        if (pInterpNode->node.pConditions) {

×

1834

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

1835

          QRY_ERR_RET(nodesNodeToSQL(pInterpNode->node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

1837

          EXPLAIN_ROW_END();

×

1838

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1841

      break;

×

1843

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT: {

×

1844

      SEventWinodwPhysiNode *pEventNode = (SEventWinodwPhysiNode *)pNode;

×

1845

      EXPLAIN_ROW_NEW(level, EXPLAIN_EVENT_FORMAT);

×

1846

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

1847

      if (pResNode->pExecInfo) {

×

1848

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

1849

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1851

      EXPLAIN_ROW_APPEND(EXPLAIN_FUNCTIONS_FORMAT, LIST_LENGTH(pEventNode->window.pFuncs));

×

1852

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1853

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pEventNode->window.node.pOutputDataBlockDesc->totalRowSize);

×

1854

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

1855

      EXPLAIN_ROW_END();

×

1856

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1858

      if (verbose) {

×

1859

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_EVENT_START_FORMAT);

×

1860

        QRY_ERR_RET(nodesNodeToSQL(pEventNode->pStartCond, tbuf + VARSTR_HEADER_SIZE,

×

1862

        EXPLAIN_ROW_END();

×

1863

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1865

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_EVENT_END_FORMAT);

×

1866

        QRY_ERR_RET(nodesNodeToSQL(pEventNode->pEndCond, tbuf + VARSTR_HEADER_SIZE,

×

1868

        EXPLAIN_ROW_END();

×

1869

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1871

      break;

×

1873

    case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN:{

×

1874

      SHashJoinPhysiNode *pJoinNode = (SHashJoinPhysiNode *)pNode;

×

1875

      EXPLAIN_ROW_NEW(level, EXPLAIN_JOIN_FORMAT, gJoinTypeStr[pJoinNode->joinType][pJoinNode->subType]);

×

1876

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

1877

      if (pResNode->pExecInfo) {

×

1878

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

1879

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1881

      EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, pJoinNode->pTargets->length);

×

1882

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1883

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pJoinNode->node.pOutputDataBlockDesc->totalRowSize);

×

1884

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1885

      EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pJoinNode->node.inputTsOrder));

×

1886

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1887

      EXPLAIN_ROW_APPEND(EXPLAIN_JOIN_ALGO, "Hash");

×

1888

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

1889

      EXPLAIN_ROW_END();

×

1890

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1892

      if (verbose) {

×

1893

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

1894

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

1896

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1897

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pJoinNode->node.pOutputDataBlockDesc->outputRowSize);

×

1898

        EXPLAIN_ROW_APPEND_LIMIT(pJoinNode->node.pLimit);

×

1899

        EXPLAIN_ROW_APPEND_SLIMIT(pJoinNode->node.pSlimit);

×

1900

        EXPLAIN_ROW_END();

×

1901

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1903

        if (pJoinNode->node.pConditions) {

×

1904

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

1905

          QRY_ERR_RET(nodesNodeToSQL(pJoinNode->node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

1908

          EXPLAIN_ROW_END();

×

1909

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1912

        bool conditionsGot = false;

×

1913

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_ON_CONDITIONS_FORMAT);

×

1914

        if (pJoinNode->pPrimKeyCond) {

×

1915

          QRY_ERR_RET(

×

1917

          conditionsGot = true;

×

1919

        if (pJoinNode->pColEqCond) {

×

1920

          if (conditionsGot) {

×

1921

            EXPLAIN_ROW_APPEND(" AND ");

×

1923

          QRY_ERR_RET(

×

1925

          conditionsGot = true;

×

1927

        if (pJoinNode->pTagEqCond) {

×

1928

          if (conditionsGot) {

×

1929

            EXPLAIN_ROW_APPEND(" AND ");

×

1931

          QRY_ERR_RET(

×

1933

          conditionsGot = true;

×

1935

        if (pJoinNode->pFullOnCond) {

×

1936

          if (conditionsGot) {

×

1937

            EXPLAIN_ROW_APPEND(" AND ");

×

1939

          QRY_ERR_RET(nodesNodeToSQL(pJoinNode->pFullOnCond, tbuf + VARSTR_HEADER_SIZE,

×

1942

        EXPLAIN_ROW_END();

×

1943

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1945

        if (pJoinNode->timeRangeTarget) {

×

1946

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_TABLE_TIMERANGE_FORMAT, qExplainGetTimerangeTargetStr(pJoinNode->timeRangeTarget), pJoinNode->timeRange.skey, pJoinNode->timeRange.ekey);

×

1947

          EXPLAIN_ROW_END();

×

1948

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1951

      break;

×

1953

    case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE:{

×

1954

      SGroupCachePhysiNode *pGroupCache = (SGroupCachePhysiNode *)pNode;

×

1955

      EXPLAIN_ROW_NEW(level, EXPLAIN_GROUP_CACHE_FORMAT);

×

1956

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

1957

      if (pResNode->pExecInfo) {

×

1958

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

1959

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1961

      EXPLAIN_ROW_APPEND(EXPLAIN_GLOBAL_GROUP_FORMAT, pGroupCache->globalGrp);

×

1962

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1963

      EXPLAIN_ROW_APPEND(EXPLAIN_GROUP_BY_UID_FORMAT, pGroupCache->grpByUid);

×

1964

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1965

      EXPLAIN_ROW_APPEND(EXPLAIN_BATCH_SCAN_FORMAT, pGroupCache->batchFetch);

×

1966

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1967

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pGroupCache->node.pOutputDataBlockDesc->totalRowSize);

×

1968

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1969

      EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pGroupCache->node.inputTsOrder));

×

1970

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1971

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

1972

      EXPLAIN_ROW_END();

×

1973

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

1975

      if (verbose) {

×

1976

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

1977

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

1979

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

1980

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pGroupCache->node.pOutputDataBlockDesc->outputRowSize);

×

1981

        EXPLAIN_ROW_APPEND_LIMIT(pGroupCache->node.pLimit);

×

1982

        EXPLAIN_ROW_APPEND_SLIMIT(pGroupCache->node.pSlimit);

×

1983

        EXPLAIN_ROW_END();

×

1984

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1986

        if (pGroupCache->node.pConditions) {

×

1987

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

1988

          QRY_ERR_RET(nodesNodeToSQL(pGroupCache->node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

1990

          EXPLAIN_ROW_END();

×

1991

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

1994

      break;

×

1996

    case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL:{

×

1997

      SDynQueryCtrlPhysiNode *pDyn = (SDynQueryCtrlPhysiNode *)pNode;

×

1998

      EXPLAIN_ROW_NEW(level, EXPLAIN_DYN_QRY_CTRL_FORMAT, qExplainGetDynQryCtrlType(pDyn));

×

1999

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

2000

      if (pResNode->pExecInfo) {

×

2001

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

2002

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2004

      switch (pDyn->qType) {

×

2005

        case DYN_QTYPE_STB_HASH: {

×

2006

          EXPLAIN_ROW_APPEND(EXPLAIN_BATCH_SCAN_FORMAT, pDyn->stbJoin.batchFetch);

×

2007

          EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2008

          EXPLAIN_ROW_APPEND(EXPLAIN_VGROUP_SLOT_FORMAT, pDyn->stbJoin.vgSlot[0], pDyn->stbJoin.vgSlot[1]);

×

2009

          EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2010

          EXPLAIN_ROW_APPEND(EXPLAIN_UID_SLOT_FORMAT, pDyn->stbJoin.uidSlot[0], pDyn->stbJoin.uidSlot[1]);

×

2011

          EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2012

          EXPLAIN_ROW_APPEND(EXPLAIN_SRC_SCAN_FORMAT, pDyn->stbJoin.srcScan[0], pDyn->stbJoin.srcScan[1]);

×

2013

          EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2014

          EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pDyn->node.pOutputDataBlockDesc->totalRowSize);

×

2015

          EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2016

          EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pDyn->node.inputTsOrder));

×

2017

          EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2018

          EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

2019

          break;

×

2021

        case DYN_QTYPE_VTB_INTERVAL:

×

2023

          EXPLAIN_ROW_APPEND(EXPLAIN_HAS_PARTITION_FORMAT, pDyn->vtbScan.hasPartition);

×

2024

          EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2025

          EXPLAIN_ROW_APPEND(EXPLAIN_BATCH_PROCESS_CHILD_FORMAT, pDyn->vtbScan.batchProcessChild);

×

2026

          EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2027

          EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pDyn->node.pOutputDataBlockDesc->totalRowSize);

×

2028

          EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2030

          EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

2031

          break;

×

2033

        case DYN_QTYPE_VTB_TS_SCAN:

×

2035

          EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, pDyn->vtbScan.pScanCols->length);

×

2036

          EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2037

          EXPLAIN_ROW_APPEND(EXPLAIN_ORIGIN_VGROUP_NUM_FORMAT, pDyn->vtbScan.pOrgVgIds->length);

×

2038

          EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2039

          EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pDyn->node.pOutputDataBlockDesc->totalRowSize);

×

2040

          EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2041

          EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pDyn->node.inputTsOrder));

×

2042

          EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2043

          EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

2044

          break;

×

2046

        case DYN_QTYPE_VTB_WINDOW: {

×

2047

          EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, pDyn->vtbWindow.pTargets->length);

×

2048

          EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2049

          EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pDyn->node.pOutputDataBlockDesc->totalRowSize);

×

2050

          EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2051

          EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pDyn->node.inputTsOrder));

×

2052

          EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2053

          EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

2054

          break;

×

2056

        default:

×

2057

          break;

×

2060

      EXPLAIN_ROW_END();

×

2061

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

2063

      if (verbose) {

×

2064

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

2065

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

2067

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2068

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pDyn->node.pOutputDataBlockDesc->outputRowSize);

×

2069

        EXPLAIN_ROW_APPEND_LIMIT(pDyn->node.pLimit);

×

2070

        EXPLAIN_ROW_APPEND_SLIMIT(pDyn->node.pSlimit);

×

2071

        EXPLAIN_ROW_END();

×

2072

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

2074

        if (pDyn->node.pConditions) {

×

2075

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

2076

          QRY_ERR_RET(nodesNodeToSQL(pDyn->node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

2078

          EXPLAIN_ROW_END();

×

2079

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

2082

      break;

×

2084

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_COUNT: {

×

2085

      SCountWindowPhysiNode *pCountNode = (SCountWindowPhysiNode *)pNode;

×

2086

      EXPLAIN_ROW_NEW(level, EXPLAIN_COUNT_FORMAT);

×

2087

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

2088

      if (pResNode->pExecInfo) {

×

2089

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

2090

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2092

      EXPLAIN_ROW_APPEND(EXPLAIN_FUNCTIONS_FORMAT, LIST_LENGTH(pCountNode->window.pFuncs));

×

2093

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2094

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pCountNode->window.node.pOutputDataBlockDesc->totalRowSize);

×

2095

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

2096

      EXPLAIN_ROW_END();

×

2097

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

2099

      if (verbose) {

×

2100

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_COUNT_NUM_FORMAT, pCountNode->windowCount);

×

2101

        EXPLAIN_ROW_END();

×

2102

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

2103

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_COUNT_SLIDING_FORMAT, pCountNode->windowSliding);

×

2104

        EXPLAIN_ROW_END();

×

2105

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

2107

      break;

×

2109

    case QUERY_NODE_PHYSICAL_PLAN_EXTERNAL_WINDOW: {

×

2110

      SExternalWindowPhysiNode *pExternal = (SExternalWindowPhysiNode *)pNode;

×

2111

      EXPLAIN_ROW_NEW(level, EXPLAIN_EXTERNAL_FORMAT, nodesGetNameFromColumnNode(pExternal->window.pTspk));

×

2112

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

2113

      if (pResNode->pExecInfo) {

×

2114

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

2115

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2117

      EXPLAIN_ROW_APPEND(EXPLAIN_FUNCTIONS_FORMAT, LIST_LENGTH(pExternal->window.pFuncs));

×

2118

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2119

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pExternal->window.node.pOutputDataBlockDesc->totalRowSize);

×

2120

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2121

      EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pExternal->window.node.inputTsOrder));

×

2122

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2123

      EXPLAIN_ROW_APPEND(EXPLAIN_OUTPUT_ORDER_TYPE_FORMAT, EXPLAIN_ORDER_STRING(pExternal->window.node.outputTsOrder));

×

2124

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2125

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

2126

      EXPLAIN_ROW_END();

×

2127

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

2129

      if (verbose) {

×

2130

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

2131

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

2133

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2134

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pExternal->window.node.pOutputDataBlockDesc->outputRowSize);

×

2135

        EXPLAIN_ROW_APPEND_LIMIT(pExternal->window.node.pLimit);

×

2136

        EXPLAIN_ROW_APPEND_SLIMIT(pExternal->window.node.pSlimit);

×

2137

        EXPLAIN_ROW_END();

×

2138

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

2139

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_TIMERANGE_FORMAT, pExternal->timeRange.skey, pExternal->timeRange.ekey);

×

2140

        EXPLAIN_ROW_END();

×

2141

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

2143

        if (pExternal->window.node.pConditions) {

×

2144

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

2145

          QRY_ERR_RET(nodesNodeToSQL(pExternal->window.node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

2147

          EXPLAIN_ROW_END();

×

2148

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

2151

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_MERGEBLOCKS_FORMAT, pExternal->window.mergeDataBlock? "True":"False");

×

2152

        EXPLAIN_ROW_END();

×

2153

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

2155

      break;

×

2157

    case QUERY_NODE_PHYSICAL_PLAN_HASH_EXTERNAL: {

×

2158

      SExternalWindowPhysiNode *pExternal = (SExternalWindowPhysiNode *)pNode;

×

2159

      EXPLAIN_ROW_NEW(level, EXPLAIN_EXTERNAL_FORMAT, nodesGetNameFromColumnNode(pExternal->window.pTspk));

×

2160

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

2161

      if (pResNode->pExecInfo) {

×

2162

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

2163

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2165

      EXPLAIN_ROW_APPEND(EXPLAIN_FUNCTIONS_FORMAT, LIST_LENGTH(pExternal->window.pFuncs));

×

2166

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2167

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pExternal->window.node.pOutputDataBlockDesc->totalRowSize);

×

2168

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2169

      EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pExternal->window.node.inputTsOrder));

×

2170

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2171

      EXPLAIN_ROW_APPEND(EXPLAIN_OUTPUT_ORDER_TYPE_FORMAT, EXPLAIN_ORDER_STRING(pExternal->window.node.outputTsOrder));

×

2172

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2173

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

2174

      EXPLAIN_ROW_END();

×

2175

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

2177

      if (verbose) {

×

2178

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

2179

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

2181

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2182

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pExternal->window.node.pOutputDataBlockDesc->outputRowSize);

×

2183

        EXPLAIN_ROW_APPEND_LIMIT(pExternal->window.node.pLimit);

×

2184

        EXPLAIN_ROW_APPEND_SLIMIT(pExternal->window.node.pSlimit);

×

2185

        EXPLAIN_ROW_END();

×

2186

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

2187

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_TIMERANGE_FORMAT, pExternal->timeRange.skey, pExternal->timeRange.ekey);

×

2188

        EXPLAIN_ROW_END();

×

2189

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

2191

        if (pExternal->window.node.pConditions) {

×

2192

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

2193

          QRY_ERR_RET(nodesNodeToSQL(pExternal->window.node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

2195

          EXPLAIN_ROW_END();

×

2196

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

2199

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_MERGEBLOCKS_FORMAT, pExternal->window.mergeDataBlock? "True":"False");

×

2200

        EXPLAIN_ROW_END();

×

2201

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

2203

      break;

×

2205

    case QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_EXTERNAL: {

×

2206

      SExternalWindowPhysiNode *pExternal = (SExternalWindowPhysiNode *)pNode;

×

2207

      EXPLAIN_ROW_NEW(level, EXPLAIN_MERGE_ALIGNED_EXTERNAL_FORMAT, nodesGetNameFromColumnNode(pExternal->window.pTspk));

×

2208

      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);

×

2209

      if (pResNode->pExecInfo) {

×

2210

        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

×

2211

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2213

      EXPLAIN_ROW_APPEND(EXPLAIN_FUNCTIONS_FORMAT, LIST_LENGTH(pExternal->window.pFuncs));

×

2214

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2215

      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pExternal->window.node.pOutputDataBlockDesc->totalRowSize);

×

2216

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2217

      EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pExternal->window.node.inputTsOrder));

×

2218

      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2219

      EXPLAIN_ROW_APPEND(EXPLAIN_OUTPUT_ORDER_TYPE_FORMAT, EXPLAIN_ORDER_STRING(pExternal->window.node.outputTsOrder));

×

2220

      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);

×

2221

      EXPLAIN_ROW_END();

×

2222

      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

×

2224

      if (verbose) {

×

2225

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);

×

2226

        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,

×

2228

        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);

×

2229

        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pExternal->window.node.pOutputDataBlockDesc->outputRowSize);

×

2230

        EXPLAIN_ROW_APPEND_LIMIT(pExternal->window.node.pLimit);

×

2231

        EXPLAIN_ROW_APPEND_SLIMIT(pExternal->window.node.pSlimit);

×

2232

        EXPLAIN_ROW_END();

×

2233

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

2235

        if (pExternal->window.node.pConditions) {

×

2236

          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);

×

2237

          QRY_ERR_RET(nodesNodeToSQL(pExternal->window.node.pConditions, tbuf + VARSTR_HEADER_SIZE,

×

2239

          EXPLAIN_ROW_END();

×

2240

          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

2243

        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_MERGEBLOCKS_FORMAT, pExternal->window.mergeDataBlock? "True":"False");

×

2244

        EXPLAIN_ROW_END();

×

2245

        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

×

2247

      break;

×

2249

    default:

×

2250

      qError("not supported physical node type %d", pNode->type);

×

2251

      return TSDB_CODE_APP_ERROR;

×

2254

  return TSDB_CODE_SUCCESS;

×

2257

static int32_t qExplainResNodeToRows(SExplainResNode *pResNode, SExplainCtx *ctx, int32_t *level) {

×

2258

  if (NULL == pResNode) {

×

2259

    qError("explain res node is NULL");

×

2260

    QRY_ERR_RET(TSDB_CODE_APP_ERROR);

×

2263

  int32_t code = 0;

×

2264

  QRY_ERR_RET(qExplainResNodeToRowsImpl(pResNode, ctx, level));

×

2266

  SNode *pNode = NULL;

×

2267

  FOREACH(pNode, pResNode->pChildren) {

×

2268

    int32_t nlevel = *level + 1;

×

2269

    QRY_ERR_RET(qExplainResNodeToRows((SExplainResNode *)pNode, ctx, &nlevel));

×

2272

  return TSDB_CODE_SUCCESS;

×

2275

static int32_t qExplainAppendGroupResRows(void *pCtx, int32_t groupId, int32_t *level, bool grpSingleChannel) {

×

2276

  SExplainResNode *node = NULL;

×

2277

  int32_t          code = 0;

×

2278

  SExplainCtx     *ctx = (SExplainCtx *)pCtx;

×

2280

  SExplainGroup *group = taosHashGet(ctx->pCurrPlanCtx->groupHash, &groupId, sizeof(groupId));

×

2281

  if (NULL == group) {

×

2282

    qError("group %d not in groupHash", groupId);

×

2283

    QRY_ERR_RET(TSDB_CODE_APP_ERROR);

×

2286

  group->singleChannel = grpSingleChannel;

×

2287

  group->physiPlanExecIdx = 0;

×

2289

  QRY_ERR_RET(qExplainGenerateResNode(group->plan, group->plan->pNode, group, &node));

×

2291

  QRY_ERR_JRET(qExplainResNodeToRows(node, ctx, level));

×

2293

_return:

×

2295

  qExplainFreeResNode(node);

×

2297

  QRY_RET(code);

×

2300

static int32_t qExplainGetRspFromCtx(void *ctx, SRetrieveTableRsp **pRsp) {

×

2301

  int32_t      code = 0;

×

2302

  SSDataBlock *pBlock = NULL;

×

2303

  SExplainCtx *pCtx = (SExplainCtx *)ctx;

×

2304

  int32_t      rowNum = taosArrayGetSize(pCtx->rows);

×

2305

  if (rowNum <= 0) {

×

2306

    qError("empty explain res rows");

×

2307

    QRY_ERR_RET(TSDB_CODE_APP_ERROR);

×

2310

  code = createDataBlock(&pBlock);

×

2311

  QRY_ERR_JRET(code);

×

2313

  SColumnInfoData infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, TSDB_EXPLAIN_RESULT_ROW_SIZE, 1);

×

2314

  QRY_ERR_JRET(blockDataAppendColInfo(pBlock, &infoData));

×

2315

  QRY_ERR_JRET(blockDataEnsureCapacity(pBlock, rowNum));

×

2317

  SColumnInfoData *pInfoData = taosArrayGet(pBlock->pDataBlock, 0);

×

2319

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

×

2320

    SQueryExplainRowInfo *row = taosArrayGet(pCtx->rows, i);

×

2321

    QRY_ERR_JRET(colDataSetVal(pInfoData, i, row->buf, false));

×

2324

  pBlock->info.rows = rowNum;

×

2326

  size_t dataEncodeBufSize = blockGetEncodeSize(pBlock);

×

2327

  int32_t rspSize = sizeof(SRetrieveTableRsp) + dataEncodeBufSize + PAYLOAD_PREFIX_LEN;

×

2329

  SRetrieveTableRsp *rsp = (SRetrieveTableRsp *)taosMemoryCalloc(1, rspSize);

×

2330

  if (NULL == rsp) {

×

2331

    qError("malloc SRetrieveTableRsp failed, size:%d", rspSize);

×

2332

    QRY_ERR_JRET(terrno);

×

2335

  rsp->completed = 1;

×

2336

  rsp->numOfRows = htobe64((int64_t)rowNum);

×

2338

  int32_t len = blockEncode(pBlock, rsp->data + PAYLOAD_PREFIX_LEN, dataEncodeBufSize, taosArrayGetSize(pBlock->pDataBlock));

×

2339

  if(len < 0) {

×

2340

    qError("qExplainGetRspFromCtx: blockEncode failed");

×

2341

    QRY_ERR_JRET(terrno);

×

2344

  rsp->compLen = htonl(len);

×

2345

  rsp->payloadLen = htonl(len);

×

2346

  rsp->compressed = 0;

×

2348

  SET_PAYLOAD_LEN(rsp->data, len, len);

×

2350

_return:

×

2351

  blockDataDestroy(pBlock);

×

2353

  *pRsp = rsp;

×

2354

  QRY_RET(code);

×

2357

static int32_t qExplainBuildPlanCtx(SQueryPlan *pDag, SExplainPlanCtx *pCtx) {

×

2358

  int32_t        code = 0;

×

2359

  SNodeListNode *plans = NULL;

×

2360

  int32_t        taskNum = 0;

×

2361

  SExplainGroup *pGroup = NULL;

×

2363

  if (pDag->numOfSubplans <= 0) {

×

2364

    qError("invalid subplan num:%d", pDag->numOfSubplans);

×

2365

    QRY_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);

×

2368

  int32_t levelNum = (int32_t)LIST_LENGTH(pDag->pSubplans);

×

2369

  if (levelNum <= 0) {

×

2370

    qError("invalid level num:%d", levelNum);

×

2371

    QRY_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);

×

2374

  pCtx->groupHash =

×

2375

      taosHashInit(EXPLAIN_MAX_GROUP_NUM, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK);

×

2376

  if (NULL == pCtx->groupHash) {

×

2377

    qError("groupHash %d failed", EXPLAIN_MAX_GROUP_NUM);

×

2378

    QRY_ERR_RET(terrno);

×

2381

  int32_t i = 0;

×

2382

  SNode*  levelNode = NULL;

×

2383

  FOREACH(levelNode, pDag->pSubplans) {

×

2384

    plans = (SNodeListNode *)levelNode;

×

2385

    if (NULL == plans) {

×

2386

      qError("empty level plan, level:%d", i);

×

2387

      QRY_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT);

×

2390

    taskNum = (int32_t)LIST_LENGTH(plans->pNodeList);

×

2391

    if (taskNum <= 0) {

×

2392

      qError("invalid level plan number:%d, level:%d", taskNum, i);

×

2393

      QRY_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT);

×

2396

    SSubplan *plan = NULL;

×

2397

    int32_t   n = 0;

×

2398

    SNode*    taskNode = NULL;

×

2399

    FOREACH(taskNode, plans->pNodeList) {

×

2400

      plan = (SSubplan *)taskNode;

×

2401

      pGroup = taosHashGet(pCtx->groupHash, &plan->id.groupId, sizeof(plan->id.groupId));

×

2402

      if (pGroup) {

×

2403

        ++pGroup->nodeNum;

×

2404

        ++n;

×

2405

        continue;

×

2408

      SExplainGroup group = {0};

×

2409

      group.nodeNum = 1;

×

2410

      group.plan = plan;

×

2412

      if (0 != taosHashPut(pCtx->groupHash, &plan->id.groupId, sizeof(plan->id.groupId), &group, sizeof(group))) {

×

2413

        qError("taosHashPut to explainGroupHash failed, taskIdx:%d", n);

×

2414

        QRY_ERR_JRET(terrno);

×

2416

      ++n;

×

2419

    if (0 == i) {

×

2420

      if (taskNum > 1) {

×

2421

        qError("invalid taskNum %d for level 0", taskNum);

×

2422

        QRY_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT);

×

2425

      pCtx->rootGroupId = plan->id.groupId;

×

2428

    qDebug("level %d group handled, taskNum:%d", i, taskNum);

×

2429

    ++i;

×

2432

  pCtx->groupNum = taosHashGetSize(pCtx->groupHash);

×

2434

  return TSDB_CODE_SUCCESS;

×

2436

_return:

×

2438

  if (code) {

×

2439

    qError("QID:0x%" PRIx64 " %s failed since %s", pDag->queryId, __func__, tstrerror(code));

×

2442

  QRY_RET(code);

×

2445

static int32_t qExplainBuildCtx(SQueryPlan *pDag, SExplainCtx **pCtx) {

×

2446

  int32_t        code = 0;

×

2447

  SNodeListNode *plans = NULL;

×

2448

  int32_t        taskNum = 0;

×

2449

  SExplainGroup *pGroup = NULL;

×

2450

  SExplainCtx   *ctx = NULL;

×

2452

  if (pDag->numOfSubplans <= 0) {

×

2453

    qError("invalid subplan num:%d", pDag->numOfSubplans);

×

2454

    QRY_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);

×

2457

  int32_t levelNum = (int32_t)LIST_LENGTH(pDag->pSubplans);

×

2458

  if (levelNum <= 0) {

×

2459

    qError("invalid level num:%d", levelNum);

×

2460

    QRY_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);

×

2463

  QRY_ERR_JRET(qExplainInitCtx(&ctx, pDag->explainInfo.verbose, pDag->explainInfo.ratio, pDag->explainInfo.mode));

×

2465

  QRY_ERR_JRET(qExplainBuildPlanCtx(pDag, &ctx->planCtx));

×

2466

  ctx->groupNum = ctx->planCtx.groupNum;

×

2468

  if (pDag->pChildren && pDag->pChildren->length > 0) {

×

2469

    ctx->subPlanCtxs = taosArrayInit_s(sizeof(SExplainPlanCtx), pDag->pChildren->length);

×

2470

    if (NULL == ctx->subPlanCtxs) {

×

2471

      qError("taosArrayInit %d explainPlanCtx failed, error:%s", pDag->pChildren->length, tstrerror(terrno));

×

2472

      QRY_ERR_JRET(terrno);

×

2475

    SNode* pNode = NULL;

×

2476

    int32_t i = 0;

×

2477

    FOREACH(pNode, pDag->pChildren) {

×

2478

      SExplainPlanCtx* pSub = taosArrayGet(ctx->subPlanCtxs, i);

×

2479

      QRY_ERR_JRET(qExplainBuildPlanCtx((SQueryPlan*)pNode, pSub));

×

2480

      ctx->groupNum += pSub->groupNum;

×

2481

      i++;

×

2485

  *pCtx = ctx;

×

2487

  return TSDB_CODE_SUCCESS;

×

2489

_return:

×

2491

  qExplainFreeCtx(ctx);

×

2493

  QRY_RET(code);

×

2496

static int32_t qExplainAppendPlanRows(SExplainCtx *pCtx) {

×

2497

  if (EXPLAIN_MODE_ANALYZE != pCtx->mode) {

×

2498

    return TSDB_CODE_SUCCESS;

×

2501

  int32_t tlen = 0;

×

2502

  char   *tbuf = pCtx->tbuf;

×

2504

  EXPLAIN_SUM_ROW_NEW(EXPLAIN_RATIO_TIME_FORMAT, pCtx->ratio);

×

2505

  EXPLAIN_SUM_ROW_END();

×

2506

  QRY_ERR_RET(qExplainResAppendRow(pCtx, tbuf, tlen, 0));

×

2508

  EXPLAIN_SUM_ROW_NEW(EXPLAIN_PLANNING_TIME_FORMAT, (double)(pCtx->jobStartTs - pCtx->reqStartTs) / 1000.0);

×

2509

  EXPLAIN_SUM_ROW_END();

×

2510

  QRY_ERR_RET(qExplainResAppendRow(pCtx, tbuf, tlen, 0));

×

2512

  EXPLAIN_SUM_ROW_NEW(EXPLAIN_EXEC_TIME_FORMAT, (double)(pCtx->jobDoneTs - pCtx->jobStartTs) / 1000.0);

×

2513

  EXPLAIN_SUM_ROW_END();

×

2514

  QRY_ERR_RET(qExplainResAppendRow(pCtx, tbuf, tlen, 0));

×

2516

  return TSDB_CODE_SUCCESS;

×

2519

static int32_t qExplainGenerateRsp(SExplainCtx *pCtx, SRetrieveTableRsp **pRsp) {

×

2520

  int32_t level = 0;

×

2522

  pCtx->currPlanId = -1;

×

2523

  pCtx->pCurrPlanCtx = &pCtx->planCtx;

×

2524

  QRY_ERR_RET(qExplainAppendGroupResRows(pCtx, pCtx->pCurrPlanCtx->rootGroupId, &level, false));

×

2526

  if (pCtx->subPlanCtxs) {

×

2527

    int32_t subNum = taosArrayGetSize(pCtx->subPlanCtxs);

×

2528

    for (pCtx->currPlanId = subNum - 1; pCtx->currPlanId >= 0; --pCtx->currPlanId) {

×

2529

      pCtx->pCurrPlanCtx = taosArrayGet(pCtx->subPlanCtxs, pCtx->currPlanId);

×

2530

      level = 0;

×

2531

      QRY_ERR_RET(qExplainAppendGroupResRows(pCtx, pCtx->pCurrPlanCtx->rootGroupId, &level, false));

×

2534

  QRY_ERR_RET(qExplainAppendPlanRows(pCtx));

×

2535

  QRY_ERR_RET(qExplainGetRspFromCtx(pCtx, pRsp));

×

2537

  return TSDB_CODE_SUCCESS;

×

2540

int32_t qExplainUpdateExecInfo(SExplainCtx *pCtx, SExplainPlanCtx *pCurrPlanCtx, SExplainRsp *pRspMsg, int32_t groupId, SRetrieveTableRsp **pRsp) {

×

2541

  if (!pCtx || !pCurrPlanCtx || !pRspMsg || !pRsp) return TSDB_CODE_INVALID_PARA;

×

2542

  SExplainResNode *node = NULL;

×

2543

  int32_t          code = 0;

×

2544

  bool             groupDone = false;

×

2546

  SExplainGroup *group = taosHashGet(pCurrPlanCtx->groupHash, &groupId, sizeof(groupId));

×

2547

  if (NULL == group) {

×

2548

    qError("group %d not in groupHash", groupId);

×

2549

    tFreeSExplainRsp(pRspMsg);

×

2550

    QRY_ERR_RET(TSDB_CODE_APP_ERROR);

×

2553

  taosWLockLatch(&group->lock);

×

2554

  if (NULL == group->nodeExecInfo) {

×

2555

    group->nodeExecInfo = taosArrayInit(group->nodeNum, sizeof(SExplainRsp));

×

2556

    if (NULL == group->nodeExecInfo) {

×

2557

      qError("taosArrayInit %d explainExecInfo failed", group->nodeNum);

×

2558

      code = terrno;

×

2559

      TAOS_CHECK_ERRNO(code);

×

2562

    group->physiPlanExecNum = pRspMsg->numOfPlans;

×

2563

  } else if (taosArrayGetSize(group->nodeExecInfo) >= group->nodeNum) {

×

2564

    qError("group execInfo already full, size:%d, nodeNum:%d", (int32_t)taosArrayGetSize(group->nodeExecInfo),

×

2566

    code = TSDB_CODE_APP_ERROR;

×

2567

    TAOS_CHECK_ERRNO(code);

×

2570

  if (group->physiPlanExecNum != pRspMsg->numOfPlans) {

×

2571

    qError("physiPlanExecNum %d mismatch with others %d in group %d", pRspMsg->numOfPlans, group->physiPlanExecNum,

×

2573

    code = TSDB_CODE_APP_ERROR;

×

2574

    TAOS_CHECK_ERRNO(code);

×

2577

  if(taosArrayPush(group->nodeExecInfo, pRspMsg) == NULL)

×

2579

    code = terrno;

×

2580

    TAOS_CHECK_ERRNO(code);

×

2583

  groupDone = (taosArrayGetSize(group->nodeExecInfo) >= group->nodeNum);

×

2585

  taosWUnLockLatch(&group->lock);

×

2587

  if (groupDone && (pCtx->groupNum == atomic_add_fetch_32(&pCtx->groupDoneNum, 1))) {

×

2588

    if (atomic_load_8((int8_t *)&pCtx->execDone)) {

×

2589

      if (0 == taosWTryLockLatch(&pCtx->lock)) {

×

2590

        QRY_ERR_RET(qExplainGenerateRsp(pCtx, pRsp));

×

2596

  return TSDB_CODE_SUCCESS;

×

2598

_exit:

×

2599

  tFreeSExplainRsp(pRspMsg);

×

2600

  taosWUnLockLatch(&group->lock);

×

2601

  return code;

×

2604

int32_t qExecStaticExplain(SQueryPlan *pDag, SRetrieveTableRsp **pRsp) {

×

2605

  if (!pDag || !pRsp) return TSDB_CODE_INVALID_PARA;

×

2606

  int32_t      code = 0;

×

2607

  SExplainCtx *pCtx = NULL;

×

2609

  QRY_ERR_RET(qExplainBuildCtx(pDag, &pCtx));

×

2610

  QRY_ERR_JRET(qExplainGenerateRsp(pCtx, pRsp));

×

2612

_return:

×

2613

  qExplainFreeCtx(pCtx);

×

2614

  QRY_RET(code);

×

2617

int32_t qExecExplainBegin(SQueryPlan *pDag, SExplainCtx **pCtx, int64_t startTs) {

×

2618

  if(!pDag || !pCtx) return TSDB_CODE_INVALID_PARA;

×

2619

  QRY_ERR_RET(qExplainBuildCtx(pDag, pCtx));

×

2621

  (*pCtx)->reqStartTs = startTs;

×

2622

  (*pCtx)->jobStartTs = taosGetTimestampUs();

×

2624

  return TSDB_CODE_SUCCESS;

×

2627

int32_t qExecExplainEnd(SExplainCtx *pCtx, SRetrieveTableRsp **pRsp) {

×

2628

  if(!pCtx || !pRsp) {

×

2629

    return TSDB_CODE_INVALID_PARA;

×

2632

  int32_t code = 0;

×

2633

  pCtx->jobDoneTs = taosGetTimestampUs();

×

2635

  atomic_store_8((int8_t *)&pCtx->execDone, true);

×

2637

  if (pCtx->groupNum == atomic_load_32(&pCtx->groupDoneNum)) {

×

2638

    if (0 == taosWTryLockLatch(&pCtx->lock)) {

×

2639

      QRY_ERR_RET(qExplainGenerateRsp(pCtx, pRsp));

×

2644

  return TSDB_CODE_SUCCESS;

×

2647

SExplainPlanCtx* qExplainGetCurrPlan(SExplainCtx *pCtx, int32_t subJobId) {

×

2648

  return EXPLAIN_GET_CUR_PLAN_CTX(pCtx, subJobId);

×

taosdata / TDengine / #4986

Source File
Press 'n' to go to next uncovered line, 'b' for previous

taosdata / TDengine / #4986

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