taosdata/TDengine | Build 3599 | source/libs/executor/src/scanoperator.c | Coveralls

74

bool processBlockWithProbability(const SSampleExecInfo* pInfo) {

×

83

  return true;

×

87

static void switchCtxOrder(SqlFunctionCtx* pCtx, int32_t numOfOutput) {

×

88

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

×

89

    SWITCH_ORDER(pCtx[i].order);

×

91

×

93

static int32_t overlapWithTimeWindow(SInterval* pInterval, SDataBlockInfo* pBlockInfo, int32_t order, bool* overlap) {

×

94

  int32_t     code = TSDB_CODE_SUCCESS;

×

95

  STimeWindow w = {0};

×

98

  if (pInterval->interval == 0) {

×

99

    *overlap = false;

×

100

    return code;

×

103

  if (order == TSDB_ORDER_ASC) {

×

104

    w = getAlignQueryTimeWindow(pInterval, pBlockInfo->window.skey);

×

105

    if (w.ekey < pBlockInfo->window.skey) {

×

106

      qError("w.ekey:%" PRId64 " < pBlockInfo->window.skey:%" PRId64, w.ekey, pBlockInfo->window.skey);

×

107

      return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;

×

110

    if (w.ekey < pBlockInfo->window.ekey) {

×

111

      *overlap = true;

×

112

      return code;

×

116

      getNextTimeWindow(pInterval, &w, order);

×

117

      if (w.skey > pBlockInfo->window.ekey) {

×

118

        break;

×

121

      if (w.ekey <= pBlockInfo->window.ekey) {

×

122

        qError("w.ekey:%" PRId64 " <= pBlockInfo->window.ekey:%" PRId64, w.ekey, pBlockInfo->window.ekey);

×

123

        return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;

×

125

      if (TMAX(w.skey, pBlockInfo->window.skey) <= pBlockInfo->window.ekey) {

×

126

        *overlap = true;

×

127

        return code;

×

131

    w = getAlignQueryTimeWindow(pInterval, pBlockInfo->window.ekey);

×

132

    if (w.skey > pBlockInfo->window.ekey) {

×

133

      qError("w.skey:%" PRId64 " > pBlockInfo->window.skey:%" PRId64, w.skey, pBlockInfo->window.ekey);

×

134

      return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;

×

137

    if (w.skey > pBlockInfo->window.skey) {

×

138

      *overlap = true;

×

139

      return code;

×

143

      getNextTimeWindow(pInterval, &w, order);

×

144

      if (w.ekey < pBlockInfo->window.skey) {

×

145

        break;

×

148

      if (w.skey >= pBlockInfo->window.skey) {

×

149

        qError("w.skey:%" PRId64 " >= pBlockInfo->window.skey:%" PRId64, w.skey, pBlockInfo->window.skey);

×

150

        return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;

×

152

      if (pBlockInfo->window.skey <= TMIN(w.ekey, pBlockInfo->window.ekey)) {

×

153

        *overlap = true;

×

154

        return code;

×

159

  *overlap = false;

×

160

  return code;

×

164

static SResultRow* getTableGroupOutputBuf(SOperatorInfo* pOperator, uint64_t groupId, SFilePage** pPage) {

×

165

  if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN) {

×

166

    return NULL;

×

169

  int64_t buf[2] = {0};

×

170

  SET_RES_WINDOW_KEY((char*)buf, &groupId, sizeof(groupId), groupId);

×

172

  STableScanInfo* pTableScanInfo = pOperator->info;

×

174

  SResultRowPosition* p1 = (SResultRowPosition*)tSimpleHashGet(pTableScanInfo->base.pdInfo.pAggSup->pResultRowHashTable,

×

177

  if (p1 == NULL) {

×

178

    return NULL;

×

181

  *pPage = getBufPage(pTableScanInfo->base.pdInfo.pAggSup->pResultBuf, p1->pageId);

×

182

  if (NULL == *pPage) {

×

183

    return NULL;

×

186

  return (SResultRow*)((char*)(*pPage) + p1->offset);

×

189

static int32_t insertTableToScanIgnoreList(STableScanInfo* pTableScanInfo, uint64_t uid) {

×

190

  if (NULL == pTableScanInfo->pIgnoreTables) {

×

191

    int32_t tableNum = taosArrayGetSize(pTableScanInfo->base.pTableListInfo->pTableList);

×

192

    pTableScanInfo->pIgnoreTables =

×

193

        taosHashInit(tableNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK);

×

194

    if (NULL == pTableScanInfo->pIgnoreTables) {

×

195

      return terrno;

×

199

  int32_t tempRes = taosHashPut(pTableScanInfo->pIgnoreTables, &uid, sizeof(uid), &pTableScanInfo->scanTimes,

×

201

  if (tempRes != TSDB_CODE_SUCCESS && tempRes != TSDB_CODE_DUP_KEY) {

×

202

    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(tempRes));

×

203

    return tempRes;

×

205

  return TSDB_CODE_SUCCESS;

×

208

static int32_t doDynamicPruneDataBlock(SOperatorInfo* pOperator, SDataBlockInfo* pBlockInfo, uint32_t* status) {

×

209

  STableScanInfo* pTableScanInfo = pOperator->info;

×

210

  int32_t         code = TSDB_CODE_SUCCESS;

×

212

  if (pTableScanInfo->base.pdInfo.pExprSup == NULL) {

×

213

    return TSDB_CODE_SUCCESS;

×

216

  SExprSupp* pSup1 = pTableScanInfo->base.pdInfo.pExprSup;

×

218

  SFilePage*  pPage = NULL;

×

219

  SResultRow* pRow = getTableGroupOutputBuf(pOperator, pBlockInfo->id.groupId, &pPage);

×

221

  if (pRow == NULL) {

×

222

    return TSDB_CODE_SUCCESS;

×

225

  bool notLoadBlock = true;

×

226

  for (int32_t i = 0; i < pSup1->numOfExprs; ++i) {

×

227

    int32_t functionId = pSup1->pCtx[i].functionId;

×

229

    SResultRowEntryInfo* pEntry = getResultEntryInfo(pRow, i, pTableScanInfo->base.pdInfo.pExprSup->rowEntryInfoOffset);

×

231

    EFuncDataRequired reqStatus = fmFuncDynDataRequired(functionId, pEntry, pBlockInfo);

×

232

    if (reqStatus != FUNC_DATA_REQUIRED_NOT_LOAD) {

×

233

      notLoadBlock = false;

×

234

      break;

×

239

  releaseBufPage(pTableScanInfo->base.pdInfo.pAggSup->pResultBuf, pPage);

×

241

  if (notLoadBlock) {

×

242

    *status = FUNC_DATA_REQUIRED_NOT_LOAD;

×

243

    code = insertTableToScanIgnoreList(pTableScanInfo, pBlockInfo->id.uid);

×

246

  return code;

×

249

static int32_t doFilterByBlockSMA(SFilterInfo* pFilterInfo, SColumnDataAgg* pColsAgg, int32_t numOfCols,

×

251

  if (pColsAgg == NULL || pFilterInfo == NULL) {

×

252

    *keep = true;

×

253

    return TSDB_CODE_SUCCESS;

×

256

  return filterRangeExecute(pFilterInfo, pColsAgg, numOfCols, numOfRows, keep);

×

259

static int32_t doLoadBlockSMA(STableScanBase* pTableScanInfo, SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo,

×

261

  SStorageAPI* pAPI = &pTaskInfo->storageAPI;

×

262

  bool         allColumnsHaveAgg = true;

×

263

  bool         hasNullSMA = false;

×

264

  if (pLoad != NULL) {

×

265

    *pLoad = false;

×

268

  int32_t code = pAPI->tsdReader.tsdReaderRetrieveBlockSMAInfo(pTableScanInfo->dataReader, pBlock, &allColumnsHaveAgg,

×

270

  if (code != TSDB_CODE_SUCCESS) {

×

271

    return code;

×

274

  if (!allColumnsHaveAgg || hasNullSMA) {

×

275

    *pLoad = false;

×

277

    *pLoad = true;

×

280

  return code;

×

283

static int32_t doSetTagColumnData(STableScanBase* pTableScanInfo, SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo,

×

285

  int32_t    code = 0;

×

286

  SExprSupp* pSup = &pTableScanInfo->pseudoSup;

×

287

  if (pSup->numOfExprs > 0) {

×

288

    code = addTagPseudoColumnData(&pTableScanInfo->readHandle, pSup->pExprInfo, pSup->numOfExprs, pBlock, rows,

×

291

    if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {

×

292

      if (pTaskInfo->streamInfo.pState) blockDataCleanup(pBlock);

×

293

      code = 0;

×

297

  return code;

×

300

bool applyLimitOffset(SLimitInfo* pLimitInfo, SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo) {

×

301

  SLimit*     pLimit = &pLimitInfo->limit;

×

302

  const char* id = GET_TASKID(pTaskInfo);

×

304

  if (pLimitInfo->remainOffset > 0) {

×

305

    if (pLimitInfo->remainOffset >= pBlock->info.rows) {

×

306

      pLimitInfo->remainOffset -= pBlock->info.rows;

×

307

      blockDataEmpty(pBlock);

×

308

      qDebug("current block ignore due to offset, current:%" PRId64 ", %s", pLimitInfo->remainOffset, id);

×

309

      return false;

×

311

      int32_t code = blockDataTrimFirstRows(pBlock, pLimitInfo->remainOffset);

×

312

      if (code != TSDB_CODE_SUCCESS) {

×

313

        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));

×

314

        pTaskInfo->code = code;

×

315

        T_LONG_JMP(pTaskInfo->env, code);

×

317

      pLimitInfo->remainOffset = 0;

×

321

  if (pLimit->limit != -1 && pLimit->limit <= (pLimitInfo->numOfOutputRows + pBlock->info.rows)) {

×

323

    int32_t keep = (int32_t)(pLimit->limit - pLimitInfo->numOfOutputRows);

×

324

    blockDataKeepFirstNRows(pBlock, keep);

×

326

    pLimitInfo->numOfOutputRows += pBlock->info.rows;

×

327

    qDebug("output limit %" PRId64 " has reached, %s", pLimit->limit, id);

×

328

    return true;

×

331

  pLimitInfo->numOfOutputRows += pBlock->info.rows;

×

332

  return false;

×

335

static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanBase* pTableScanInfo, SSDataBlock* pBlock,

×

337

  int32_t        code = TSDB_CODE_SUCCESS;

×

338

  int32_t        lino = 0;

×

339

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

×

340

  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;

×

341

  bool           loadSMA = false;

×

343

  SFileBlockLoadRecorder* pCost = &pTableScanInfo->readRecorder;

×

345

  pCost->totalBlocks += 1;

×

346

  pCost->totalRows += pBlock->info.rows;

×

347

  *status = pTableScanInfo->dataBlockLoadFlag;

×

349

  if (pOperator->exprSupp.pFilterInfo != NULL) {

×

350

    (*status) = FUNC_DATA_REQUIRED_DATA_LOAD;

×

352

    bool overlap = false;

×

354

        overlapWithTimeWindow(&pTableScanInfo->pdInfo.interval, &pBlock->info, pTableScanInfo->cond.order, &overlap);

×

355

    if (ret != TSDB_CODE_SUCCESS) {

×

356

      return ret;

×

358

    if (overlap) {

×

359

      (*status) = FUNC_DATA_REQUIRED_DATA_LOAD;

×

363

  SDataBlockInfo* pBlockInfo = &pBlock->info;

×

364

  taosMemoryFreeClear(pBlock->pBlockAgg);

×

366

  if (*status == FUNC_DATA_REQUIRED_FILTEROUT) {

×

367

    qDebug("%s data block filter out, brange:%" PRId64 "-%" PRId64 ", rows:%" PRId64, GET_TASKID(pTaskInfo),

×

369

    pCost->filterOutBlocks += 1;

×

370

    pCost->totalRows += pBlock->info.rows;

×

371

    pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->dataReader);

×

372

    return TSDB_CODE_SUCCESS;

×

373

  } else if (*status == FUNC_DATA_REQUIRED_NOT_LOAD) {

×

374

    qDebug("%s data block skipped, brange:%" PRId64 "-%" PRId64 ", rows:%" PRId64 ", uid:%" PRIu64,

×

377

    code = doSetTagColumnData(pTableScanInfo, pBlock, pTaskInfo, pBlock->info.rows);

×

378

    pCost->skipBlocks += 1;

×

379

    pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->dataReader);

×

380

    return code;

×

381

  } else if (*status == FUNC_DATA_REQUIRED_SMA_LOAD) {

×

382

    pCost->loadBlockStatis += 1;

×

383

    loadSMA = true;  // mark the operation of load sma;

×

384

    bool success = true;

×

385

    code = doLoadBlockSMA(pTableScanInfo, pBlock, pTaskInfo, &success);

×

386

    if (code) {

×

387

      pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->dataReader);

×

388

      qError("%s failed to retrieve sma info", GET_TASKID(pTaskInfo));

×

389

      QUERY_CHECK_CODE(code, lino, _end);

×

392

    if (success) {  // failed to load the block sma data, data block statistics does not exist, load data block instead

×

393

      qDebug("%s data block SMA loaded, brange:%" PRId64 "-%" PRId64 ", rows:%" PRId64, GET_TASKID(pTaskInfo),

×

395

      code = doSetTagColumnData(pTableScanInfo, pBlock, pTaskInfo, pBlock->info.rows);

×

396

      pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->dataReader);

×

397

      return code;

×

399

      qDebug("%s failed to load SMA, since not all columns have SMA", GET_TASKID(pTaskInfo));

×

400

      *status = FUNC_DATA_REQUIRED_DATA_LOAD;

×

404

  if (*status != FUNC_DATA_REQUIRED_DATA_LOAD) {

×

405

    pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->dataReader);

×

406

    qError("%s loadDataBlock invalid status:%d", GET_TASKID(pTaskInfo), *status);

×

407

    return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;

×

411

  if (pOperator->exprSupp.pFilterInfo != NULL && (!loadSMA)) {

×

412

    bool success = true;

×

413

    code = doLoadBlockSMA(pTableScanInfo, pBlock, pTaskInfo, &success);

×

414

    if (code) {

×

415

      pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->dataReader);

×

416

      qError("%s failed to retrieve sma info", GET_TASKID(pTaskInfo));

×

417

      QUERY_CHECK_CODE(code, lino, _end);

×

420

    if (success) {

×

421

      size_t size = taosArrayGetSize(pBlock->pDataBlock);

×

422

      bool   keep = false;

×

423

      code = doFilterByBlockSMA(pOperator->exprSupp.pFilterInfo, pBlock->pBlockAgg, size, pBlockInfo->rows, &keep);

×

424

      if (code) {

×

425

        pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->dataReader);

×

426

        qError("%s failed to do filter by block sma, code:%s", GET_TASKID(pTaskInfo), tstrerror(code));

×

427

        QUERY_CHECK_CODE(code, lino, _end);

×

430

      if (!keep) {

×

431

        qDebug("%s data block filter out by block SMA, brange:%" PRId64 "-%" PRId64 ", rows:%" PRId64,

×

433

        pCost->filterOutBlocks += 1;

×

434

        (*status) = FUNC_DATA_REQUIRED_FILTEROUT;

×

435

        taosMemoryFreeClear(pBlock->pBlockAgg);

×

437

        pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->dataReader);

×

438

        return TSDB_CODE_SUCCESS;

×

444

  taosMemoryFreeClear(pBlock->pBlockAgg);

×

447

  code = doDynamicPruneDataBlock(pOperator, pBlockInfo, status);

×

448

  if (code) {

×

449

    pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->dataReader);

×

450

    QUERY_CHECK_CODE(code, lino, _end);

×

453

  if (*status == FUNC_DATA_REQUIRED_NOT_LOAD) {

×

454

    qDebug("%s data block skipped due to dynamic prune, brange:%" PRId64 "-%" PRId64 ", rows:%" PRId64,

×

456

    pCost->skipBlocks += 1;

×

457

    pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->dataReader);

×

459

    STableScanInfo* p1 = pOperator->info;

×

460

    if (taosHashGetSize(p1->pIgnoreTables) == taosArrayGetSize(p1->base.pTableListInfo->pTableList)) {

×

461

      *status = FUNC_DATA_REQUIRED_ALL_FILTEROUT;

×

463

      *status = FUNC_DATA_REQUIRED_FILTEROUT;

×

465

    return TSDB_CODE_SUCCESS;

×

468

  pCost->totalCheckedRows += pBlock->info.rows;

×

469

  pCost->loadBlocks += 1;

×

471

  SSDataBlock* p = NULL;

×

472

  code = pAPI->tsdReader.tsdReaderRetrieveDataBlock(pTableScanInfo->dataReader, &p, NULL);

×

473

  if (p == NULL || code != TSDB_CODE_SUCCESS || p != pBlock) {

×

474

    return code;

×

477

  code = doSetTagColumnData(pTableScanInfo, pBlock, pTaskInfo, pBlock->info.rows);

×

478

  if (code) {

×

479

    return code;

×

483

  pCost->totalRows -= pBlock->info.rows;

×

485

  if (pOperator->exprSupp.pFilterInfo != NULL) {

×

486

    code = doFilter(pBlock, pOperator->exprSupp.pFilterInfo, &pTableScanInfo->matchInfo);

×

487

    QUERY_CHECK_CODE(code, lino, _end);

×

489

    int64_t st = taosGetTimestampUs();

×

490

    double  el = (taosGetTimestampUs() - st) / 1000.0;

×

491

    pTableScanInfo->readRecorder.filterTime += el;

×

493

    if (pBlock->info.rows == 0) {

×

494

      pCost->filterOutBlocks += 1;

×

495

      qDebug("%s data block filter out, brange:%" PRId64 "-%" PRId64 ", rows:%" PRId64 ", elapsed time:%.2f ms",

×

498

      qDebug("%s data block filter applied, elapsed time:%.2f ms", GET_TASKID(pTaskInfo), el);

×

502

  bool limitReached = applyLimitOffset(&pTableScanInfo->limitInfo, pBlock, pTaskInfo);

×

503

  if (limitReached) {  // set operator flag is done

×

504

    setOperatorCompleted(pOperator);

×

507

  pCost->totalRows += pBlock->info.rows;

×

509

_end:

×

510

  if (code != TSDB_CODE_SUCCESS) {

×

511

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

513

  return code;

×

516

static void prepareForDescendingScan(STableScanBase* pTableScanInfo, SqlFunctionCtx* pCtx, int32_t numOfOutput) {

×

517

  SET_REVERSE_SCAN_FLAG(pTableScanInfo);

×

519

  switchCtxOrder(pCtx, numOfOutput);

×

520

  pTableScanInfo->cond.order = TSDB_ORDER_DESC;

×

521

  STimeWindow* pTWindow = &pTableScanInfo->cond.twindows;

×

522

  TSWAP(pTWindow->skey, pTWindow->ekey);

×

523

×

530

static void freeTableCachedVal(void* param) {

×

531

  if (param == NULL) {

×

532

    return;

×

535

  STableCachedVal* pVal = param;

×

536

  taosMemoryFree((void*)pVal->pName);

×

537

  taosMemoryFree(pVal->pTags);

×

538

  taosMemoryFree(pVal);

×

541

static int32_t createTableCacheVal(const SMetaReader* pMetaReader, STableCachedVal** ppResVal) {

×

542

  int32_t          code = TSDB_CODE_SUCCESS;

×

543

  int32_t          lino = 0;

×

544

  STableCachedVal* pVal = taosMemoryMalloc(sizeof(STableCachedVal));

×

545

  QUERY_CHECK_NULL(pVal, code, lino, _end, terrno);

×

547

  pVal->pTags = NULL;

×

548

  pVal->pName = taosStrdup(pMetaReader->me.name);

×

549

  QUERY_CHECK_NULL(pVal->pName, code, lino, _end, terrno);

×

552

  if (pMetaReader->me.type == TSDB_CHILD_TABLE) {

×

553

    STag* pTag = (STag*)pMetaReader->me.ctbEntry.pTags;

×

554

    pVal->pTags = taosMemoryMalloc(pTag->len);

×

555

    QUERY_CHECK_NULL(pVal->pTags, code, lino, _end, terrno);

×

556

    memcpy(pVal->pTags, pTag, pTag->len);

×

559

  (*ppResVal) = pVal;

×

561

_end:

×

562

  if (code != TSDB_CODE_SUCCESS) {

×

563

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

564

    freeTableCachedVal(pVal);

×

566

  return code;

×

570

static void freeCachedMetaItem(const void* key, size_t keyLen, void* value, void* ud) {

×

574

  freeTableCachedVal(value);

×

575

×

577

static void doSetNullValue(SSDataBlock* pBlock, const SExprInfo* pExpr, int32_t numOfExpr) {

×

578

  for (int32_t j = 0; j < numOfExpr; ++j) {

×

579

    int32_t dstSlotId = pExpr[j].base.resSchema.slotId;

×

581

    SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, dstSlotId);

×

582

    colDataSetNNULL(pColInfoData, 0, pBlock->info.rows);

×

584

×

586

static void freeTableCachedValObj(STableCachedVal* pVal) {

×

587

  taosMemoryFree((void*)pVal->pName);

×

588

  taosMemoryFree(pVal->pTags);

×

589

×

591

int32_t addTagPseudoColumnData(SReadHandle* pHandle, const SExprInfo* pExpr, int32_t numOfExpr, SSDataBlock* pBlock,

×

593

  int32_t          code = TSDB_CODE_SUCCESS;

×

594

  int32_t          lino = 0;

×

595

  bool             freeReader = false;

×

596

  LRUHandle*       h = NULL;

×

597

  STableCachedVal  val = {0};

×

598

  SMetaReader      mr = {0};

×

599

  const char*      idStr = pTask->id.str;

×

600

  int32_t          insertRet = TAOS_LRU_STATUS_OK;

×

601

  STableCachedVal* pVal = NULL;

×

604

  if (numOfExpr <= 0) {

×

605

    return TSDB_CODE_SUCCESS;

×

611

  int32_t backupRows = pBlock->info.rows;

×

612

  pBlock->info.rows = rows;

×

618

  if (pCache == NULL) {

×

619

    pHandle->api.metaReaderFn.initReader(&mr, pHandle->vnode, META_READER_LOCK, &pHandle->api.metaFn);

×

620

    code = pHandle->api.metaReaderFn.getEntryGetUidCache(&mr, pBlock->info.id.uid);

×

621

    if (code != TSDB_CODE_SUCCESS) {

×

623

      if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {

×

624

        qWarn("failed to get table meta, table may have been dropped, uid:0x%" PRIx64 ", code:%s, %s",

×

628

        doSetNullValue(pBlock, pExpr, numOfExpr);

×

630

        qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", pBlock->info.id.uid, tstrerror(code), idStr);

×

632

      pHandle->api.metaReaderFn.clearReader(&mr);

×

633

      return code;

×

636

    pHandle->api.metaReaderFn.readerReleaseLock(&mr);

×

638

    val.pName = mr.me.name;

×

639

    val.pTags = (STag*)mr.me.ctbEntry.pTags;

×

641

    freeReader = true;

×

643

    pCache->metaFetch += 1;

×

645

    h = taosLRUCacheLookup(pCache->pTableMetaEntryCache, &pBlock->info.id.uid, sizeof(pBlock->info.id.uid));

×

646

    if (h == NULL) {

×

647

      pHandle->api.metaReaderFn.initReader(&mr, pHandle->vnode, META_READER_LOCK, &pHandle->api.metaFn);

×

648

      freeReader = true;

×

649

      code = pHandle->api.metaReaderFn.getEntryGetUidCache(&mr, pBlock->info.id.uid);

×

650

      if (code != TSDB_CODE_SUCCESS) {

×

651

        if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {

×

652

          qWarn("failed to get table meta, table may have been dropped, uid:0x%" PRIx64 ", code:%s, %s",

×

655

          doSetNullValue(pBlock, pExpr, numOfExpr);

×

657

          qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", pBlock->info.id.uid, tstrerror(code),

×

660

        pHandle->api.metaReaderFn.clearReader(&mr);

×

661

        return code;

×

664

      pHandle->api.metaReaderFn.readerReleaseLock(&mr);

×

666

      code = createTableCacheVal(&mr, &pVal);

×

667

      QUERY_CHECK_CODE(code, lino, _end);

×

669

      val = *pVal;

×

671

      pCache->cacheHit += 1;

×

672

      STableCachedVal* pValTmp = taosLRUCacheValue(pCache->pTableMetaEntryCache, h);

×

673

      val = *pValTmp;

×

675

      bool bRes = taosLRUCacheRelease(pCache->pTableMetaEntryCache, h, false);

×

676

      qTrace("release LRU cache, res %d", bRes);

×

679

    qDebug("retrieve table meta from cache:%" PRIu64 ", hit:%" PRIu64 " miss:%" PRIu64 ", %s", pCache->metaFetch,

×

683

  for (int32_t j = 0; j < numOfExpr; ++j) {

×

684

    const SExprInfo* pExpr1 = &pExpr[j];

×

685

    int32_t          dstSlotId = pExpr1->base.resSchema.slotId;

×

687

    SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, dstSlotId);

×

688

    colInfoDataCleanup(pColInfoData, pBlock->info.rows);

×

690

    int32_t functionId = pExpr1->pExpr->_function.functionId;

×

693

    if (fmIsScanPseudoColumnFunc(functionId)) {

×

694

      int32_t fType = pExpr1->pExpr->_function.functionType;

×

695

      if (fType == FUNCTION_TYPE_TBNAME) {

×

696

        code = setTbNameColData(pBlock, pColInfoData, functionId, val.pName);

×

697

        QUERY_CHECK_CODE(code, lino, _end);

×

698

      } else if (fType == FUNCTION_TYPE_VGID) {

×

699

        code = setVgIdColData(pBlock, pColInfoData, functionId, pTask->id.vgId);

×

700

        QUERY_CHECK_CODE(code, lino, _end);

×

701

      } else if (fType == FUNCTION_TYPE_VGVER) {

×

702

        code = setVgVerColData(pBlock, pColInfoData, functionId, pBlock->info.version);

×

703

        QUERY_CHECK_CODE(code, lino, _end);

×

706

      STagVal tagVal = {0};

×

707

      tagVal.cid = pExpr1->base.pParam[0].pCol->colId;

×

708

      const char* p = pHandle->api.metaFn.extractTagVal(val.pTags, pColInfoData->info.type, &tagVal);

×

710

      char* data = NULL;

×

711

      if (pColInfoData->info.type != TSDB_DATA_TYPE_JSON && p != NULL) {

×

712

        data = tTagValToData((const STagVal*)p, false);

×

714

        data = (char*)p;

×

717

      bool isNullVal = (data == NULL) || (pColInfoData->info.type == TSDB_DATA_TYPE_JSON && tTagIsJsonNull(data));

×

718

      if (isNullVal) {

×

719

        colDataSetNNULL(pColInfoData, 0, pBlock->info.rows);

×

720

      } else if (pColInfoData->info.type != TSDB_DATA_TYPE_JSON) {

×

721

        code = colDataSetNItems(pColInfoData, 0, data, pBlock->info.rows, false);

×

722

        if (IS_VAR_DATA_TYPE(((const STagVal*)p)->type)) {

×

723

          taosMemoryFree(data);

×

725

        QUERY_CHECK_CODE(code, lino, _end);

×

727

        for (int32_t i = 0; i < pBlock->info.rows; ++i) {

×

728

          code = colDataSetVal(pColInfoData, i, data, false);

×

729

          QUERY_CHECK_CODE(code, lino, _end);

×

736

  pBlock->info.rows = backupRows;

×

738

_end:

×

740

  if (NULL != pVal) {

×

741

    insertRet = taosLRUCacheInsert(pCache->pTableMetaEntryCache, &pBlock->info.id.uid, sizeof(uint64_t), pVal,

×

743

    if (insertRet != TAOS_LRU_STATUS_OK) {

×

744

      qWarn("failed to put meta into lru cache, code:%d, %s", insertRet, idStr);

×

748

  if (freeReader) {

×

749

    pHandle->api.metaReaderFn.clearReader(&mr);

×

751

  if (code != TSDB_CODE_SUCCESS) {

×

752

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

754

  return code;

×

757

int32_t setTbNameColData(const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, int32_t functionId,

×

759

  int32_t                     code = TSDB_CODE_SUCCESS;

×

760

  int32_t                     lino = 0;

×

761

  struct SScalarFuncExecFuncs fpSet = {0};

×

762

  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);

×

763

  QUERY_CHECK_CODE(code, lino, _end);

×

765

  size_t len = TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE;

×

766

  char   buf[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};

×

767

  STR_TO_VARSTR(buf, name)

×

769

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

×

771

  code = colInfoDataEnsureCapacity(&infoData, 1, false);

×

772

  QUERY_CHECK_CODE(code, lino, _end);

×

774

  code = colDataSetVal(&infoData, 0, buf, false);

×

775

  QUERY_CHECK_CODE(code, lino, _end);

×

777

  SScalarParam srcParam = {.numOfRows = pBlock->info.rows, .columnData = &infoData};

×

778

  SScalarParam param = {.columnData = pColInfoData};

×

780

  if (fpSet.process != NULL) {

×

781

    code = fpSet.process(&srcParam, 1, &param);

×

782

    QUERY_CHECK_CODE(code, lino, _end);

×

784

    qError("failed to get the corresponding callback function, functionId:%d", functionId);

×

787

  colDataDestroy(&infoData);

×

789

_end:

×

790

  if (code != TSDB_CODE_SUCCESS) {

×

791

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

793

  return code;

×

796

int32_t setVgIdColData(const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, int32_t functionId, int32_t vgId) {

×

797

  int32_t                     code = TSDB_CODE_SUCCESS;

×

798

  int32_t                     lino = 0;

×

799

  struct SScalarFuncExecFuncs fpSet = {0};

×

800

  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);

×

801

  QUERY_CHECK_CODE(code, lino, _end);

×

803

  SColumnInfoData infoData = createColumnInfoData(pColInfoData->info.type, pColInfoData->info.bytes, 1);

×

805

  code = colInfoDataEnsureCapacity(&infoData, 1, false);

×

806

  QUERY_CHECK_CODE(code, lino, _end);

×

808

  code = colDataSetVal(&infoData, 0, (const char*)&vgId, false);

×

809

  QUERY_CHECK_CODE(code, lino, _end);

×

811

  SScalarParam srcParam = {.numOfRows = pBlock->info.rows, .columnData = &infoData};

×

812

  SScalarParam param = {.columnData = pColInfoData};

×

814

  if (fpSet.process != NULL) {

×

815

    code = fpSet.process(&srcParam, 1, &param);

×

816

    QUERY_CHECK_CODE(code, lino, _end);

×

818

    qError("failed to get the corresponding callback function, functionId:%d", functionId);

×

821

_end:

×

822

  colDataDestroy(&infoData);

×

823

  if (code != TSDB_CODE_SUCCESS) {

×

824

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

826

  return code;

×

829

int32_t setVgVerColData(const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, int32_t functionId, int64_t vgVer) {

×

830

  int32_t                     code = TSDB_CODE_SUCCESS;

×

831

  int32_t                     lino = 0;

×

832

  struct SScalarFuncExecFuncs fpSet = {0};

×

833

  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);

×

834

  QUERY_CHECK_CODE(code, lino, _end);

×

836

  SColumnInfoData infoData = createColumnInfoData(pColInfoData->info.type, pColInfoData->info.bytes, 1);

×

838

  code = colInfoDataEnsureCapacity(&infoData, 1, false);

×

839

  QUERY_CHECK_CODE(code, lino, _end);

×

841

  code = colDataSetVal(&infoData, 0, (const char*)&vgVer, false);

×

842

  QUERY_CHECK_CODE(code, lino, _end);

×

844

  SScalarParam srcParam = {.numOfRows = pBlock->info.rows, .columnData = &infoData};

×

845

  SScalarParam param = {.columnData = pColInfoData};

×

847

  if (fpSet.process != NULL) {

×

848

    code = fpSet.process(&srcParam, 1, &param);

×

849

    QUERY_CHECK_CODE(code, lino, _end);

×

851

    qError("failed to get the corresponding callback function, functionId:%d", functionId);

×

854

_end:

×

855

  colDataDestroy(&infoData);

×

856

  if (code != TSDB_CODE_SUCCESS) {

×

857

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

859

  return code;

×

862

static int32_t initNextGroupScan(STableScanInfo* pInfo, STableKeyInfo** pKeyInfo, int32_t* size) {

×

863

  int32_t code = TSDB_CODE_SUCCESS;

×

864

  int32_t lino = 0;

×

865

  code = tableListGetGroupList(pInfo->base.pTableListInfo, pInfo->currentGroupId, pKeyInfo, size);

×

866

  QUERY_CHECK_CODE(code, lino, _end);

×

868

  pInfo->tableStartIndex = TARRAY_ELEM_IDX(pInfo->base.pTableListInfo->pTableList, *pKeyInfo);

×

869

  pInfo->tableEndIndex = (pInfo->tableStartIndex + (*size) - 1);

×

870

  pInfo->pResBlock->info.blankFill = false;

×

871

  taosMemoryFreeClear(pInfo->pResBlock->pBlockAgg);

×

873

  if (!pInfo->needCountEmptyTable) {

×

874

    pInfo->countState = TABLE_COUNT_STATE_END;

×

876

    pInfo->countState = TABLE_COUNT_STATE_SCAN;

×

879

_end:

×

880

  if (code != TSDB_CODE_SUCCESS) {

×

881

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

883

  return code;

×

886

void markGroupProcessed(STableScanInfo* pInfo, uint64_t groupId) {

×

887

  if (pInfo->countState == TABLE_COUNT_STATE_END) {

×

888

    return;

×

890

  if (pInfo->base.pTableListInfo->groupOffset) {

×

891

    pInfo->countState = TABLE_COUNT_STATE_PROCESSED;

×

893

    int32_t code = taosHashRemove(pInfo->base.pTableListInfo->remainGroups, &groupId, sizeof(groupId));

×

894

    if (code != TSDB_CODE_SUCCESS) {

×

895

      qDebug("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));

×

900

static SSDataBlock* getOneRowResultBlock(SExecTaskInfo* pTaskInfo, STableScanBase* pBase, SSDataBlock* pBlock,

×

902

  blockDataEmpty(pBlock);

×

903

  pBlock->info.rows = 1;

×

904

  pBlock->info.id.uid = tbInfo->uid;

×

905

  pBlock->info.id.groupId = tbInfo->groupId;

×

906

  pBlock->info.blankFill = true;

×

909

  int32_t col_num = blockDataGetNumOfCols(pBlock);

×

910

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

×

911

    SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, i);

×

916

  terrno = doSetTagColumnData(pBase, pBlock, pTaskInfo, 1);

×

918

  return pBlock;

×

921

static SSDataBlock* getBlockForEmptyTable(SOperatorInfo* pOperator, const STableKeyInfo* tbInfo) {

×

922

  STableScanInfo* pTableScanInfo = pOperator->info;

×

924

      getOneRowResultBlock(pOperator->pTaskInfo, &pTableScanInfo->base, pTableScanInfo->pResBlock, tbInfo);

×

926

  pOperator->resultInfo.totalRows++;

×

927

  return pBlock;

×

930

static int32_t doTableScanImplNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

×

931

  int32_t         code = TSDB_CODE_SUCCESS;

×

932

  int32_t         lino = 0;

×

933

  STableScanInfo* pTableScanInfo = pOperator->info;

×

934

  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;

×

935

  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;

×

936

  SSDataBlock*    pBlock = pTableScanInfo->pResBlock;

×

937

  bool            hasNext = false;

×

938

  int64_t         st = taosGetTimestampUs();

×

940

  QRY_PARAM_CHECK(ppRes);

×

941

  pBlock->info.dataLoad = false;

×

943

  while (true) {

×

944

    code = pAPI->tsdReader.tsdNextDataBlock(pTableScanInfo->base.dataReader, &hasNext);

×

945

    if (code != TSDB_CODE_SUCCESS) {

×

946

      pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->base.dataReader);

×

947

      QUERY_CHECK_CODE(code, lino, _end);

×

950

    if (!hasNext) {

×

951

      break;

×

954

    if (isTaskKilled(pTaskInfo)) {

×

955

      pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->base.dataReader);

×

956

      code = pTaskInfo->code;

×

957

      goto _end;

×

960

    if (pOperator->status == OP_EXEC_DONE) {

×

961

      pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->base.dataReader);

×

962

      break;

×

966

    bool processThisBlock = processBlockWithProbability(&pTableScanInfo->sample);

×

967

    if (!processThisBlock) {

×

968

      continue;

×

971

    if (pBlock->info.id.uid) {

×

972

      pBlock->info.id.groupId = tableListGetTableGroupId(pTableScanInfo->base.pTableListInfo, pBlock->info.id.uid);

×

975

    uint32_t status = 0;

×

976

    code = loadDataBlock(pOperator, &pTableScanInfo->base, pBlock, &status);

×

977

    QUERY_CHECK_CODE(code, lino, _end);

×

979

    if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {

×

980

      break;

×

984

    if (status == FUNC_DATA_REQUIRED_FILTEROUT || pBlock->info.rows == 0) {

×

985

      continue;

×

988

    pOperator->resultInfo.totalRows = pTableScanInfo->base.readRecorder.totalRows;

×

989

    pTableScanInfo->base.readRecorder.elapsedTime += (taosGetTimestampUs() - st) / 1000.0;

×

991

    pOperator->cost.totalCost = pTableScanInfo->base.readRecorder.elapsedTime;

×

992

    pBlock->info.scanFlag = pTableScanInfo->base.scanFlag;

×

994

    (*ppRes) = pBlock;

×

995

    return code;

×

998

_end:

×

999

  if (code != TSDB_CODE_SUCCESS) {

×

1000

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

1001

    pTaskInfo->code = code;

×

1002

    T_LONG_JMP(pTaskInfo->env, code);

×

1004

  return code;

×

1007

static int32_t doGroupedTableScan(SOperatorInfo* pOperator, SSDataBlock** pBlock) {

×

1008

  int32_t         code = TSDB_CODE_SUCCESS;

×

1009

  int32_t         lino = 0;

×

1010

  STableScanInfo* pTableScanInfo = pOperator->info;

×

1011

  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;

×

1012

  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;

×

1014

  QRY_PARAM_CHECK(pBlock);

×

1017

  if (pTableScanInfo->base.dataReader == NULL || pOperator->status == OP_EXEC_DONE) {

×

1018

    return code;

×

1022

  while (pTableScanInfo->scanTimes < pTableScanInfo->scanInfo.numOfAsc) {

×

1023

    SSDataBlock* p = NULL;

×

1024

    code = doTableScanImplNext(pOperator, &p);

×

1025

    QUERY_CHECK_CODE(code, lino, _end);

×

1027

    if (p != NULL) {

×

1028

      markGroupProcessed(pTableScanInfo, p->info.id.groupId);

×

1029

      *pBlock = p;

×

1030

      return code;

×

1033

    pTableScanInfo->scanTimes += 1;

×

1034

    taosHashClear(pTableScanInfo->pIgnoreTables);

×

1036

    if (pTableScanInfo->scanTimes < pTableScanInfo->scanInfo.numOfAsc) {

×

1037

      setTaskStatus(pTaskInfo, TASK_NOT_COMPLETED);

×

1038

      pTableScanInfo->base.scanFlag = MAIN_SCAN;

×

1039

      pTableScanInfo->base.dataBlockLoadFlag = FUNC_DATA_REQUIRED_DATA_LOAD;

×

1040

      qDebug("start to repeat ascending order scan data blocks due to query func required, %s", GET_TASKID(pTaskInfo));

×

1043

      code = pAPI->tsdReader.tsdReaderResetStatus(pTableScanInfo->base.dataReader, &pTableScanInfo->base.cond);

×

1044

      QUERY_CHECK_CODE(code, lino, _end);

×

1048

  int32_t total = pTableScanInfo->scanInfo.numOfAsc + pTableScanInfo->scanInfo.numOfDesc;

×

1049

  if (pTableScanInfo->scanTimes < total) {

×

1050

    if (pTableScanInfo->base.cond.order == TSDB_ORDER_ASC) {

×

1051

      prepareForDescendingScan(&pTableScanInfo->base, pOperator->exprSupp.pCtx, 0);

×

1052

      code = pAPI->tsdReader.tsdReaderResetStatus(pTableScanInfo->base.dataReader, &pTableScanInfo->base.cond);

×

1053

      QUERY_CHECK_CODE(code, lino, _end);

×

1054

      qDebug("%s start to descending order scan data blocks due to query func required", GET_TASKID(pTaskInfo));

×

1057

    while (pTableScanInfo->scanTimes < total) {

×

1058

      SSDataBlock* p = NULL;

×

1059

      code = doTableScanImplNext(pOperator, &p);

×

1060

      QUERY_CHECK_CODE(code, lino, _end);

×

1062

      if (p != NULL) {

×

1063

        markGroupProcessed(pTableScanInfo, p->info.id.groupId);

×

1064

        *pBlock = p;

×

1065

        return code;

×

1068

      pTableScanInfo->scanTimes += 1;

×

1069

      taosHashClear(pTableScanInfo->pIgnoreTables);

×

1071

      if (pTableScanInfo->scanTimes < total) {

×

1072

        setTaskStatus(pTaskInfo, TASK_NOT_COMPLETED);

×

1073

        pTableScanInfo->base.scanFlag = MAIN_SCAN;

×

1075

        qDebug("%s start to repeat descending order scan data blocks", GET_TASKID(pTaskInfo));

×

1076

        code = pAPI->tsdReader.tsdReaderResetStatus(pTableScanInfo->base.dataReader, &pTableScanInfo->base.cond);

×

1077

        QUERY_CHECK_CODE(code, lino, _end);

×

1082

  if (pTableScanInfo->countState < TABLE_COUNT_STATE_END) {

×

1083

    STableListInfo* pTableListInfo = pTableScanInfo->base.pTableListInfo;

×

1084

    if (pTableListInfo->groupOffset) {  // group by tbname, group by tag + sort

×

1085

      if (pTableScanInfo->countState < TABLE_COUNT_STATE_PROCESSED) {

×

1086

        pTableScanInfo->countState = TABLE_COUNT_STATE_PROCESSED;

×

1088

            (STableKeyInfo*)tableListGetInfo(pTableScanInfo->base.pTableListInfo, pTableScanInfo->tableStartIndex);

×

1090

        if (NULL == pStart) {

×

1091

          return code;

×

1094

        *pBlock = getBlockForEmptyTable(pOperator, pStart);

×

1095

        return code;

×

1098

      int32_t numOfTables = 0;

×

1099

      code = tableListGetSize(pTableListInfo, &numOfTables);

×

1100

      QUERY_CHECK_CODE(code, lino, _end);

×

1102

      if (pTableScanInfo->tableEndIndex + 1 >= numOfTables) {

×

1104

        void* pIte = taosHashIterate(pTableListInfo->remainGroups, NULL);

×

1105

        if (pIte != NULL) {

×

1106

          size_t        keySize = 0;

×

1107

          uint64_t*     pGroupId = taosHashGetKey(pIte, &keySize);

×

1108

          STableKeyInfo info = {.uid = *(uint64_t*)pIte, .groupId = *pGroupId};

×

1109

          taosHashCancelIterate(pTableListInfo->remainGroups, pIte);

×

1110

          markGroupProcessed(pTableScanInfo, *pGroupId);

×

1111

          *pBlock = getBlockForEmptyTable(pOperator, &info);

×

1113

          return code;

×

1117

    pTableScanInfo->countState = TABLE_COUNT_STATE_END;

×

1120

_end:

×

1121

  if (code != TSDB_CODE_SUCCESS) {

×

1122

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

1123

    pTaskInfo->code = code;

×

1126

  return code;

×

1129

static int32_t createTableListInfoFromParam(SOperatorInfo* pOperator) {

×

1130

  STableScanInfo*          pInfo = pOperator->info;

×

1131

  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;

×

1132

  int32_t                  code = 0;

×

1133

  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;

×

1134

  STableScanOperatorParam* pParam = (STableScanOperatorParam*)pOperator->pOperatorGetParam->value;

×

1135

  int32_t                  num = taosArrayGetSize(pParam->pUidList);

×

1136

  if (num <= 0) {

×

1137

    qError("empty table scan uid list");

×

1138

    return TSDB_CODE_INVALID_PARA;

×

1141

  qDebug("vgId:%d add total %d dynamic tables to scan, tableSeq:%d, exist num:%" PRId64 ", operator status:%d",

×

1145

  if (pParam->tableSeq) {

×

1146

    pListInfo->oneTableForEachGroup = true;

×

1147

    if (taosArrayGetSize(pListInfo->pTableList) > 0) {

×

1148

      taosHashClear(pListInfo->map);

×

1149

      taosArrayClear(pListInfo->pTableList);

×

1150

      pOperator->status = OP_EXEC_DONE;

×

1153

    pListInfo->oneTableForEachGroup = false;

×

1154

    pListInfo->numOfOuputGroups = 1;

×

1157

  STableKeyInfo info = {.groupId = 0};

×

1158

  int32_t       tableIdx = 0;

×

1159

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

×

1160

    uint64_t* pUid = taosArrayGet(pParam->pUidList, i);

×

1161

    if (!pUid) {

×

1162

      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));

×

1163

      return terrno;

×

1166

    if (taosHashPut(pListInfo->map, pUid, sizeof(uint64_t), &tableIdx, sizeof(int32_t))) {

×

1167

      if (TSDB_CODE_DUP_KEY == terrno) {

×

1168

        continue;

×

1170

      return terrno;

×

1173

    info.uid = *pUid;

×

1174

    void* p = taosArrayPush(pListInfo->pTableList, &info);

×

1175

    if (p == NULL) {

×

1176

      return terrno;

×

1179

    tableIdx++;

×

1180

    qDebug("add dynamic table scan uid:%" PRIu64 ", %s", info.uid, GET_TASKID(pTaskInfo));

×

1183

  return code;

×

1186

static int32_t startNextGroupScan(SOperatorInfo* pOperator, SSDataBlock** pResult) {

×

1187

  int32_t         code = TSDB_CODE_SUCCESS;

×

1188

  int32_t         lino = 0;

×

1189

  STableScanInfo* pInfo = pOperator->info;

×

1190

  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;

×

1191

  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;

×

1192

  int32_t         numOfTables = 0;

×

1194

  QRY_PARAM_CHECK(pResult);

×

1196

  code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);

×

1197

  QUERY_CHECK_CODE(code, lino, _end);

×

1199

  if ((++pInfo->currentGroupId) >= tableListGetOutputGroups(pInfo->base.pTableListInfo)) {

×

1200

    setOperatorCompleted(pOperator);

×

1201

    if (pOperator->dynamicTask) {

×

1202

      taosArrayClear(pInfo->base.pTableListInfo->pTableList);

×

1203

      taosHashClear(pInfo->base.pTableListInfo->map);

×

1205

    return code;

×

1209

  pOperator->status = OP_OPENED;

×

1210

  resetLimitInfoForNextGroup(&pInfo->base.limitInfo);

×

1212

  int32_t        num = 0;

×

1213

  STableKeyInfo* pList = NULL;

×

1214

  code = initNextGroupScan(pInfo, &pList, &num);

×

1215

  QUERY_CHECK_CODE(code, lino, _end);

×

1217

  code = pAPI->tsdReader.tsdSetQueryTableList(pInfo->base.dataReader, pList, num);

×

1218

  QUERY_CHECK_CODE(code, lino, _end);

×

1220

  code = pAPI->tsdReader.tsdReaderResetStatus(pInfo->base.dataReader, &pInfo->base.cond);

×

1221

  QUERY_CHECK_CODE(code, lino, _end);

×

1222

  pInfo->scanTimes = 0;

×

1224

  code = doGroupedTableScan(pOperator, pResult);

×

1225

  QUERY_CHECK_CODE(code, lino, _end);

×

1227

  if (*pResult != NULL) {

×

1228

    if (pOperator->dynamicTask) {

×

1229

      (*pResult)->info.id.groupId = (*pResult)->info.id.uid;

×

1231

    return code;

×

1234

_end:

×

1235

  if (code != TSDB_CODE_SUCCESS) {

×

1236

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

1237

    pTaskInfo->code = code;

×

1239

  return code;

×

1242

static int32_t doInitReader(STableScanInfo* pInfo, SExecTaskInfo* pTaskInfo, SStorageAPI* pAPI, int32_t* pNum,

×

1244

  const char* idStr = GET_TASKID(pTaskInfo);

×

1245

  int32_t     code = initNextGroupScan(pInfo, pList, pNum);

×

1246

  if (code) {

×

1247

    qError("%s failed to init groupScan Info, code:%s at line:%d", idStr, tstrerror(code), __LINE__);

×

1248

    return code;

×

1251

  if (pInfo->base.dataReader != NULL) {

×

1252

    qError("%s tsdb reader should be null", idStr);

×

1253

    return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;

×

1256

  code = pAPI->tsdReader.tsdReaderOpen(pInfo->base.readHandle.vnode, &pInfo->base.cond, *pList, *pNum, pInfo->pResBlock,

×

1257

                                       (void**)&pInfo->base.dataReader, idStr, &pInfo->pIgnoreTables);

×

1258

  if (code) {

×

1259

    qError("%s failed to open tsdbReader, code:%s at line:%d", idStr, tstrerror(code), __LINE__);

×

1262

  return code;

×

1265

static int32_t groupSeqTableScan(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {

×

1266

  int32_t         code = TSDB_CODE_SUCCESS;

×

1267

  int32_t         lino = 0;

×

1268

  STableScanInfo* pInfo = pOperator->info;

×

1269

  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;

×

1270

  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;

×

1271

  int32_t         num = 0;

×

1272

  STableKeyInfo*  pList = NULL;

×

1273

  SSDataBlock*    pResult = NULL;

×

1274

  const char*     idStr = GET_TASKID(pTaskInfo);

×

1276

  QRY_PARAM_CHECK(pResBlock);

×

1278

  if (pInfo->currentGroupId == -1) {

×

1279

    if ((++pInfo->currentGroupId) >= tableListGetOutputGroups(pInfo->base.pTableListInfo)) {

×

1280

      setOperatorCompleted(pOperator);

×

1281

      return code;

×

1284

    taosRLockLatch(&pTaskInfo->lock);

×

1285

    code = doInitReader(pInfo, pTaskInfo, pAPI, &num, &pList);

×

1286

    taosRUnLockLatch(&pTaskInfo->lock);

×

1287

    QUERY_CHECK_CODE(code, lino, _end);

×

1289

    if (pInfo->filesetDelimited) {

×

1290

      pAPI->tsdReader.tsdSetFilesetDelimited(pInfo->base.dataReader);

×

1293

    if (pInfo->pResBlock->info.capacity > pOperator->resultInfo.capacity) {

×

1294

      pOperator->resultInfo.capacity = pInfo->pResBlock->info.capacity;

×

1298

  code = doGroupedTableScan(pOperator, &pResult);

×

1299

  QUERY_CHECK_CODE(code, lino, _end);

×

1301

  if (pResult != NULL) {

×

1302

    if (pOperator->dynamicTask) {

×

1303

      pResult->info.id.groupId = pResult->info.id.uid;

×

1306

    *pResBlock = pResult;

×

1307

    return code;

×

1311

    code = startNextGroupScan(pOperator, &pResult);

×

1312

    QUERY_CHECK_CODE(code, lino, _end);

×

1314

    if (pResult || pOperator->status == OP_EXEC_DONE) {

×

1315

      *pResBlock = pResult;

×

1316

      return code;

×

1320

_end:

×

1321

  if (code != TSDB_CODE_SUCCESS) {

×

1322

    qError("%s %s failed at line %d since %s", idStr, __func__, lino, tstrerror(code));

×

1323

    pTaskInfo->code = code;

×

1326

  return code;

×

1329

static int32_t doTableScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

×

1330

  int32_t         code = TSDB_CODE_SUCCESS;

×

1331

  int32_t         lino = 0;

×

1332

  STableScanInfo* pInfo = pOperator->info;

×

1333

  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;

×

1334

  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;

×

1335

  QRY_PARAM_CHECK(ppRes);

×

1337

  if (pOperator->pOperatorGetParam) {

×

1338

    pOperator->dynamicTask = true;

×

1339

    code = createTableListInfoFromParam(pOperator);

×

1340

    freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);

×

1341

    pOperator->pOperatorGetParam = NULL;

×

1342

    QUERY_CHECK_CODE(code, lino, _end);

×

1344

    if (pOperator->status == OP_EXEC_DONE) {

×

1345

      pInfo->currentGroupId = -1;

×

1346

      pOperator->status = OP_OPENED;

×

1347

      SSDataBlock* result = NULL;

×

1350

        code = startNextGroupScan(pOperator, &result);

×

1351

        QUERY_CHECK_CODE(code, lino, _end);

×

1353

        if (result || pOperator->status == OP_EXEC_DONE) {

×

1354

          (*ppRes) = result;

×

1355

          return code;

×

1362

  if (pInfo->scanMode == TABLE_SCAN__TABLE_ORDER) {

×

1363

    int32_t       numOfTables = 0;

×

1364

    STableKeyInfo tInfo = {0};

×

1365

    pInfo->countState = TABLE_COUNT_STATE_END;

×

1367

    while (1) {

×

1368

      SSDataBlock* result = NULL;

×

1369

      code = doGroupedTableScan(pOperator, &result);

×

1370

      QUERY_CHECK_CODE(code, lino, _end);

×

1372

      if (result || (pOperator->status == OP_EXEC_DONE) || isTaskKilled(pTaskInfo)) {

×

1373

        (*ppRes) = result;

×

1374

        return code;

×

1378

      pInfo->currentTable++;

×

1380

      taosRLockLatch(&pTaskInfo->lock);

×

1381

      numOfTables = 0;

×

1382

      code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);

×

1383

      if (code != TSDB_CODE_SUCCESS) {

×

1384

        taosRUnLockLatch(&pTaskInfo->lock);

×

1385

        TSDB_CHECK_CODE(code, lino, _end);

×

1388

      if (pInfo->currentTable >= numOfTables) {

×

1389

        qDebug("all table checked in table list, total:%d, return NULL, %s", numOfTables, GET_TASKID(pTaskInfo));

×

1390

        taosRUnLockLatch(&pTaskInfo->lock);

×

1391

        (*ppRes) = NULL;

×

1392

        return code;

×

1395

      STableKeyInfo* tmp = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->currentTable);

×

1396

      if (!tmp) {

×

1397

        taosRUnLockLatch(&pTaskInfo->lock);

×

1398

        (*ppRes) = NULL;

×

1399

        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

×

1402

      tInfo = *tmp;

×

1403

      taosRUnLockLatch(&pTaskInfo->lock);

×

1405

      code = pAPI->tsdReader.tsdSetQueryTableList(pInfo->base.dataReader, &tInfo, 1);

×

1406

      QUERY_CHECK_CODE(code, lino, _end);

×

1407

      qDebug("set uid:%" PRIu64 " into scanner, total tables:%d, index:%d/%d %s", tInfo.uid, numOfTables,

×

1410

      code = pAPI->tsdReader.tsdReaderResetStatus(pInfo->base.dataReader, &pInfo->base.cond);

×

1411

      QUERY_CHECK_CODE(code, lino, _end);

×

1412

      pInfo->scanTimes = 0;

×

1415

    code = groupSeqTableScan(pOperator, ppRes);

×

1416

    QUERY_CHECK_CODE(code, lino, _end);

×

1419

_end:

×

1420

  if (code != TSDB_CODE_SUCCESS) {

×

1421

    qError("%s %s failed at line %d since %s", GET_TASKID(pTaskInfo), __func__, lino, tstrerror(code));

×

1422

    pTaskInfo->code = code;

×

1423

    T_LONG_JMP(pTaskInfo->env, code);

×

1426

  return code;

×

1429

static int32_t getTableScannerExecInfo(struct SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len) {

×

1430

  SFileBlockLoadRecorder* pRecorder = taosMemoryCalloc(1, sizeof(SFileBlockLoadRecorder));

×

1431

  if (!pRecorder) {

×

1432

    return terrno;

×

1434

  STableScanInfo* pTableScanInfo = pOptr->info;

×

1435

  *pRecorder = pTableScanInfo->base.readRecorder;

×

1436

  *pOptrExplain = pRecorder;

×

1437

  *len = sizeof(SFileBlockLoadRecorder);

×

1438

  return 0;

×

1441

static void destroyTableScanBase(STableScanBase* pBase, TsdReader* pAPI) {

×

1442

  cleanupQueryTableDataCond(&pBase->cond);

×

1444

  if (pAPI->tsdReaderClose) {

×

1445

    pAPI->tsdReaderClose(pBase->dataReader);

×

1447

  pBase->dataReader = NULL;

×

1449

  if (pBase->matchInfo.pList != NULL) {

×

1450

    taosArrayDestroy(pBase->matchInfo.pList);

×

1453

  tableListDestroy(pBase->pTableListInfo);

×

1454

  taosLRUCacheCleanup(pBase->metaCache.pTableMetaEntryCache);

×

1455

  cleanupExprSupp(&pBase->pseudoSup);

×

1456

×

1458

static void destroyTableScanOperatorInfo(void* param) {

×

1459

  STableScanInfo* pTableScanInfo = (STableScanInfo*)param;

×

1460

  blockDataDestroy(pTableScanInfo->pResBlock);

×

1461

  taosHashCleanup(pTableScanInfo->pIgnoreTables);

×

1462

  destroyTableScanBase(&pTableScanInfo->base, &pTableScanInfo->base.readerAPI);

×

1463

  taosMemoryFreeClear(param);

×

1464

×

1466

static void resetClolumnReserve(SSDataBlock* pBlock, int32_t dataRequireFlag) {

×

1467

  if (pBlock && dataRequireFlag == FUNC_DATA_REQUIRED_NOT_LOAD) {

×

1468

    int32_t numOfCols = taosArrayGetSize(pBlock->pDataBlock);

×

1469

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

×

1470

      SColumnInfoData* pCol = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, i);

×

1471

      if (pCol) {

×

1472

        pCol->info.noData = true;

×

1476

×

1478

int32_t createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle,

×

1481

  QRY_PARAM_CHECK(pOptrInfo);

×

1483

  int32_t         code = TSDB_CODE_SUCCESS;

×

1484

  int32_t         lino = 0;

×

1485

  STableScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableScanInfo));

×

1486

  SOperatorInfo*  pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));

×

1487

  if (pInfo == NULL || pOperator == NULL) {

×

1488

    code = terrno;

×

1489

    goto _error;

×

1492

  SScanPhysiNode*     pScanNode = &pTableScanNode->scan;

×

1493

  SDataBlockDescNode* pDescNode = pScanNode->node.pOutputDataBlockDesc;

×

1495

  int32_t numOfCols = 0;

×

1497

      extractColMatchInfo(pScanNode->pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID, &pInfo->base.matchInfo);

×

1498

  QUERY_CHECK_CODE(code, lino, _error);

×

1500

  initLimitInfo(pScanNode->node.pLimit, pScanNode->node.pSlimit, &pInfo->base.limitInfo);

×

1501

  code = initQueryTableDataCond(&pInfo->base.cond, pTableScanNode, readHandle);

×

1502

  QUERY_CHECK_CODE(code, lino, _error);

×

1504

  if (pScanNode->pScanPseudoCols != NULL) {

×

1505

    SExprSupp* pSup = &pInfo->base.pseudoSup;

×

1506

    pSup->pExprInfo = NULL;

×

1507

    code = createExprInfo(pScanNode->pScanPseudoCols, NULL, &pSup->pExprInfo, &pSup->numOfExprs);

×

1508

    QUERY_CHECK_CODE(code, lino, _error);

×

1510

    pSup->pCtx = createSqlFunctionCtx(pSup->pExprInfo, pSup->numOfExprs, &pSup->rowEntryInfoOffset,

×

1512

    QUERY_CHECK_NULL(pSup->pCtx, code, lino, _error, terrno);

×

1515

  pInfo->scanInfo = (SScanInfo){.numOfAsc = pTableScanNode->scanSeq[0], .numOfDesc = pTableScanNode->scanSeq[1]};

×

1516

  pInfo->base.scanFlag = (pInfo->scanInfo.numOfAsc > 1) ? PRE_SCAN : MAIN_SCAN;

×

1518

  pInfo->base.pdInfo.interval = extractIntervalInfo(pTableScanNode);

×

1519

  pInfo->base.readHandle = *readHandle;

×

1520

  pInfo->base.dataBlockLoadFlag = pTableScanNode->dataRequired;

×

1522

  pInfo->sample.sampleRatio = pTableScanNode->ratio;

×

1523

  pInfo->sample.seed = taosGetTimestampSec();

×

1525

  pInfo->base.readerAPI = pTaskInfo->storageAPI.tsdReader;

×

1526

  initResultSizeInfo(&pOperator->resultInfo, 4096);

×

1527

  pInfo->pResBlock = createDataBlockFromDescNode(pDescNode);

×

1528

  resetClolumnReserve(pInfo->pResBlock, pInfo->base.dataBlockLoadFlag);

×

1529

  QUERY_CHECK_NULL(pInfo->pResBlock, code, lino, _error, terrno);

×

1531

  code = prepareDataBlockBuf(pInfo->pResBlock, &pInfo->base.matchInfo);

×

1532

  QUERY_CHECK_CODE(code, lino, _error);

×

1534

  code = filterInitFromNode((SNode*)pTableScanNode->scan.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);

×

1535

  QUERY_CHECK_CODE(code, lino, _error);

×

1537

  pInfo->currentGroupId = -1;

×

1539

  pInfo->tableEndIndex = -1;

×

1540

  pInfo->assignBlockUid = pTableScanNode->assignBlockUid;

×

1541

  pInfo->hasGroupByTag = pTableScanNode->pGroupTags ? true : false;

×

1543

  setOperatorInfo(pOperator, "TableScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN, false, OP_NOT_OPENED, pInfo,

×

1545

  pOperator->exprSupp.numOfExprs = numOfCols;

×

1547

  pInfo->needCountEmptyTable = tsCountAlwaysReturnValue && pTableScanNode->needCountEmptyTable;

×

1549

  pInfo->base.pTableListInfo = pTableListInfo;

×

1550

  pInfo->base.metaCache.pTableMetaEntryCache = taosLRUCacheInit(1024 * 128, -1, .5);

×

1551

  if (pInfo->base.metaCache.pTableMetaEntryCache == NULL) {

×

1552

    code = terrno;

×

1553

    QUERY_CHECK_CODE(code, lino, _error);

×

1556

  pInfo->filesetDelimited = pTableScanNode->filesetDelimited;

×

1558

  taosLRUCacheSetStrictCapacity(pInfo->base.metaCache.pTableMetaEntryCache, false);

×

1559

  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableScanNext, NULL, destroyTableScanOperatorInfo,

×

1563

  pOperator->cost.openCost = 0;

×

1564

  *pOptrInfo = pOperator;

×

1565

  return TSDB_CODE_SUCCESS;

×

1567

_error:

×

1568

  if (pInfo != NULL) {

×

1569

    pInfo->base.pTableListInfo = NULL;  // this attribute will be destroy outside of this function

×

1570

    destroyTableScanOperatorInfo(pInfo);

×

1573

  if (pOperator != NULL) {

×

1574

    pOperator->info = NULL;

×

1575

    destroyOperator(pOperator);

×

1577

  pTaskInfo->code = code;

×

1578

  return code;

×

1581

int32_t createTableSeqScanOperatorInfo(void* pReadHandle, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {

×

1582

  QRY_PARAM_CHECK(pOptrInfo);

×

1584

  int32_t         code = 0;

×

1585

  STableScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableScanInfo));

×

1586

  SOperatorInfo*  pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));

×

1587

  if (pInfo == NULL || pOperator == NULL) {

×

1588

    code = terrno;

×

1589

    goto _end;

×

1592

  pInfo->base.dataReader = pReadHandle;

×

1595

  setOperatorInfo(pOperator, "TableSeqScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN, false, OP_NOT_OPENED,

×

1597

  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableScanImplNext, NULL, NULL, optrDefaultBufFn, NULL,

×

1599

  *pOptrInfo = pOperator;

×

1600

  return code;

×

1602

_end:

×

1603

  if (pInfo != NULL) {

×

1604

    taosMemoryFree(pInfo);

×

1607

  if (pOperator != NULL) {

×

1608

    taosMemoryFree(pOperator);

×

1611

  pTaskInfo->code = code;

×

1612

  return code;

×

1615

FORCE_INLINE void doClearBufferedBlocks(SStreamScanInfo* pInfo) {

×

1616

  qDebug("clear buff blocks:%d", (int32_t)taosArrayGetSize(pInfo->pBlockLists));

×

1617

  taosArrayClear(pInfo->pBlockLists);

×

1618

  pInfo->validBlockIndex = 0;

×

1619

×

1621

static bool isSessionWindow(SStreamScanInfo* pInfo) {

×

1622

  return pInfo->windowSup.parentType == QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION;

×

1625

static bool isStateWindow(SStreamScanInfo* pInfo) {

×

1626

  return pInfo->windowSup.parentType == QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE ||

×

1627

         pInfo->windowSup.parentType == QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT;

×

1630

static bool isIntervalWindow(SStreamScanInfo* pInfo) {

×

1631

  return pInfo->windowSup.parentType == QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL ||

×

1632

         pInfo->windowSup.parentType == QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL ||

×

1633

         pInfo->windowSup.parentType == QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL ||

×

1634

         pInfo->windowSup.parentType == QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL;

×

1637

static bool isSignleIntervalWindow(SStreamScanInfo* pInfo) {

×

1638

  return pInfo->windowSup.parentType == QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL;

×

1641

static bool isSlidingWindow(SStreamScanInfo* pInfo) {

×

1642

  return isIntervalWindow(pInfo) && pInfo->interval.interval != pInfo->interval.sliding;

×

1645

static bool isCountSlidingWindow(SStreamScanInfo* pInfo) {

×

1646

  return pInfo->windowSup.pStreamAggSup &&

×

1647

         (pInfo->windowSup.pStreamAggSup->windowCount != pInfo->windowSup.pStreamAggSup->windowSliding);

×

1650

static bool isCountWindow(SStreamScanInfo* pInfo) {

×

1651

  return pInfo->windowSup.parentType == QUERY_NODE_PHYSICAL_PLAN_STREAM_COUNT;

×

1654

static bool isTimeSlice(SStreamScanInfo* pInfo) {

×

1655

  return pInfo->windowSup.parentType == QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERP_FUNC;

×

1658

static void setGroupId(SStreamScanInfo* pInfo, SSDataBlock* pBlock, int32_t groupColIndex, int32_t rowIndex) {

×

1659

  SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, groupColIndex);

×

1660

  uint64_t*        groupCol = (uint64_t*)pColInfo->pData;

×

1661

  if (colDataIsNull_s(pColInfo, rowIndex)) {

×

1662

    pInfo->igCheckGroupId = true;

×

1664

    pInfo->groupId = groupCol[rowIndex];

×

1666

×

1668

void resetTableScanInfo(STableScanInfo* pTableScanInfo, STimeWindow* pWin, uint64_t ver) {

×

1669

  pTableScanInfo->base.cond.twindows = *pWin;

×

1670

  pTableScanInfo->base.cond.startVersion = 0;

×

1671

  pTableScanInfo->base.cond.endVersion = ver;

×

1672

  pTableScanInfo->scanTimes = 0;

×

1673

  pTableScanInfo->currentGroupId = -1;

×

1674

  pTableScanInfo->tableEndIndex = -1;

×

1675

  pTableScanInfo->base.readerAPI.tsdReaderClose(pTableScanInfo->base.dataReader);

×

1676

  pTableScanInfo->base.dataReader = NULL;

×

1677

  pTableScanInfo->scanMode = TABLE_SCAN__BLOCK_ORDER;

×

1678

×

1680

static SSDataBlock* readPreVersionData(SOperatorInfo* pTableScanOp, uint64_t tbUid, TSKEY startTs, TSKEY endTs,

×

1682

  int32_t       code = TSDB_CODE_SUCCESS;

×

1683

  int32_t       lino = 0;

×

1684

  STableKeyInfo tblInfo = {.uid = tbUid, .groupId = 0};

×

1686

  STableScanInfo*     pTableScanInfo = pTableScanOp->info;

×

1687

  SQueryTableDataCond cond = pTableScanInfo->base.cond;

×

1689

  cond.startVersion = -1;

×

1690

  cond.endVersion = maxVersion;

×

1691

  cond.twindows = (STimeWindow){.skey = startTs, .ekey = endTs};

×

1693

  SExecTaskInfo* pTaskInfo = pTableScanOp->pTaskInfo;

×

1694

  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;

×

1696

  SSDataBlock* pBlock = pTableScanInfo->pResBlock;

×

1697

  STsdbReader* pReader = NULL;

×

1698

  code = pAPI->tsdReader.tsdReaderOpen(pTableScanInfo->base.readHandle.vnode, &cond, &tblInfo, 1, pBlock,

×

1699

                                       (void**)&pReader, GET_TASKID(pTaskInfo), NULL);

×

1700

  QUERY_CHECK_CODE(code, lino, _end);

×

1702

  bool hasNext = false;

×

1703

  code = pAPI->tsdReader.tsdNextDataBlock(pReader, &hasNext);

×

1704

  QUERY_CHECK_CODE(code, lino, _end);

×

1706

  if (hasNext) {

×

1707

    SSDataBlock* p = NULL;

×

1708

    code = pAPI->tsdReader.tsdReaderRetrieveDataBlock(pReader, &p, NULL);

×

1709

    QUERY_CHECK_CODE(code, lino, _end);

×

1711

    code = doSetTagColumnData(&pTableScanInfo->base, pBlock, pTaskInfo, pBlock->info.rows);

×

1712

    QUERY_CHECK_CODE(code, lino, _end);

×

1714

    pBlock->info.id.groupId = tableListGetTableGroupId(pTableScanInfo->base.pTableListInfo, pBlock->info.id.uid);

×

1717

_end:

×

1718

  pAPI->tsdReader.tsdReaderClose(pReader);

×

1719

  qDebug("retrieve prev rows:%" PRId64 ", skey:%" PRId64 ", ekey:%" PRId64 " uid:%" PRIu64 ", max ver:%" PRId64

×

1722

  if (code != TSDB_CODE_SUCCESS) {

×

1723

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

1724

    terrno = code;

×

1725

    return NULL;

×

1728

  return pBlock->info.rows > 0 ? pBlock : NULL;

×

1731

bool comparePrimaryKey(SColumnInfoData* pCol, int32_t rowId, void* pVal) {

×

1733

  if (!pVal || !pCol) {

×

1734

    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_INVALID_PARA));

×

1735

    return false;

×

1737

  void* pData = colDataGetData(pCol, rowId);

×

1738

  if (IS_VAR_DATA_TYPE(pCol->info.type)) {

×

1739

    int32_t colLen = varDataLen(pData);

×

1740

    int32_t keyLen = varDataLen(pVal);

×

1741

    if (pCol->info.type == TSDB_DATA_TYPE_JSON) {

×

1742

      colLen = getJsonValueLen(pData);

×

1743

      keyLen = getJsonValueLen(pVal);

×

1746

    if (colLen == keyLen && memcmp(pData, pVal, colLen) == 0) {

×

1747

      return true;

×

1750

    if (memcmp(pData, pVal, pCol->info.bytes) == 0) {

×

1751

      return true;

×

1754

  return false;

×

1757

bool hasPrimaryKeyCol(SStreamScanInfo* pInfo) { return pInfo->primaryKeyIndex != -1; }

×

1759

static uint64_t getGroupIdByCol(SStreamScanInfo* pInfo, uint64_t uid, TSKEY ts, int64_t maxVersion, void* pVal) {

×

1760

  SSDataBlock* pPreRes = readPreVersionData(pInfo->pTableScanOp, uid, ts, ts, maxVersion);

×

1761

  if (!pPreRes || pPreRes->info.rows == 0) {

×

1762

    if (terrno != TSDB_CODE_SUCCESS) {

×

1763

      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));

×

1765

    return 0;

×

1768

  int32_t rowId = 0;

×

1769

  if (hasPrimaryKeyCol(pInfo)) {

×

1770

    SColumnInfoData* pPkCol = taosArrayGet(pPreRes->pDataBlock, pInfo->primaryKeyIndex);

×

1771

    for (; rowId < pPreRes->info.rows; rowId++) {

×

1772

      if (comparePrimaryKey(pPkCol, rowId, pVal)) {

×

1773

        break;

×

1777

  if (rowId >= pPreRes->info.rows) {

×

1778

    qInfo("===stream===read preversion data of primary key failed. ts:%" PRId64 ",version:%" PRId64, ts, maxVersion);

×

1779

    return 0;

×

1781

  return calGroupIdByData(&pInfo->partitionSup, pInfo->pPartScalarSup, pPreRes, rowId);

×

1784

static uint64_t getGroupIdByUid(SStreamScanInfo* pInfo, uint64_t uid) {

×

1785

  STableScanInfo* pTableScanInfo = pInfo->pTableScanOp->info;

×

1786

  return tableListGetTableGroupId(pTableScanInfo->base.pTableListInfo, uid);

×

1789

static uint64_t getGroupIdByData(SStreamScanInfo* pInfo, uint64_t uid, TSKEY ts, int64_t maxVersion, void* pVal) {

×

1790

  if (pInfo->partitionSup.needCalc) {

×

1791

    return getGroupIdByCol(pInfo, uid, ts, maxVersion, pVal);

×

1794

  return getGroupIdByUid(pInfo, uid);

×

1797

static void prepareRangeScan(SStreamScanInfo* pInfo, SSDataBlock* pBlock, int32_t* pRowIndex, bool* pRes) {

×

1798

  int32_t code = TSDB_CODE_SUCCESS;

×

1799

  int32_t lino = 0;

×

1800

  if (pBlock->info.rows == 0) {

×

1801

    if (pRes) {

×

1802

      (*pRes) = false;

×

1804

    goto _end;

×

1806

  if ((*pRowIndex) == pBlock->info.rows) {

×

1807

    if (pRes) {

×

1808

      (*pRes) = false;

×

1810

    goto _end;

×

1813

  SColumnInfoData* pStartTsCol = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX);

×

1814

  TSKEY*           startData = (TSKEY*)pStartTsCol->pData;

×

1815

  SColumnInfoData* pEndTsCol = taosArrayGet(pBlock->pDataBlock, END_TS_COLUMN_INDEX);

×

1816

  TSKEY*           endData = (TSKEY*)pEndTsCol->pData;

×

1817

  STimeWindow      win = {.skey = startData[*pRowIndex], .ekey = endData[*pRowIndex]};

×

1818

  SColumnInfoData* pGpCol = taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX);

×

1819

  uint64_t*        gpData = (uint64_t*)pGpCol->pData;

×

1820

  uint64_t         groupId = gpData[*pRowIndex];

×

1822

  SColumnInfoData* pCalStartTsCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_START_TS_COLUMN_INDEX);

×

1823

  TSKEY*           calStartData = (TSKEY*)pCalStartTsCol->pData;

×

1824

  SColumnInfoData* pCalEndTsCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_END_TS_COLUMN_INDEX);

×

1825

  TSKEY*           calEndData = (TSKEY*)pCalEndTsCol->pData;

×

1827

  setGroupId(pInfo, pBlock, GROUPID_COLUMN_INDEX, *pRowIndex);

×

1828

  if (isSlidingWindow(pInfo) || isCountSlidingWindow(pInfo)) {

×

1829

    pInfo->updateWin.skey = calStartData[*pRowIndex];

×

1830

    pInfo->updateWin.ekey = calEndData[*pRowIndex];

×

1832

  (*pRowIndex)++;

×

1834

  for (; *pRowIndex < pBlock->info.rows; (*pRowIndex)++) {

×

1835

    if (win.skey == startData[*pRowIndex] && groupId == gpData[*pRowIndex]) {

×

1836

      win.ekey = TMAX(win.ekey, endData[*pRowIndex]);

×

1837

      continue;

×

1840

    if (win.skey == endData[*pRowIndex] && groupId == gpData[*pRowIndex]) {

×

1841

      win.skey = TMIN(win.skey, startData[*pRowIndex]);

×

1842

      continue;

×

1844

    break;

×

1847

  STableScanInfo* pTScanInfo = pInfo->pTableScanOp->info;

×

1849

  QUERY_CHECK_NULL(pInfo->pUpdateInfo, code, lino, _end, TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);

×

1851

  qDebug("prepare range scan start:%" PRId64 ",end:%" PRId64 ",maxVer:%" PRIu64, win.skey, win.ekey,

×

1853

  resetTableScanInfo(pInfo->pTableScanOp->info, &win, pInfo->pUpdateInfo->maxDataVersion);

×

1854

  pInfo->pTableScanOp->status = OP_OPENED;

×

1855

  if (pRes) {

×

1856

    (*pRes) = true;

×

1859

_end:

×

1860

  if (code != TSDB_CODE_SUCCESS) {

×

1861

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

1863

×

1865

static STimeWindow getSlidingWindow(TSKEY* startTsCol, TSKEY* endTsCol, uint64_t* gpIdCol, SInterval* pInterval,

×

1867

  SResultRowInfo dumyInfo = {0};

×

1868

  dumyInfo.cur.pageId = -1;

×

1869

  STimeWindow win = getActiveTimeWindow(NULL, &dumyInfo, startTsCol[*pRowIndex], pInterval, TSDB_ORDER_ASC);

×

1870

  STimeWindow endWin = win;

×

1871

  STimeWindow preWin = win;

×

1872

  uint64_t    groupId = gpIdCol[*pRowIndex];

×

1875

    if (hasGroup) {

×

1876

      (*pRowIndex) += 1;

×

1878

      while ((groupId == gpIdCol[(*pRowIndex)] && startTsCol[*pRowIndex] <= endWin.ekey)) {

×

1879

        (*pRowIndex) += 1;

×

1880

        if ((*pRowIndex) == pDataBlockInfo->rows) {

×

1881

          break;

×

1887

      preWin = endWin;

×

1888

      getNextTimeWindow(pInterval, &endWin, TSDB_ORDER_ASC);

×

1889

    } while (endTsCol[(*pRowIndex) - 1] >= endWin.skey);

×

1890

    endWin = preWin;

×

1891

    if (win.ekey == endWin.ekey || (*pRowIndex) == pDataBlockInfo->rows || groupId != gpIdCol[*pRowIndex]) {

×

1892

      win.ekey = endWin.ekey;

×

1893

      return win;

×

1895

    win.ekey = endWin.ekey;

×

1899

static int32_t doRangeScan(SStreamScanInfo* pInfo, SSDataBlock* pSDB, int32_t tsColIndex, int32_t* pRowIndex,

×

1901

  qDebug("do stream range scan. windows index:%d", *pRowIndex);

×

1903

  int32_t code = TSDB_CODE_SUCCESS;

×

1904

  int32_t lino = 0;

×

1905

  bool    prepareRes = true;

×

1907

  while (1) {

×

1908

    SSDataBlock* pResult = NULL;

×

1909

    code = doTableScanNext(pInfo->pTableScanOp, &pResult);

×

1910

    QUERY_CHECK_CODE(code, lino, _end);

×

1912

    if (!pResult) {

×

1913

      prepareRangeScan(pInfo, pSDB, pRowIndex, &prepareRes);

×

1915

      code = doTableScanNext(pInfo->pTableScanOp, &pResult);

×

1916

      QUERY_CHECK_CODE(code, lino, _end);

×

1919

    if (!pResult) {

×

1920

      if (prepareRes) {

×

1921

        continue;

×

1923

      blockDataCleanup(pSDB);

×

1924

      *pRowIndex = 0;

×

1925

      pInfo->updateWin = (STimeWindow){.skey = INT64_MIN, .ekey = INT64_MAX};

×

1926

      STableScanInfo* pTableScanInfo = pInfo->pTableScanOp->info;

×

1927

      pTableScanInfo->base.readerAPI.tsdReaderClose(pTableScanInfo->base.dataReader);

×

1928

      pTableScanInfo->base.dataReader = NULL;

×

1929

      (*ppRes) = NULL;

×

1930

      goto _end;

×

1933

    code = doFilter(pResult, pInfo->pTableScanOp->exprSupp.pFilterInfo, NULL);

×

1934

    QUERY_CHECK_CODE(code, lino, _end);

×

1935

    if (pResult->info.rows == 0) {

×

1936

      continue;

×

1939

    if (pInfo->igCheckGroupId == true) {

×

1940

      pResult->info.calWin = pInfo->updateWin;

×

1941

      (*ppRes) = pResult;

×

1942

      goto _end;

×

1945

    if (pInfo->partitionSup.needCalc) {

×

1946

      SSDataBlock* tmpBlock = NULL;

×

1947

      code = createOneDataBlock(pResult, true, &tmpBlock);

×

1948

      QUERY_CHECK_CODE(code, lino, _end);

×

1950

      blockDataCleanup(pResult);

×

1951

      for (int32_t i = 0; i < tmpBlock->info.rows; i++) {

×

1952

        if (calGroupIdByData(&pInfo->partitionSup, pInfo->pPartScalarSup, tmpBlock, i) == pInfo->groupId) {

×

1953

          for (int32_t j = 0; j < pInfo->pTableScanOp->exprSupp.numOfExprs; j++) {

×

1954

            SColumnInfoData* pSrcCol = taosArrayGet(tmpBlock->pDataBlock, j);

×

1955

            SColumnInfoData* pDestCol = taosArrayGet(pResult->pDataBlock, j);

×

1956

            bool             isNull = colDataIsNull(pSrcCol, tmpBlock->info.rows, i, NULL);

×

1957

            char*            pSrcData = NULL;

×

1958

            if (!isNull) pSrcData = colDataGetData(pSrcCol, i);

×

1959

            code = colDataSetVal(pDestCol, pResult->info.rows, pSrcData, isNull);

×

1960

            QUERY_CHECK_CODE(code, lino, _end);

×

1962

          pResult->info.rows++;

×

1966

      blockDataDestroy(tmpBlock);

×

1968

      if (pResult->info.rows > 0) {

×

1969

        pResult->info.calWin = pInfo->updateWin;

×

1970

        (*ppRes) = pResult;

×

1971

        goto _end;

×

1973

    } else if (pResult->info.id.groupId == pInfo->groupId) {

×

1974

      pResult->info.calWin = pInfo->updateWin;

×

1975

      (*ppRes) = pResult;

×

1976

      goto _end;

×

1980

_end:

×

1981

  if (code != TSDB_CODE_SUCCESS) {

×

1982

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

1984

  return code;

×

1987

static void getPreSessionWindow(SStreamAggSupporter* pAggSup, TSKEY startTs, TSKEY endTs, uint64_t groupId,

×

1989

  pKey->win.skey = startTs;

×

1990

  pKey->win.ekey = endTs;

×

1991

  pKey->groupId = groupId;

×

1993

  void*   pCur = pAggSup->stateStore.streamStateSessionSeekKeyCurrentPrev(pAggSup->pState, pKey);

×

1994

  int32_t code = pAggSup->stateStore.streamStateSessionGetKVByCur(pCur, pKey, NULL, 0);

×

1995

  if (code != TSDB_CODE_SUCCESS) {

×

1996

    SET_SESSION_WIN_KEY_INVALID(pKey);

×

1999

  taosMemoryFree(pCur);

×

2000

×

2002

int32_t appendOneRowToSpecialBlockImpl(SSDataBlock* pBlock, TSKEY* pStartTs, TSKEY* pEndTs, TSKEY* pCalStartTs,

×

2004

  int32_t          code = TSDB_CODE_SUCCESS;

×

2005

  int32_t          lino = 0;

×

2006

  SColumnInfoData* pStartTsCol = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX);

×

2007

  SColumnInfoData* pEndTsCol = taosArrayGet(pBlock->pDataBlock, END_TS_COLUMN_INDEX);

×

2008

  SColumnInfoData* pUidCol = taosArrayGet(pBlock->pDataBlock, UID_COLUMN_INDEX);

×

2009

  SColumnInfoData* pGpCol = taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX);

×

2010

  SColumnInfoData* pCalStartCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_START_TS_COLUMN_INDEX);

×

2011

  SColumnInfoData* pCalEndCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_END_TS_COLUMN_INDEX);

×

2012

  SColumnInfoData* pTableCol = taosArrayGet(pBlock->pDataBlock, TABLE_NAME_COLUMN_INDEX);

×

2013

  code = colDataSetVal(pStartTsCol, pBlock->info.rows, (const char*)pStartTs, false);

×

2014

  QUERY_CHECK_CODE(code, lino, _end);

×

2016

  code = colDataSetVal(pEndTsCol, pBlock->info.rows, (const char*)pEndTs, false);

×

2017

  QUERY_CHECK_CODE(code, lino, _end);

×

2019

  code = colDataSetVal(pUidCol, pBlock->info.rows, (const char*)pUid, pUid == NULL);

×

2020

  QUERY_CHECK_CODE(code, lino, _end);

×

2022

  code = colDataSetVal(pGpCol, pBlock->info.rows, (const char*)pGp, pGp == NULL);

×

2023

  QUERY_CHECK_CODE(code, lino, _end);

×

2025

  code = colDataSetVal(pCalStartCol, pBlock->info.rows, (const char*)pCalStartTs, false);

×

2026

  QUERY_CHECK_CODE(code, lino, _end);

×

2028

  code = colDataSetVal(pCalEndCol, pBlock->info.rows, (const char*)pCalEndTs, false);

×

2029

  QUERY_CHECK_CODE(code, lino, _end);

×

2031

  code = colDataSetVal(pTableCol, pBlock->info.rows, (const char*)pTbName, pTbName == NULL);

×

2032

  QUERY_CHECK_CODE(code, lino, _end);

×

2034

  if (taosArrayGetSize(pBlock->pDataBlock) > PRIMARY_KEY_COLUMN_INDEX) {

×

2035

    SColumnInfoData* pPkCol = taosArrayGet(pBlock->pDataBlock, PRIMARY_KEY_COLUMN_INDEX);

×

2036

    code = colDataSetVal(pPkCol, pBlock->info.rows, (const char*)pPkData, pPkData == NULL);

×

2037

    QUERY_CHECK_CODE(code, lino, _end);

×

2039

  pBlock->info.rows++;

×

2041

_end:

×

2042

  if (code != TSDB_CODE_SUCCESS) {

×

2043

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

2045

  return code;

×

2048

int32_t appendPkToSpecialBlock(SSDataBlock* pBlock, TSKEY* pTsArray, SColumnInfoData* pPkCol, int32_t rowId,

×

2050

  void* pVal = NULL;

×

2051

  if (pPkCol) {

×

2052

    pVal = colDataGetData(pPkCol, rowId);

×

2054

  return appendOneRowToSpecialBlockImpl(pBlock, pTsArray + rowId, pTsArray + rowId, pTsArray + rowId, pTsArray + rowId,

×

2058

static int32_t getPreVersionDataBlock(uint64_t uid, TSKEY startTs, TSKEY endTs, int64_t version, char* taskIdStr,

×

2060

  int32_t      code = TSDB_CODE_SUCCESS;

×

2061

  int32_t      lino = 0;

×

2062

  SSDataBlock* pPreRes = readPreVersionData(pInfo->pTableScanOp, uid, startTs, endTs, version);

×

2063

  printDataBlock(pPreRes, "pre res", taskIdStr);

×

2064

  blockDataCleanup(pBlock);

×

2065

  if (!pPreRes) {

×

2066

    if (terrno != TSDB_CODE_SUCCESS) {

×

2067

      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));

×

2069

    goto _end;

×

2071

  code = blockDataEnsureCapacity(pBlock, pPreRes->info.rows);

×

2072

  QUERY_CHECK_CODE(code, lino, _end);

×

2074

  SColumnInfoData* pTsCol = (SColumnInfoData*)taosArrayGet(pPreRes->pDataBlock, pInfo->primaryTsIndex);

×

2075

  SColumnInfoData* pPkCol = NULL;

×

2076

  if (hasPrimaryKeyCol(pInfo)) {

×

2077

    pPkCol = (SColumnInfoData*)taosArrayGet(pPreRes->pDataBlock, pInfo->primaryKeyIndex);

×

2079

  for (int32_t i = 0; i < pPreRes->info.rows; i++) {

×

2080

    uint64_t groupId = calGroupIdByData(&pInfo->partitionSup, pInfo->pPartScalarSup, pPreRes, i);

×

2081

    code = appendPkToSpecialBlock(pBlock, (TSKEY*)pTsCol->pData, pPkCol, i, &uid, &groupId, NULL);

×

2082

    QUERY_CHECK_CODE(code, lino, _end);

×

2084

  printDataBlock(pBlock, "new delete", taskIdStr);

×

2086

_end:

×

2087

  if (code != TSDB_CODE_SUCCESS) {

×

2088

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

2090

  return code;

×

2093

static int32_t generateSessionScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSrcBlock, SSDataBlock* pDestBlock,

×

2095

  int32_t code = TSDB_CODE_SUCCESS;

×

2096

  int32_t lino = 0;

×

2097

  if (pSrcBlock->info.rows == 0) {

×

2098

    return TSDB_CODE_SUCCESS;

×

2100

  SSHashObj*       pScanRange = tSimpleHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT));

×

2101

  SExecTaskInfo*   pTaskInfo = pInfo->pStreamScanOp->pTaskInfo;

×

2102

  SColumnInfoData* pStartTsCol = taosArrayGet(pSrcBlock->pDataBlock, START_TS_COLUMN_INDEX);

×

2103

  TSKEY*           startData = (TSKEY*)pStartTsCol->pData;

×

2104

  SColumnInfoData* pEndTsCol = taosArrayGet(pSrcBlock->pDataBlock, END_TS_COLUMN_INDEX);

×

2105

  TSKEY*           endData = (TSKEY*)pEndTsCol->pData;

×

2106

  SColumnInfoData* pUidCol = taosArrayGet(pSrcBlock->pDataBlock, UID_COLUMN_INDEX);

×

2107

  uint64_t*        uidCol = (uint64_t*)pUidCol->pData;

×

2108

  SColumnInfoData* pGpCol = taosArrayGet(pSrcBlock->pDataBlock, GROUPID_COLUMN_INDEX);

×

2109

  SColumnInfoData* pSrcPkCol = NULL;

×

2110

  uint64_t*        pSrcGp = (uint64_t*)pGpCol->pData;

×

2111

  if (taosArrayGetSize(pSrcBlock->pDataBlock) > PRIMARY_KEY_COLUMN_INDEX) {

×

2112

    pSrcPkCol = taosArrayGet(pSrcBlock->pDataBlock, PRIMARY_KEY_COLUMN_INDEX);

×

2114

  int64_t ver = pSrcBlock->info.version - 1;

×

2116

  if (pInfo->partitionSup.needCalc &&

×

2117

      (startData[0] != endData[0] || (hasPrimaryKeyCol(pInfo) && mode == STREAM_DELETE_DATA))) {

×

2118

    code = getPreVersionDataBlock(uidCol[0], startData[0], endData[0], ver, GET_TASKID(pTaskInfo), pInfo, pSrcBlock);

×

2119

    QUERY_CHECK_CODE(code, lino, _end);

×

2120

    startData = (TSKEY*)pStartTsCol->pData;

×

2121

    endData = (TSKEY*)pEndTsCol->pData;

×

2122

    uidCol = (uint64_t*)pUidCol->pData;

×

2123

    pSrcGp = (uint64_t*)pGpCol->pData;

×

2125

  blockDataCleanup(pDestBlock);

×

2126

  code = blockDataEnsureCapacity(pDestBlock, pSrcBlock->info.rows);

×

2127

  QUERY_CHECK_CODE(code, lino, _end);

×

2129

  SColumnInfoData* pDestStartCol = taosArrayGet(pDestBlock->pDataBlock, START_TS_COLUMN_INDEX);

×

2130

  SColumnInfoData* pDestEndCol = taosArrayGet(pDestBlock->pDataBlock, END_TS_COLUMN_INDEX);

×

2131

  SColumnInfoData* pDestUidCol = taosArrayGet(pDestBlock->pDataBlock, UID_COLUMN_INDEX);

×

2132

  SColumnInfoData* pDestGpCol = taosArrayGet(pDestBlock->pDataBlock, GROUPID_COLUMN_INDEX);

×

2133

  SColumnInfoData* pDestCalStartTsCol = taosArrayGet(pDestBlock->pDataBlock, CALCULATE_START_TS_COLUMN_INDEX);

×

2134

  SColumnInfoData* pDestCalEndTsCol = taosArrayGet(pDestBlock->pDataBlock, CALCULATE_END_TS_COLUMN_INDEX);

×

2135

  SColumnInfoData* pDestTableNameInxCol = taosArrayGet(pDestBlock->pDataBlock, TABLE_NAME_COLUMN_INDEX);

×

2136

  for (int32_t i = 0; i < pSrcBlock->info.rows; i++) {

×

2137

    uint64_t groupId = pSrcGp[i];

×

2138

    if (groupId == 0) {

×

2139

      void* pVal = NULL;

×

2140

      if (hasPrimaryKeyCol(pInfo) && pSrcPkCol) {

×

2141

        pVal = colDataGetData(pSrcPkCol, i);

×

2143

      groupId = getGroupIdByData(pInfo, uidCol[i], startData[i], ver, pVal);

×

2146

    SSessionKey startWin = {0};

×

2147

    getCurSessionWindow(pInfo->windowSup.pStreamAggSup, startData[i], startData[i], groupId, &startWin);

×

2148

    if (IS_INVALID_SESSION_WIN_KEY(startWin)) {

×

2150

      continue;

×

2152

    SSessionKey endWin = {0};

×

2153

    getCurSessionWindow(pInfo->windowSup.pStreamAggSup, endData[i], endData[i], groupId, &endWin);

×

2154

    if (IS_INVALID_SESSION_WIN_KEY(endWin)) {

×

2155

      getPreSessionWindow(pInfo->windowSup.pStreamAggSup, endData[i], endData[i], groupId, &endWin);

×

2157

    if (IS_INVALID_SESSION_WIN_KEY(startWin)) {

×

2159

      qError("generate session scan range failed. rang start:%" PRIx64 ", end:%" PRIx64, startData[i], endData[i]);

×

2160

      continue;

×

2163

    SSessionKey checkKey = {.groupId = groupId, .win.skey = startWin.win.skey, .win.ekey = endWin.win.ekey};

×

2164

    if (tSimpleHashGet(pScanRange, &checkKey, sizeof(SSessionKey)) != NULL) {

×

2165

      continue;

×

2167

    code = tSimpleHashPut(pScanRange, &checkKey, sizeof(SSessionKey), NULL, 0);

×

2168

    QUERY_CHECK_CODE(code, lino, _end);

×

2170

    code = colDataSetVal(pDestStartCol, i, (const char*)&startWin.win.skey, false);

×

2171

    QUERY_CHECK_CODE(code, lino, _end);

×

2173

    code = colDataSetVal(pDestEndCol, i, (const char*)&endWin.win.ekey, false);

×

2174

    QUERY_CHECK_CODE(code, lino, _end);

×

2176

    colDataSetNULL(pDestUidCol, i);

×

2177

    code = colDataSetVal(pDestGpCol, i, (const char*)&groupId, false);

×

2178

    QUERY_CHECK_CODE(code, lino, _end);

×

2180

    colDataSetNULL(pDestCalStartTsCol, i);

×

2181

    colDataSetNULL(pDestTableNameInxCol, i);

×

2182

    pDestBlock->info.rows++;

×

2185

_end:

×

2186

  tSimpleHashCleanup(pScanRange);

×

2187

  if (code != TSDB_CODE_SUCCESS) {

×

2188

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

2190

  return code;

×

2193

static int32_t generateCountScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSrcBlock, SSDataBlock* pDestBlock,

×

2195

  int32_t code = TSDB_CODE_SUCCESS;

×

2196

  int32_t lino = 0;

×

2197

  blockDataCleanup(pDestBlock);

×

2198

  if (pSrcBlock->info.rows == 0) {

×

2199

    return TSDB_CODE_SUCCESS;

×

2201

  SExecTaskInfo*   pTaskInfo = pInfo->pStreamScanOp->pTaskInfo;

×

2202

  SColumnInfoData* pStartTsCol = taosArrayGet(pSrcBlock->pDataBlock, START_TS_COLUMN_INDEX);

×

2203

  TSKEY*           startData = (TSKEY*)pStartTsCol->pData;

×

2204

  SColumnInfoData* pEndTsCol = taosArrayGet(pSrcBlock->pDataBlock, END_TS_COLUMN_INDEX);

×

2205

  TSKEY*           endData = (TSKEY*)pEndTsCol->pData;

×

2206

  SColumnInfoData* pUidCol = taosArrayGet(pSrcBlock->pDataBlock, UID_COLUMN_INDEX);

×

2207

  uint64_t*        uidCol = (uint64_t*)pUidCol->pData;

×

2208

  SColumnInfoData* pGpCol = taosArrayGet(pSrcBlock->pDataBlock, GROUPID_COLUMN_INDEX);

×

2209

  uint64_t*        pSrcGp = (uint64_t*)pGpCol->pData;

×

2210

  SColumnInfoData* pSrcPkCol = NULL;

×

2211

  if (taosArrayGetSize(pSrcBlock->pDataBlock) > PRIMARY_KEY_COLUMN_INDEX) {

×

2212

    pSrcPkCol = taosArrayGet(pSrcBlock->pDataBlock, PRIMARY_KEY_COLUMN_INDEX);

×

2214

  int64_t ver = pSrcBlock->info.version - 1;

×

2216

  if (pInfo->partitionSup.needCalc &&

×

2217

      (startData[0] != endData[0] || (hasPrimaryKeyCol(pInfo) && mode == STREAM_DELETE_DATA))) {

×

2218

    code = getPreVersionDataBlock(uidCol[0], startData[0], endData[0], ver, GET_TASKID(pTaskInfo), pInfo, pSrcBlock);

×

2219

    QUERY_CHECK_CODE(code, lino, _end);

×

2220

    startData = (TSKEY*)pStartTsCol->pData;

×

2221

    endData = (TSKEY*)pEndTsCol->pData;

×

2222

    uidCol = (uint64_t*)pUidCol->pData;

×

2223

    pSrcGp = (uint64_t*)pGpCol->pData;

×

2226

  code = blockDataEnsureCapacity(pDestBlock, pSrcBlock->info.rows);

×

2227

  QUERY_CHECK_CODE(code, lino, _end);

×

2229

  SColumnInfoData* pDestStartCol = taosArrayGet(pDestBlock->pDataBlock, START_TS_COLUMN_INDEX);

×

2230

  SColumnInfoData* pDestEndCol = taosArrayGet(pDestBlock->pDataBlock, END_TS_COLUMN_INDEX);

×

2231

  SColumnInfoData* pDestUidCol = taosArrayGet(pDestBlock->pDataBlock, UID_COLUMN_INDEX);

×

2232

  SColumnInfoData* pDestGpCol = taosArrayGet(pDestBlock->pDataBlock, GROUPID_COLUMN_INDEX);

×

2233

  SColumnInfoData* pDestCalStartTsCol = taosArrayGet(pDestBlock->pDataBlock, CALCULATE_START_TS_COLUMN_INDEX);

×

2234

  SColumnInfoData* pDestCalEndTsCol = taosArrayGet(pDestBlock->pDataBlock, CALCULATE_END_TS_COLUMN_INDEX);

×

2235

  SColumnInfoData* pDestTableNameInxCol = taosArrayGet(pDestBlock->pDataBlock, TABLE_NAME_COLUMN_INDEX);

×

2236

  for (int32_t i = 0; i < pSrcBlock->info.rows; i++) {

×

2237

    uint64_t groupId = pSrcGp[i];

×

2238

    if (groupId == 0) {

×

2239

      void* pVal = NULL;

×

2240

      if (hasPrimaryKeyCol(pInfo) && pSrcPkCol) {

×

2241

        pVal = colDataGetData(pSrcPkCol, i);

×

2243

      groupId = getGroupIdByData(pInfo, uidCol[i], startData[i], ver, pVal);

×

2245

    SSessionKey startWin = {.win.skey = startData[i], .win.ekey = endData[i], .groupId = groupId};

×

2246

    SSessionKey range = {0};

×

2247

    getCountWinRange(pInfo->windowSup.pStreamAggSup, &startWin, mode, &range);

×

2248

    code = colDataSetVal(pDestStartCol, i, (const char*)&range.win.skey, false);

×

2249

    QUERY_CHECK_CODE(code, lino, _end);

×

2251

    code = colDataSetVal(pDestEndCol, i, (const char*)&range.win.ekey, false);

×

2252

    QUERY_CHECK_CODE(code, lino, _end);

×

2254

    colDataSetNULL(pDestUidCol, i);

×

2255

    code = colDataSetVal(pDestGpCol, i, (const char*)&groupId, false);

×

2256

    QUERY_CHECK_CODE(code, lino, _end);

×

2258

    code = colDataSetVal(pDestCalStartTsCol, i, (const char*)&range.win.skey, false);

×

2259

    QUERY_CHECK_CODE(code, lino, _end);

×

2261

    code = colDataSetVal(pDestCalEndTsCol, i, (const char*)&range.win.ekey, false);

×

2262

    QUERY_CHECK_CODE(code, lino, _end);

×

2264

    colDataSetNULL(pDestTableNameInxCol, i);

×

2266

    pDestBlock->info.rows++;

×

2269

_end:

×

2270

  if (code != TSDB_CODE_SUCCESS) {

×

2271

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

2273

  return code;

×

2276

static int32_t setDelRangeEndKey(SStreamAggSupporter* pAggSup, SStreamFillSupporter* pFillSup, SWinKey* pEndKey, STimeWindow* pScanRange, bool* pRes) {

×

2277

  int32_t     code = TSDB_CODE_SUCCESS;

×

2278

  int32_t     lino = 0;

×

2279

  SSlicePoint nextPoint = {.key.groupId = pEndKey->groupId};

×

2280

  int32_t     vLen = 0;

×

2281

  int32_t     winCode = TSDB_CODE_SUCCESS;

×

2282

  code = pAggSup->stateStore.streamStateFillGetNext(pAggSup->pState, pEndKey, &nextPoint.key, (void**)&nextPoint.pResPos, &vLen, &winCode);

×

2283

  QUERY_CHECK_CODE(code, lino, _end);

×

2284

  if (winCode == TSDB_CODE_SUCCESS) {

×

2285

    setPointBuff(&nextPoint, pFillSup);

×

2286

    if (HAS_ROW_DATA(nextPoint.pLeftRow) && pEndKey->ts < nextPoint.pLeftRow->key) {

×

2287

      pScanRange->ekey = nextPoint.pLeftRow->key;

×

2288

      *pRes = true;

×

2289

    } else if (pEndKey->ts < nextPoint.pRightRow->key) {

×

2290

      pScanRange->ekey = nextPoint.pRightRow->key;

×

2291

      *pRes = true;

×

2293

      *pEndKey = nextPoint.key;

×

2294

      pScanRange->ekey = TMAX(nextPoint.pRightRow->key, nextPoint.key.ts);

×

2295

      *pRes = false;

×

2299

_end:

×

2300

  if (code != TSDB_CODE_SUCCESS) {

×

2301

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

2303

  return code;

×

2306

int32_t getTimeSliceWinRange(SStreamAggSupporter* pAggSup, SStreamFillSupporter* pFillSup, SInterval* pInterval, TSKEY start, TSKEY end,

×

2308

  int32_t        code = TSDB_CODE_SUCCESS;

×

2309

  int32_t        lino = 0;

×

2310

  int32_t        winCode = TSDB_CODE_SUCCESS;

×

2311

  SResultRowInfo dumyInfo = {0};

×

2312

  dumyInfo.cur.pageId = -1;

×

2313

  STimeWindow sWin = getActiveTimeWindow(NULL, &dumyInfo, start, pInterval, TSDB_ORDER_ASC);

×

2314

  SWinKey     startKey = {.groupId = groupId, .ts = sWin.skey};

×

2316

  sWin = getActiveTimeWindow(NULL, &dumyInfo, end, pInterval, TSDB_ORDER_ASC);

×

2317

  SWinKey endKey = {.groupId = groupId, .ts = sWin.ekey};

×

2319

  SSlicePoint prevPoint = {.key.groupId = groupId};

×

2320

  SSlicePoint nextPoint = {.key.groupId = groupId};

×

2321

  int32_t     vLen = 0;

×

2322

  code = pAggSup->stateStore.streamStateFillGetPrev(pAggSup->pState, &startKey, &prevPoint.key, (void**)&prevPoint.pResPos, &vLen, &winCode);

×

2323

  QUERY_CHECK_CODE(code, lino, _end);

×

2324

  if (winCode == TSDB_CODE_SUCCESS) {

×

2325

    setPointBuff(&prevPoint, pFillSup);

×

2326

    if (HAS_ROW_DATA(prevPoint.pRightRow)) {

×

2327

      pScanRange->skey = prevPoint.pRightRow->key;

×

2329

      pScanRange->skey = prevPoint.pLeftRow->key;

×

2332

    pScanRange->skey = startKey.ts;

×

2335

  bool res = false;

×

2336

  SWinKey curKey = endKey;

×

2337

  code = setDelRangeEndKey(pAggSup, pFillSup, &curKey, pScanRange, &res);

×

2338

  QUERY_CHECK_CODE(code, lino, _end);

×

2339

  if (res == false) {

×

2340

    code = setDelRangeEndKey(pAggSup, pFillSup, &curKey, pScanRange, &res);

×

2341

    QUERY_CHECK_CODE(code, lino, _end);

×

2343

  if (res == false) {

×

2344

    pScanRange->ekey = TMAX(endKey.ts, pScanRange->ekey);

×

2347

_end:

×

2348

  if (code != TSDB_CODE_SUCCESS) {

×

2349

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

2351

  return code;

×

2354

static int32_t generateTimeSliceScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSrcBlock, SSDataBlock* pDestBlock,

×

2356

  int32_t code = TSDB_CODE_SUCCESS;

×

2357

  int32_t lino = 0;

×

2358

  blockDataCleanup(pDestBlock);

×

2359

  if (pSrcBlock->info.rows == 0) {

×

2360

    return TSDB_CODE_SUCCESS;

×

2362

  SExecTaskInfo*   pTaskInfo = pInfo->pStreamScanOp->pTaskInfo;

×

2363

  SColumnInfoData* pStartTsCol = taosArrayGet(pSrcBlock->pDataBlock, START_TS_COLUMN_INDEX);

×

2364

  TSKEY*           startData = (TSKEY*)pStartTsCol->pData;

×

2365

  SColumnInfoData* pEndTsCol = taosArrayGet(pSrcBlock->pDataBlock, END_TS_COLUMN_INDEX);

×

2366

  TSKEY*           endData = (TSKEY*)pEndTsCol->pData;

×

2367

  SColumnInfoData* pUidCol = taosArrayGet(pSrcBlock->pDataBlock, UID_COLUMN_INDEX);

×

2368

  uint64_t*        uidCol = (uint64_t*)pUidCol->pData;

×

2369

  SColumnInfoData* pGpCol = taosArrayGet(pSrcBlock->pDataBlock, GROUPID_COLUMN_INDEX);

×

2370

  uint64_t*        pSrcGp = (uint64_t*)pGpCol->pData;

×

2371

  SColumnInfoData* pSrcPkCol = NULL;

×

2372

  if (taosArrayGetSize(pSrcBlock->pDataBlock) > PRIMARY_KEY_COLUMN_INDEX) {

×

2373

    pSrcPkCol = taosArrayGet(pSrcBlock->pDataBlock, PRIMARY_KEY_COLUMN_INDEX);

×

2375

  int64_t ver = pSrcBlock->info.version - 1;

×

2377

  if (pInfo->partitionSup.needCalc &&

×

2378

      (startData[0] != endData[0] || (hasPrimaryKeyCol(pInfo) && mode == STREAM_DELETE_DATA))) {

×

2379

    code = getPreVersionDataBlock(uidCol[0], startData[0], endData[0], ver, GET_TASKID(pTaskInfo), pInfo, pSrcBlock);

×

2380

    QUERY_CHECK_CODE(code, lino, _end);

×

2381

    startData = (TSKEY*)pStartTsCol->pData;

×

2382

    endData = (TSKEY*)pEndTsCol->pData;

×

2383

    uidCol = (uint64_t*)pUidCol->pData;

×

2384

    pSrcGp = (uint64_t*)pGpCol->pData;

×

2387

  code = blockDataEnsureCapacity(pDestBlock, pSrcBlock->info.rows);

×

2388

  QUERY_CHECK_CODE(code, lino, _end);

×

2390

  SColumnInfoData* pDestStartCol = taosArrayGet(pDestBlock->pDataBlock, START_TS_COLUMN_INDEX);

×

2391

  SColumnInfoData* pDestEndCol = taosArrayGet(pDestBlock->pDataBlock, END_TS_COLUMN_INDEX);

×

2392

  SColumnInfoData* pDestUidCol = taosArrayGet(pDestBlock->pDataBlock, UID_COLUMN_INDEX);

×

2393

  SColumnInfoData* pDestGpCol = taosArrayGet(pDestBlock->pDataBlock, GROUPID_COLUMN_INDEX);

×

2394

  SColumnInfoData* pDestCalStartTsCol = taosArrayGet(pDestBlock->pDataBlock, CALCULATE_START_TS_COLUMN_INDEX);

×

2395

  SColumnInfoData* pDestCalEndTsCol = taosArrayGet(pDestBlock->pDataBlock, CALCULATE_END_TS_COLUMN_INDEX);

×

2396

  for (int32_t i = 0; i < pSrcBlock->info.rows; i++) {

×

2397

    uint64_t groupId = pSrcGp[i];

×

2398

    if (groupId == 0) {

×

2399

      void* pVal = NULL;

×

2400

      if (hasPrimaryKeyCol(pInfo) && pSrcPkCol) {

×

2401

        pVal = colDataGetData(pSrcPkCol, i);

×

2403

      groupId = getGroupIdByData(pInfo, uidCol[i], startData[i], ver, pVal);

×

2406

    STimeWindow scanRange = {0};

×

2407

    code = getTimeSliceWinRange(pInfo->windowSup.pStreamAggSup, pInfo->pFillSup, &pInfo->interval, startData[i], endData[i], groupId,

×

2409

    QUERY_CHECK_CODE(code, lino, _end);

×

2411

    code = colDataSetVal(pDestStartCol, i, (const char*)&scanRange.skey, false);

×

2412

    QUERY_CHECK_CODE(code, lino, _end);

×

2414

    code = colDataSetVal(pDestEndCol, i, (const char*)&scanRange.ekey, false);

×

2415

    QUERY_CHECK_CODE(code, lino, _end);

×

2417

    colDataSetNULL(pDestUidCol, i);

×

2418

    code = colDataSetVal(pDestGpCol, i, (const char*)&groupId, false);

×

2419

    QUERY_CHECK_CODE(code, lino, _end);

×

2421

    code = colDataSetVal(pDestCalStartTsCol, i, (const char*)&scanRange.skey, false);

×

2422

    QUERY_CHECK_CODE(code, lino, _end);

×

2424

    code = colDataSetVal(pDestCalEndTsCol, i, (const char*)&scanRange.ekey, false);

×

2425

    QUERY_CHECK_CODE(code, lino, _end);

×

2427

    pDestBlock->info.rows++;

×

2430

_end:

×

2431

  if (code != TSDB_CODE_SUCCESS) {

×

2432

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

2434

  return code;

×

2437

static int32_t generateIntervalScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSrcBlock, SSDataBlock* pDestBlock,

×

2439

  int32_t code = TSDB_CODE_SUCCESS;

×

2440

  int32_t lino = 0;

×

2441

  blockDataCleanup(pDestBlock);

×

2442

  if (pSrcBlock->info.rows == 0) {

×

2443

    return TSDB_CODE_SUCCESS;

×

2445

  SSHashObj*       pScanRange = tSimpleHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT));

×

2446

  SExecTaskInfo*   pTaskInfo = pInfo->pStreamScanOp->pTaskInfo;

×

2447

  SColumnInfoData* pSrcStartTsCol = (SColumnInfoData*)taosArrayGet(pSrcBlock->pDataBlock, START_TS_COLUMN_INDEX);

×

2448

  SColumnInfoData* pSrcEndTsCol = (SColumnInfoData*)taosArrayGet(pSrcBlock->pDataBlock, END_TS_COLUMN_INDEX);

×

2449

  SColumnInfoData* pSrcUidCol = taosArrayGet(pSrcBlock->pDataBlock, UID_COLUMN_INDEX);

×

2450

  SColumnInfoData* pSrcGpCol = taosArrayGet(pSrcBlock->pDataBlock, GROUPID_COLUMN_INDEX);

×

2451

  SColumnInfoData* pSrcPkCol = NULL;

×

2452

  if (taosArrayGetSize(pSrcBlock->pDataBlock) > PRIMARY_KEY_COLUMN_INDEX) {

×

2453

    pSrcPkCol = taosArrayGet(pSrcBlock->pDataBlock, PRIMARY_KEY_COLUMN_INDEX);

×

2456

  uint64_t* srcUidData = (uint64_t*)pSrcUidCol->pData;

×

2457

  TSKEY*    srcStartTsCol = (TSKEY*)pSrcStartTsCol->pData;

×

2458

  TSKEY*    srcEndTsCol = (TSKEY*)pSrcEndTsCol->pData;

×

2459

  int64_t   ver = pSrcBlock->info.version - 1;

×

2461

  if (pInfo->partitionSup.needCalc &&

×

2462

      (srcStartTsCol[0] != srcEndTsCol[0] || (hasPrimaryKeyCol(pInfo) && mode == STREAM_DELETE_DATA))) {

×

2463

    code = getPreVersionDataBlock(srcUidData[0], srcStartTsCol[0], srcEndTsCol[0], ver, GET_TASKID(pTaskInfo), pInfo,

×

2465

    QUERY_CHECK_CODE(code, lino, _end);

×

2467

    srcStartTsCol = (TSKEY*)pSrcStartTsCol->pData;

×

2468

    srcEndTsCol = (TSKEY*)pSrcEndTsCol->pData;

×

2469

    srcUidData = (uint64_t*)pSrcUidCol->pData;

×

2472

  uint64_t* srcGp = (uint64_t*)pSrcGpCol->pData;

×

2473

  code = blockDataEnsureCapacity(pDestBlock, pSrcBlock->info.rows);

×

2474

  QUERY_CHECK_CODE(code, lino, _end);

×

2476

  SColumnInfoData* pStartTsCol = taosArrayGet(pDestBlock->pDataBlock, START_TS_COLUMN_INDEX);

×

2477

  SColumnInfoData* pEndTsCol = taosArrayGet(pDestBlock->pDataBlock, END_TS_COLUMN_INDEX);

×

2478

  SColumnInfoData* pDeUidCol = taosArrayGet(pDestBlock->pDataBlock, UID_COLUMN_INDEX);

×

2479

  SColumnInfoData* pGpCol = taosArrayGet(pDestBlock->pDataBlock, GROUPID_COLUMN_INDEX);

×

2480

  SColumnInfoData* pCalStartTsCol = taosArrayGet(pDestBlock->pDataBlock, CALCULATE_START_TS_COLUMN_INDEX);

×

2481

  SColumnInfoData* pCalEndTsCol = taosArrayGet(pDestBlock->pDataBlock, CALCULATE_END_TS_COLUMN_INDEX);

×

2482

  SColumnInfoData* pDestTableNameInxCol = taosArrayGet(pDestBlock->pDataBlock, TABLE_NAME_COLUMN_INDEX);

×

2483

  for (int32_t i = 0; i < pSrcBlock->info.rows;) {

×

2484

    uint64_t srcUid = srcUidData[i];

×

2485

    uint64_t groupId = srcGp[i];

×

2486

    if (groupId == 0) {

×

2487

      void* pVal = NULL;

×

2488

      if (hasPrimaryKeyCol(pInfo) && pSrcPkCol) {

×

2489

        pVal = colDataGetData(pSrcPkCol, i);

×

2491

      groupId = getGroupIdByData(pInfo, srcUid, srcStartTsCol[i], ver, pVal);

×

2493

    TSKEY calStartTs = srcStartTsCol[i];

×

2494

    code = colDataSetVal(pCalStartTsCol, pDestBlock->info.rows, (const char*)(&calStartTs), false);

×

2495

    QUERY_CHECK_CODE(code, lino, _end);

×

2497

    STimeWindow win = getSlidingWindow(srcStartTsCol, srcEndTsCol, srcGp, &pInfo->interval, &pSrcBlock->info, &i,

×

2498

                                       pInfo->partitionSup.needCalc);

×

2499

    TSKEY       calEndTs = srcStartTsCol[i - 1];

×

2500

    code = colDataSetVal(pCalEndTsCol, pDestBlock->info.rows, (const char*)(&calEndTs), false);

×

2501

    QUERY_CHECK_CODE(code, lino, _end);

×

2503

    code = colDataSetVal(pDeUidCol, pDestBlock->info.rows, (const char*)(&srcUid), false);

×

2504

    QUERY_CHECK_CODE(code, lino, _end);

×

2506

    SSessionKey checkKey = {.groupId = groupId, .win = win};

×

2507

    if (tSimpleHashGet(pScanRange, &checkKey, sizeof(SSessionKey)) != NULL) {

×

2508

      continue;

×

2510

    code = tSimpleHashPut(pScanRange, &checkKey, sizeof(SSessionKey), NULL, 0);

×

2511

    QUERY_CHECK_CODE(code, lino, _end);

×

2513

    code = colDataSetVal(pStartTsCol, pDestBlock->info.rows, (const char*)(&win.skey), false);

×

2514

    QUERY_CHECK_CODE(code, lino, _end);

×

2516

    code = colDataSetVal(pEndTsCol, pDestBlock->info.rows, (const char*)(&win.ekey), false);

×

2517

    QUERY_CHECK_CODE(code, lino, _end);

×

2519

    code = colDataSetVal(pGpCol, pDestBlock->info.rows, (const char*)(&groupId), false);

×

2520

    QUERY_CHECK_CODE(code, lino, _end);

×

2522

    colDataSetNULL(pDestTableNameInxCol,  pDestBlock->info.rows);

×

2524

    pDestBlock->info.rows++;

×

2527

_end:

×

2528

  tSimpleHashCleanup(pScanRange);

×

2529

  if (code != TSDB_CODE_SUCCESS) {

×

2530

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

2532

  return code;

×

2535

static int32_t calBlockTbName(SStreamScanInfo* pInfo, SSDataBlock* pBlock, int32_t rowId) {

×

2536

  int32_t code = TSDB_CODE_SUCCESS;

×

2537

  int32_t lino = 0;

×

2538

  blockDataCleanup(pInfo->pCreateTbRes);

×

2539

  if (pInfo->tbnameCalSup.numOfExprs == 0 && pInfo->tagCalSup.numOfExprs == 0) {

×

2540

    pBlock->info.parTbName[0] = 0;

×

2542

    code = appendCreateTableRow(pInfo->pStreamScanOp->pTaskInfo->streamInfo.pState, &pInfo->tbnameCalSup,

×

2545

    QUERY_CHECK_CODE(code, lino, _end);

×

2548

_end:

×

2549

  if (code != TSDB_CODE_SUCCESS) {

×

2550

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

2552

  return code;

×

2555

static int32_t generatePartitionDelResBlock(SStreamScanInfo* pInfo, SSDataBlock* pSrcBlock, SSDataBlock* pDestBlock) {

×

2556

  int32_t          code = TSDB_CODE_SUCCESS;

×

2557

  int32_t          lino = 0;

×

2558

  SColumnInfoData* pSrcStartTsCol = (SColumnInfoData*)taosArrayGet(pSrcBlock->pDataBlock, START_TS_COLUMN_INDEX);

×

2559

  SColumnInfoData* pSrcEndTsCol = (SColumnInfoData*)taosArrayGet(pSrcBlock->pDataBlock, END_TS_COLUMN_INDEX);

×

2560

  SColumnInfoData* pSrcUidCol = taosArrayGet(pSrcBlock->pDataBlock, UID_COLUMN_INDEX);

×

2561

  uint64_t*        srcUidData = (uint64_t*)pSrcUidCol->pData;

×

2562

  SColumnInfoData* pSrcGpCol = taosArrayGet(pSrcBlock->pDataBlock, GROUPID_COLUMN_INDEX);

×

2563

  uint64_t*        srcGp = (uint64_t*)pSrcGpCol->pData;

×

2565

  TSKEY*  srcStartTsCol = (TSKEY*)pSrcStartTsCol->pData;

×

2566

  TSKEY*  srcEndTsCol = (TSKEY*)pSrcEndTsCol->pData;

×

2567

  int64_t ver = pSrcBlock->info.version - 1;

×

2568

  for (int32_t delI = 0; delI < pSrcBlock->info.rows; delI++) {

×

2569

    uint64_t     groupId = 0;

×

2570

    uint64_t     srcUid = srcUidData[delI];

×

2571

    char         tbname[VARSTR_HEADER_SIZE + TSDB_TABLE_NAME_LEN] = {0};

×

2572

    SSDataBlock* pPreRes = readPreVersionData(pInfo->pTableScanOp, srcUid, srcStartTsCol[delI], srcEndTsCol[delI], ver);

×

2573

    if (!pPreRes) {

×

2574

      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));

×

2575

      continue;

×

2577

    code = blockDataEnsureCapacity(pDestBlock, pDestBlock->info.rows + pPreRes->info.rows);

×

2578

    QUERY_CHECK_CODE(code, lino, _end);

×

2579

    for (int32_t preJ = 0; preJ < pPreRes->info.rows; preJ++) {

×

2580

      groupId = calGroupIdByData(&pInfo->partitionSup, pInfo->pPartScalarSup, pPreRes, preJ);

×

2581

      if (pInfo->pPartTbnameSup) {

×

2582

        void*   parTbname = NULL;

×

2583

        int32_t winCode = TSDB_CODE_SUCCESS;

×

2584

        code = pInfo->stateStore.streamStateGetParName(pInfo->pStreamScanOp->pTaskInfo->streamInfo.pState, groupId,

×

2586

        QUERY_CHECK_CODE(code, lino, _end);

×

2588

        if (winCode != TSDB_CODE_SUCCESS) {

×

2589

          code = calBlockTbName(pInfo, pPreRes, preJ);

×

2590

          QUERY_CHECK_CODE(code, lino, _end);

×

2591

          memcpy(varDataVal(tbname), pPreRes->info.parTbName, strlen(pPreRes->info.parTbName));

×

2593

          memcpy(varDataVal(tbname), parTbname, TSDB_TABLE_NAME_LEN);

×

2595

        varDataSetLen(tbname, strlen(varDataVal(tbname)));

×

2596

        pInfo->stateStore.streamStateFreeVal(parTbname);

×

2598

      code = appendDataToSpecialBlock(pDestBlock, srcStartTsCol + delI, srcEndTsCol + delI, srcUidData + delI, &groupId,

×

2599

                                      tbname[0] == 0 ? NULL : tbname);

×

2600

      QUERY_CHECK_CODE(code, lino, _end);

×

2604

_end:

×

2605

  if (code != TSDB_CODE_SUCCESS) {

×

2606

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

2608

  return code;

×

2611

static int32_t generateDeleteResultBlockImpl(SStreamScanInfo* pInfo, SSDataBlock* pSrcBlock, SSDataBlock* pDestBlock) {

×

2612

  int32_t          code = TSDB_CODE_SUCCESS;

×

2613

  int32_t          lino = 0;

×

2614

  SColumnInfoData* pSrcStartTsCol = (SColumnInfoData*)taosArrayGet(pSrcBlock->pDataBlock, START_TS_COLUMN_INDEX);

×

2615

  SColumnInfoData* pSrcEndTsCol = (SColumnInfoData*)taosArrayGet(pSrcBlock->pDataBlock, END_TS_COLUMN_INDEX);

×

2616

  SColumnInfoData* pSrcUidCol = taosArrayGet(pSrcBlock->pDataBlock, UID_COLUMN_INDEX);

×

2617

  uint64_t*        srcUidData = (uint64_t*)pSrcUidCol->pData;

×

2618

  SColumnInfoData* pSrcGpCol = taosArrayGet(pSrcBlock->pDataBlock, GROUPID_COLUMN_INDEX);

×

2619

  uint64_t*        srcGp = (uint64_t*)pSrcGpCol->pData;

×

2620

  SColumnInfoData* pSrcPkCol = NULL;

×

2621

  if (taosArrayGetSize(pSrcBlock->pDataBlock) > PRIMARY_KEY_COLUMN_INDEX) {

×

2622

    pSrcPkCol = taosArrayGet(pSrcBlock->pDataBlock, PRIMARY_KEY_COLUMN_INDEX);

×

2625

  TSKEY*  srcStartTsCol = (TSKEY*)pSrcStartTsCol->pData;

×

2626

  TSKEY*  srcEndTsCol = (TSKEY*)pSrcEndTsCol->pData;

×

2627

  int64_t ver = pSrcBlock->info.version - 1;

×

2628

  for (int32_t i = 0; i < pSrcBlock->info.rows; i++) {

×

2629

    uint64_t srcUid = srcUidData[i];

×

2630

    uint64_t groupId = srcGp[i];

×

2631

    char     tbname[VARSTR_HEADER_SIZE + TSDB_TABLE_NAME_LEN] = {0};

×

2632

    if (groupId == 0) {

×

2633

      void* pVal = NULL;

×

2634

      if (hasPrimaryKeyCol(pInfo) && pSrcPkCol) {

×

2635

        pVal = colDataGetData(pSrcPkCol, i);

×

2637

      groupId = getGroupIdByData(pInfo, srcUid, srcStartTsCol[i], ver, pVal);

×

2639

    if (pInfo->tbnameCalSup.pExprInfo) {

×

2640

      void*   parTbname = NULL;

×

2641

      int32_t winCode = TSDB_CODE_SUCCESS;

×

2642

      code = pInfo->stateStore.streamStateGetParName(pInfo->pStreamScanOp->pTaskInfo->streamInfo.pState, groupId,

×

2644

      QUERY_CHECK_CODE(code, lino, _end);

×

2646

      if (winCode != TSDB_CODE_SUCCESS) {

×

2647

        SSDataBlock* pPreRes = readPreVersionData(pInfo->pTableScanOp, srcUid, srcStartTsCol[i], srcStartTsCol[i], ver);

×

2648

        if (!pPreRes) {

×

2649

          qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));

×

2650

          continue;

×

2652

        printDataBlock(pPreRes, "pre res", GET_TASKID(pInfo->pStreamScanOp->pTaskInfo));

×

2653

        code = calBlockTbName(pInfo, pPreRes, 0);

×

2654

        QUERY_CHECK_CODE(code, lino, _end);

×

2655

        memcpy(varDataVal(tbname), pPreRes->info.parTbName, strlen(pPreRes->info.parTbName));

×

2657

        memcpy(varDataVal(tbname), parTbname, TSDB_TABLE_NAME_LEN);

×

2659

      varDataSetLen(tbname, strlen(varDataVal(tbname)));

×

2660

      pInfo->stateStore.streamStateFreeVal(parTbname);

×

2662

    code = appendDataToSpecialBlock(pDestBlock, srcStartTsCol + i, srcEndTsCol + i, srcUidData + i, &groupId,

×

2663

                                    tbname[0] == 0 ? NULL : tbname);

×

2664

    QUERY_CHECK_CODE(code, lino, _end);

×

2667

_end:

×

2668

  if (code != TSDB_CODE_SUCCESS) {

×

2669

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

2671

  return code;

×

2674

static int32_t generateDeleteResultBlock(SStreamScanInfo* pInfo, SSDataBlock* pSrcBlock, SSDataBlock* pDestBlock) {

×

2675

  blockDataCleanup(pDestBlock);

×

2676

  int32_t rows = pSrcBlock->info.rows;

×

2677

  if (rows == 0) {

×

2678

    return TSDB_CODE_SUCCESS;

×

2680

  int32_t code = blockDataEnsureCapacity(pDestBlock, rows);

×

2681

  if (code != TSDB_CODE_SUCCESS) {

×

2682

    return code;

×

2684

  if (pInfo->partitionSup.needCalc) {

×

2685

    return generatePartitionDelResBlock(pInfo, pSrcBlock, pDestBlock);

×

2687

  return generateDeleteResultBlockImpl(pInfo, pSrcBlock, pDestBlock);

×

2690

static int32_t generateScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSrcBlock, SSDataBlock* pDestBlock,

×

2692

  int32_t code = TSDB_CODE_SUCCESS;

×

2693

  int32_t lino = 0;

×

2694

  if (isIntervalWindow(pInfo)) {

×

2695

    code = generateIntervalScanRange(pInfo, pSrcBlock, pDestBlock, type);

×

2696

    QUERY_CHECK_CODE(code, lino, _end);

×

2697

  } else if (isSessionWindow(pInfo) || isStateWindow(pInfo)) {

×

2698

    code = generateSessionScanRange(pInfo, pSrcBlock, pDestBlock, type);

×

2699

    QUERY_CHECK_CODE(code, lino, _end);

×

2700

  } else if (isCountWindow(pInfo)) {

×

2701

    code = generateCountScanRange(pInfo, pSrcBlock, pDestBlock, type);

×

2702

    QUERY_CHECK_CODE(code, lino, _end);

×

2703

  } else if (isTimeSlice(pInfo)) {

×

2704

    code = generateTimeSliceScanRange(pInfo, pSrcBlock, pDestBlock, type);

×

2705

    QUERY_CHECK_CODE(code, lino, _end);

×

2707

    code = generateDeleteResultBlock(pInfo, pSrcBlock, pDestBlock);

×

2708

    QUERY_CHECK_CODE(code, lino, _end);

×

2710

  pDestBlock->info.type = STREAM_CLEAR;

×

2711

  pDestBlock->info.version = pSrcBlock->info.version;

×

2712

  pDestBlock->info.dataLoad = 1;

×

2713

  code = blockDataUpdateTsWindow(pDestBlock, 0);

×

2714

  QUERY_CHECK_CODE(code, lino, _end);

×

2716

_end:

×

2717

  if (code != TSDB_CODE_SUCCESS) {

×

2718

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

2720

  return code;

×

2723

int32_t appendDataToSpecialBlock(SSDataBlock* pBlock, TSKEY* pStartTs, TSKEY* pEndTs, uint64_t* pUid, uint64_t* pGp,

×

2725

  return appendOneRowToSpecialBlockImpl(pBlock, pStartTs, pEndTs, pStartTs, pEndTs, pUid, pGp, pTbName, NULL);

×

2728

bool checkExpiredData(SStateStore* pAPI, SUpdateInfo* pUpdateInfo, STimeWindowAggSupp* pTwSup, uint64_t tableId,

×

2730

  bool isExpired = false;

×

2731

  bool isInc = pAPI->isIncrementalTimeStamp(pUpdateInfo, tableId, ts, pPkVal, len);

×

2732

  if (!isInc) {

×

2733

    isExpired = isOverdue(ts, pTwSup);

×

2735

  return isExpired;

×

2738

static int32_t checkUpdateData(SStreamScanInfo* pInfo, bool invertible, SSDataBlock* pBlock, bool out) {

×

2739

  int32_t code = TSDB_CODE_SUCCESS;

×

2740

  int32_t lino = 0;

×

2741

  if (out) {

×

2742

    blockDataCleanup(pInfo->pUpdateDataRes);

×

2743

    code = blockDataEnsureCapacity(pInfo->pUpdateDataRes, pBlock->info.rows * 2);

×

2744

    QUERY_CHECK_CODE(code, lino, _end);

×

2746

  SColumnInfoData* pColDataInfo = taosArrayGet(pBlock->pDataBlock, pInfo->primaryTsIndex);

×

2747

  TSKEY*           tsCol = (TSKEY*)pColDataInfo->pData;

×

2748

  SColumnInfoData* pPkColDataInfo = NULL;

×

2749

  if (hasPrimaryKeyCol(pInfo)) {

×

2750

    pPkColDataInfo = taosArrayGet(pBlock->pDataBlock, pInfo->primaryKeyIndex);

×

2753

  bool tableInserted = pInfo->stateStore.updateInfoIsTableInserted(pInfo->pUpdateInfo, pBlock->info.id.uid);

×

2754

  for (int32_t rowId = 0; rowId < pBlock->info.rows; rowId++) {

×

2756

    dumyInfo.cur.pageId = -1;

×

2757

    bool        isClosed = false;

×

2758

    STimeWindow win = {.skey = INT64_MIN, .ekey = INT64_MAX};

×

2759

    bool        overDue = isOverdue(tsCol[rowId], &pInfo->twAggSup);

×

2760

    if (pInfo->igExpired && overDue) {

×

2761

      continue;

×

2764

    if (tableInserted && overDue) {

×

2765

      win = getActiveTimeWindow(NULL, &dumyInfo, tsCol[rowId], &pInfo->interval, TSDB_ORDER_ASC);

×

2766

      isClosed = isCloseWindow(&win, &pInfo->twAggSup);

×

2769

    void*   pPkVal = NULL;

×

2770

    int32_t pkLen = 0;

×

2771

    if (hasPrimaryKeyCol(pInfo)) {

×

2772

      pPkVal = colDataGetData(pPkColDataInfo, rowId);

×

2773

      pkLen = colDataGetRowLength(pPkColDataInfo, rowId);

×

2776

        pInfo->stateStore.updateInfoIsUpdated(pInfo->pUpdateInfo, pBlock->info.id.uid, tsCol[rowId], pPkVal, pkLen);

×

2777

    bool isDeleted =

×

2778

        isClosed && isSignleIntervalWindow(pInfo) &&

×

2779

        isDeletedStreamWindow(&win, pBlock->info.id.groupId, pInfo->pState, &pInfo->twAggSup, &pInfo->stateStore);

×

2780

    if ((update || isDeleted) && out) {

×

2781

      qDebug("stream update check not pass, update %d, deleted Win %d", update, isDeleted);

×

2782

      uint64_t gpId = 0;

×

2783

      code = appendPkToSpecialBlock(pInfo->pUpdateDataRes, tsCol, pPkColDataInfo, rowId, &pBlock->info.id.uid, &gpId,

×

2785

      QUERY_CHECK_CODE(code, lino, _end);

×

2786

      if (isDeleted && pInfo->partitionSup.needCalc) {

×

2787

        gpId = calGroupIdByData(&pInfo->partitionSup, pInfo->pPartScalarSup, pBlock, rowId);

×

2788

        code = appendPkToSpecialBlock(pInfo->pUpdateDataRes, tsCol, pPkColDataInfo, rowId, &pBlock->info.id.uid, &gpId,

×

2790

        QUERY_CHECK_CODE(code, lino, _end);

×

2794

  if (out && pInfo->pUpdateDataRes->info.rows > 0) {

×

2795

    pInfo->pUpdateDataRes->info.version = pBlock->info.version;

×

2796

    pInfo->pUpdateDataRes->info.dataLoad = 1;

×

2797

    code = blockDataUpdateTsWindow(pInfo->pUpdateDataRes, 0);

×

2798

    QUERY_CHECK_CODE(code, lino, _end);

×

2799

    pInfo->pUpdateDataRes->info.type = pInfo->partitionSup.needCalc ? STREAM_DELETE_DATA : STREAM_CLEAR;

×

2802

_end:

×

2803

  if (code != TSDB_CODE_SUCCESS) {

×

2804

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

2806

  return code;

×

2809

static int32_t doBlockDataWindowFilter(SSDataBlock* pBlock, int32_t tsIndex, STimeWindow* pWindow, const char* id) {

×

2810

  int32_t code = TSDB_CODE_SUCCESS;

×

2811

  int32_t lino = 0;

×

2812

  bool*   p = NULL;

×

2813

  if (pWindow->skey != INT64_MIN || pWindow->ekey != INT64_MAX) {

×

2814

    p = taosMemoryCalloc(pBlock->info.rows, sizeof(bool));

×

2815

    QUERY_CHECK_NULL(p, code, lino, _end, terrno);

×

2816

    bool hasUnqualified = false;

×

2818

    SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, tsIndex);

×

2820

    if (pWindow->skey != INT64_MIN) {

×

2821

      qDebug("%s filter for additional history window, skey:%" PRId64, id, pWindow->skey);

×

2823

      QUERY_CHECK_NULL(pCol->pData, code, lino, _end, TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);

×

2824

      for (int32_t i = 0; i < pBlock->info.rows; ++i) {

×

2825

        int64_t* ts = (int64_t*)colDataGetData(pCol, i);

×

2826

        p[i] = (*ts >= pWindow->skey);

×

2828

        if (!p[i]) {

×

2829

          hasUnqualified = true;

×

2832

    } else if (pWindow->ekey != INT64_MAX) {

×

2833

      qDebug("%s filter for additional history window, ekey:%" PRId64, id, pWindow->ekey);

×

2834

      for (int32_t i = 0; i < pBlock->info.rows; ++i) {

×

2835

        int64_t* ts = (int64_t*)colDataGetData(pCol, i);

×

2836

        p[i] = (*ts <= pWindow->ekey);

×

2838

        if (!p[i]) {

×

2839

          hasUnqualified = true;

×

2844

    if (hasUnqualified) {

×

2845

      code = trimDataBlock(pBlock, pBlock->info.rows, p);

×

2846

      QUERY_CHECK_CODE(code, lino, _end);

×

2850

_end:

×

2851

  taosMemoryFree(p);

×

2852

  if (code != TSDB_CODE_SUCCESS) {

×

2853

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

2855

  return code;

×

2858

static int32_t doBlockDataPrimaryKeyFilter(SSDataBlock* pBlock, STqOffsetVal* offset) {

×

2859

  int32_t code = TSDB_CODE_SUCCESS;

×

2860

  int32_t lino = 0;

×

2861

  if (pBlock->info.window.skey != offset->ts || offset->primaryKey.type == 0) {

×

2862

    return code;

×

2864

  bool* p = taosMemoryCalloc(pBlock->info.rows, sizeof(bool));

×

2865

  QUERY_CHECK_NULL(p, code, lino, _end, terrno);

×

2866

  bool hasUnqualified = false;

×

2868

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

×

2869

  SColumnInfoData* pColPk = taosArrayGet(pBlock->pDataBlock, 1);

×

2871

  qDebug("doBlockDataWindowFilter primary key, ts:%" PRId64 " %" PRId64, offset->ts, offset->primaryKey.val);

×

2872

  QUERY_CHECK_CONDITION((pColPk->info.type == offset->primaryKey.type), code, lino, _end,

×

2875

  __compar_fn_t func = getComparFunc(pColPk->info.type, 0);

×

2876

  QUERY_CHECK_NULL(func, code, lino, _end, terrno);

×

2877

  for (int32_t i = 0; i < pBlock->info.rows; ++i) {

×

2878

    int64_t* ts = (int64_t*)colDataGetData(pColTs, i);

×

2879

    void*    data = colDataGetData(pColPk, i);

×

2880

    if (IS_VAR_DATA_TYPE(pColPk->info.type)) {

×

2881

      void* tmq = taosMemoryMalloc(offset->primaryKey.nData + VARSTR_HEADER_SIZE);

×

2882

      QUERY_CHECK_NULL(tmq, code, lino, _end, terrno);

×

2883

      memcpy(varDataVal(tmq), offset->primaryKey.pData, offset->primaryKey.nData);

×

2884

      varDataLen(tmq) = offset->primaryKey.nData;

×

2885

      p[i] = (*ts > offset->ts) || (func(data, tmq) > 0);

×

2886

      taosMemoryFree(tmq);

×

2888

      p[i] = (*ts > offset->ts) || (func(data, &offset->primaryKey.val) > 0);

×

2891

    if (!p[i]) {

×

2892

      hasUnqualified = true;

×

2896

  if (hasUnqualified) {

×

2897

    code = trimDataBlock(pBlock, pBlock->info.rows, p);

×

2898

    QUERY_CHECK_CODE(code, lino, _end);

×

2901

_end:

×

2902

  taosMemoryFree(p);

×

2903

  if (code != TSDB_CODE_SUCCESS) {

×

2904

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

2906

  return code;

×

2910

static int32_t rebuildDeleteBlockData(SSDataBlock* pBlock, STimeWindow* pWindow, const char* id) {

×

2911

  int32_t code = TSDB_CODE_SUCCESS;

×

2912

  int32_t lino = 0;

×

2913

  int32_t numOfRows = pBlock->info.rows;

×

2914

  bool*   p = taosMemoryCalloc(numOfRows, sizeof(bool));

×

2915

  QUERY_CHECK_NULL(p, code, lino, _end, terrno);

×

2917

  bool    hasUnqualified = false;

×

2918

  int64_t skey = pWindow->skey;

×

2919

  int64_t ekey = pWindow->ekey;

×

2921

  SColumnInfoData* pSrcStartCol = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX);

×

2922

  uint64_t*        tsStartCol = (uint64_t*)pSrcStartCol->pData;

×

2923

  SColumnInfoData* pSrcEndCol = taosArrayGet(pBlock->pDataBlock, END_TS_COLUMN_INDEX);

×

2924

  uint64_t*        tsEndCol = (uint64_t*)pSrcEndCol->pData;

×

2926

  if (pWindow->skey != INT64_MIN) {

×

2927

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

×

2928

      if (tsStartCol[i] < skey) {

×

2929

        tsStartCol[i] = skey;

×

2932

      if (tsEndCol[i] >= skey) {

×

2933

        p[i] = true;

×

2935

        hasUnqualified = true;

×

2938

  } else if (pWindow->ekey != INT64_MAX) {

×

2939

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

×

2940

      if (tsEndCol[i] > ekey) {

×

2941

        tsEndCol[i] = ekey;

×

2944

      if (tsStartCol[i] <= ekey) {

×

2945

        p[i] = true;

×

2947

        hasUnqualified = true;

×

2952

  if (hasUnqualified) {

×

2953

    code = trimDataBlock(pBlock, pBlock->info.rows, p);

×

2954

    qDebug("%s re-build delete datablock, start key revised to:%" PRId64 ", rows:%" PRId64, id, skey,

×

2956

    QUERY_CHECK_CODE(code, lino, _end);

×

2958

    qDebug("%s not update the delete block", id);

×

2961

_end:

×

2962

  taosMemoryFree(p);

×

2963

  if (code != TSDB_CODE_SUCCESS) {

×

2964

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

2966

  return code;

×

2969

static int32_t colIdComparFn(const void* param1, const void* param2) {

×

2970

  int32_t p1 = *(int32_t*)param1;

×

2971

  int32_t p2 = *(int32_t*)param2;

×

2973

  if (p1 == p2) {

×

2974

    return 0;

×

2976

    return (p1 < p2) ? -1 : 1;

×

2980

static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock, STimeWindow* pTimeWindow,

×

2982

  int32_t         code = TSDB_CODE_SUCCESS;

×

2983

  int32_t         lino = 0;

×

2984

  SDataBlockInfo* pBlockInfo = &pInfo->pRes->info;

×

2985

  SOperatorInfo*  pOperator = pInfo->pStreamScanOp;

×

2986

  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;

×

2987

  const char*     id = GET_TASKID(pTaskInfo);

×

2989

  code = blockDataEnsureCapacity(pInfo->pRes, pBlock->info.rows);

×

2990

  QUERY_CHECK_CODE(code, lino, _end);

×

2992

  pBlockInfo->rows = pBlock->info.rows;

×

2993

  pBlockInfo->id.uid = pBlock->info.id.uid;

×

2994

  pBlockInfo->type = STREAM_NORMAL;

×

2995

  pBlockInfo->version = pBlock->info.version;

×

2997

  STableScanInfo* pTableScanInfo = pInfo->pTableScanOp->info;

×

2998

  pBlockInfo->id.groupId = tableListGetTableGroupId(pTableScanInfo->base.pTableListInfo, pBlock->info.id.uid);

×

3000

  SArray* pColList = taosArrayInit(4, sizeof(int32_t));

×

3001

  QUERY_CHECK_NULL(pColList, code, lino, _end, terrno);

×

3004

  for (int32_t i = 0; i < taosArrayGetSize(pInfo->matchInfo.pList); ++i) {

×

3005

    SColMatchItem* pColMatchInfo = taosArrayGet(pInfo->matchInfo.pList, i);

×

3006

    if (!pColMatchInfo->needOutput) {

×

3007

      continue;

×

3010

    bool colExists = false;

×

3011

    for (int32_t j = 0; j < blockDataGetNumOfCols(pBlock); ++j) {

×

3012

      SColumnInfoData* pResCol = NULL;

×

3013

      code = bdGetColumnInfoData(pBlock, j, &pResCol);

×

3014

      QUERY_CHECK_CODE(code, lino, _end);

×

3016

      if (pResCol->info.colId == pColMatchInfo->colId) {

×

3017

        SColumnInfoData* pDst = taosArrayGet(pInfo->pRes->pDataBlock, pColMatchInfo->dstSlotId);

×

3018

        code = colDataAssign(pDst, pResCol, pBlock->info.rows, &pInfo->pRes->info);

×

3019

        QUERY_CHECK_CODE(code, lino, _end);

×

3021

        colExists = true;

×

3022

        void* tmp = taosArrayPush(pColList, &pColMatchInfo->dstSlotId);

×

3023

        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

×

3024

        break;

×

3029

    if (!colExists) {

×

3030

      SColumnInfoData* pDst = taosArrayGet(pInfo->pRes->pDataBlock, pColMatchInfo->dstSlotId);

×

3031

      colDataSetNNULL(pDst, 0, pBlockInfo->rows);

×

3032

      void* tmp = taosArrayPush(pColList, &pColMatchInfo->dstSlotId);

×

3033

      QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

×

3038

  if (pInfo->numOfPseudoExpr > 0) {

×

3039

    code = addTagPseudoColumnData(&pInfo->readHandle, pInfo->pPseudoExpr, pInfo->numOfPseudoExpr, pInfo->pRes,

×

3040

                                  pBlockInfo->rows, pTaskInfo, &pTableScanInfo->base.metaCache);

×

3042

    if (code) {

×

3043

      QUERY_CHECK_CODE(code, lino, _end);

×

3047

    terrno = 0;

×

3049

    for (int32_t i = 0; i < pInfo->numOfPseudoExpr; ++i) {

×

3050

      void* tmp = taosArrayPush(pColList, &pInfo->pPseudoExpr[i].base.resSchema.slotId);

×

3051

      QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

×

3055

  taosArraySort(pColList, colIdComparFn);

×

3057

  int32_t i = 0, j = 0;

×

3058

  while (i < taosArrayGetSize(pColList)) {

×

3059

    int32_t slot1 = *(int32_t*)taosArrayGet(pColList, i);

×

3060

    if (slot1 > j) {

×

3061

      SColumnInfoData* pDst = taosArrayGet(pInfo->pRes->pDataBlock, j);

×

3062

      colDataSetNNULL(pDst, 0, pBlockInfo->rows);

×

3063

      j += 1;

×

3065

      i += 1;

×

3066

      j += 1;

×

3070

  while (j < taosArrayGetSize(pInfo->pRes->pDataBlock)) {

×

3071

    SColumnInfoData* pDst = taosArrayGet(pInfo->pRes->pDataBlock, j);

×

3072

    colDataSetNNULL(pDst, 0, pBlockInfo->rows);

×

3073

    j += 1;

×

3076

  taosArrayDestroy(pColList);

×

3078

  if (filter) {

×

3079

    code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);

×

3080

    QUERY_CHECK_CODE(code, lino, _end);

×

3084

  code = doBlockDataWindowFilter(pInfo->pRes, pInfo->primaryTsIndex, pTimeWindow, id);

×

3085

  QUERY_CHECK_CODE(code, lino, _end);

×

3086

  pInfo->pRes->info.dataLoad = 1;

×

3088

  code = blockDataUpdateTsWindow(pInfo->pRes, pInfo->primaryTsIndex);

×

3089

  QUERY_CHECK_CODE(code, lino, _end);

×

3090

  if (pInfo->pRes->info.rows == 0) {

×

3091

    return 0;

×

3094

  code = calBlockTbName(pInfo, pInfo->pRes, 0);

×

3095

  QUERY_CHECK_CODE(code, lino, _end);

×

3097

_end:

×

3098

  if (code != TSDB_CODE_SUCCESS) {

×

3099

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

3101

  return code;

×

3104

static int32_t processPrimaryKey(SSDataBlock* pBlock, bool hasPrimaryKey, STqOffsetVal* offset) {

×

3105

  int32_t code = TSDB_CODE_SUCCESS;

×

3106

  int32_t lino = 0;

×

3107

  SValue  val = {0};

×

3108

  if (hasPrimaryKey) {

×

3109

    code = doBlockDataPrimaryKeyFilter(pBlock, offset);

×

3110

    if (code != TSDB_CODE_SUCCESS) {

×

3111

      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));

×

3112

      return code;

×

3114

    SColumnInfoData* pColPk = taosArrayGet(pBlock->pDataBlock, 1);

×

3116

    if (pBlock->info.rows < 1) {

×

3117

      return code;

×

3119

    void* tmp = colDataGetData(pColPk, pBlock->info.rows - 1);

×

3120

    val.type = pColPk->info.type;

×

3121

    if (IS_VAR_DATA_TYPE(pColPk->info.type)) {

×

3122

      val.pData = taosMemoryMalloc(varDataLen(tmp));

×

3123

      QUERY_CHECK_NULL(val.pData, code, lino, _end, terrno);

×

3124

      val.nData = varDataLen(tmp);

×

3125

      memcpy(val.pData, varDataVal(tmp), varDataLen(tmp));

×

3127

      memcpy(&val.val, tmp, pColPk->info.bytes);

×

3130

  tqOffsetResetToData(offset, pBlock->info.id.uid, pBlock->info.window.ekey, val);

×

3132

_end:

×

3133

  if (code != TSDB_CODE_SUCCESS) {

×

3134

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

3136

  return code;

×

3139

static int32_t doQueueScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

×

3140

  int32_t        code = TSDB_CODE_SUCCESS;

×

3141

  int32_t        lino = 0;

×

3142

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

×

3143

  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;

×

3145

  SStreamScanInfo* pInfo = pOperator->info;

×

3146

  const char*      id = GET_TASKID(pTaskInfo);

×

3148

  qDebug("start to exec queue scan, %s", id);

×

3150

  if (isTaskKilled(pTaskInfo)) {

×

3151

    (*ppRes) = NULL;

×

3152

    return pTaskInfo->code;

×

3155

  if (pTaskInfo->streamInfo.currentOffset.type == TMQ_OFFSET__SNAPSHOT_DATA) {

×

3156

    while (1) {

×

3157

      SSDataBlock* pResult = NULL;

×

3158

      code = doTableScanNext(pInfo->pTableScanOp, &pResult);

×

3159

      QUERY_CHECK_CODE(code, lino, _end);

×

3161

      if (pResult && pResult->info.rows > 0) {

×

3162

        bool hasPrimaryKey = pAPI->tqReaderFn.tqGetTablePrimaryKey(pInfo->tqReader);

×

3163

        code = processPrimaryKey(pResult, hasPrimaryKey, &pTaskInfo->streamInfo.currentOffset);

×

3164

        QUERY_CHECK_CODE(code, lino, _end);

×

3165

        qDebug("tmqsnap doQueueScan get data utid:%" PRId64 "", pResult->info.id.uid);

×

3166

        if (pResult->info.rows > 0) {

×

3167

          (*ppRes) = pResult;

×

3168

          return code;

×

3175

    STableScanInfo* pTSInfo = pInfo->pTableScanOp->info;

×

3176

    pAPI->tsdReader.tsdReaderClose(pTSInfo->base.dataReader);

×

3178

    pTSInfo->base.dataReader = NULL;

×

3179

    int64_t validVer = pTaskInfo->streamInfo.snapshotVer + 1;

×

3180

    qDebug("queue scan tsdb over, switch to wal ver %" PRId64 "", validVer);

×

3181

    if (pAPI->tqReaderFn.tqReaderSeek(pInfo->tqReader, validVer, pTaskInfo->id.str) < 0) {

×

3182

      (*ppRes) = NULL;

×

3183

      return code;

×

3186

    tqOffsetResetToLog(&pTaskInfo->streamInfo.currentOffset, validVer);

×

3189

  if (pTaskInfo->streamInfo.currentOffset.type == TMQ_OFFSET__LOG) {

×

3190

    while (1) {

×

3192

          pAPI->tqReaderFn.tqReaderNextBlockInWal(pInfo->tqReader, id, pTaskInfo->streamInfo.sourceExcluded);

×

3194

      SSDataBlock*       pRes = pAPI->tqReaderFn.tqGetResultBlock(pInfo->tqReader);

×

3195

      struct SWalReader* pWalReader = pAPI->tqReaderFn.tqReaderGetWalReader(pInfo->tqReader);

×

3198

      tqOffsetResetToLog(&pTaskInfo->streamInfo.currentOffset, pWalReader->curVersion);

×

3201

      pTaskInfo->streamInfo.currentOffset.ts = pAPI->tqReaderFn.tqGetResultBlockTime(pInfo->tqReader);

×

3203

      if (hasResult) {

×

3204

        qDebug("doQueueScan get data from log %" PRId64 " rows, version:%" PRId64, pRes->info.rows,

×

3206

        blockDataCleanup(pInfo->pRes);

×

3207

        STimeWindow defaultWindow = {.skey = INT64_MIN, .ekey = INT64_MAX};

×

3208

        code = setBlockIntoRes(pInfo, pRes, &defaultWindow, true);

×

3209

        QUERY_CHECK_CODE(code, lino, _end);

×

3210

        qDebug("doQueueScan after filter get data from log %" PRId64 " rows, version:%" PRId64, pInfo->pRes->info.rows,

×

3212

        if (pInfo->pRes->info.rows > 0) {

×

3213

          (*ppRes) = pInfo->pRes;

×

3214

          return code;

×

3217

        qDebug("doQueueScan get none from log, return, version:%" PRId64, pTaskInfo->streamInfo.currentOffset.version);

×

3218

        (*ppRes) = NULL;

×

3219

        return code;

×

3223

    qError("unexpected streamInfo prepare type: %d", pTaskInfo->streamInfo.currentOffset.type);

×

3224

    (*ppRes) = NULL;

×

3225

    return code;

×

3228

_end:

×

3229

  if (code != TSDB_CODE_SUCCESS) {

×

3230

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

3231

    pTaskInfo->code = code;

×

3232

    T_LONG_JMP(pTaskInfo->env, code);

×

3234

  (*ppRes) = NULL;

×

3235

  return code;

×

3238

static SSDataBlock* doQueueScan(SOperatorInfo* pOperator) {

×

3239

  SSDataBlock* pRes = NULL;

×

3240

  int32_t      code = doQueueScanNext(pOperator, &pRes);

×

3241

  return pRes;

×

3244

static int32_t filterDelBlockByUid(SSDataBlock* pDst, const SSDataBlock* pSrc, SStreamScanInfo* pInfo) {

×

3245

  int32_t    code = TSDB_CODE_SUCCESS;

×

3246

  int32_t    lino = 0;

×

3247

  STqReader* pReader = pInfo->tqReader;

×

3248

  int32_t    rows = pSrc->info.rows;

×

3249

  code = blockDataEnsureCapacity(pDst, rows);

×

3250

  QUERY_CHECK_CODE(code, lino, _end);

×

3252

  SColumnInfoData* pSrcStartCol = taosArrayGet(pSrc->pDataBlock, START_TS_COLUMN_INDEX);

×

3253

  uint64_t*        startCol = (uint64_t*)pSrcStartCol->pData;

×

3254

  SColumnInfoData* pSrcEndCol = taosArrayGet(pSrc->pDataBlock, END_TS_COLUMN_INDEX);

×

3255

  uint64_t*        endCol = (uint64_t*)pSrcEndCol->pData;

×

3256

  SColumnInfoData* pSrcUidCol = taosArrayGet(pSrc->pDataBlock, UID_COLUMN_INDEX);

×

3257

  uint64_t*        uidCol = (uint64_t*)pSrcUidCol->pData;

×

3259

  SColumnInfoData* pDstStartCol = taosArrayGet(pDst->pDataBlock, START_TS_COLUMN_INDEX);

×

3260

  SColumnInfoData* pDstEndCol = taosArrayGet(pDst->pDataBlock, END_TS_COLUMN_INDEX);

×

3261

  SColumnInfoData* pDstUidCol = taosArrayGet(pDst->pDataBlock, UID_COLUMN_INDEX);

×

3263

  int32_t j = 0;

×

3264

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

×

3265

    if (pInfo->readerFn.tqReaderIsQueriedTable(pReader, uidCol[i])) {

×

3266

      code = colDataSetVal(pDstStartCol, j, (const char*)&startCol[i], false);

×

3267

      QUERY_CHECK_CODE(code, lino, _end);

×

3269

      code = colDataSetVal(pDstEndCol, j, (const char*)&endCol[i], false);

×

3270

      QUERY_CHECK_CODE(code, lino, _end);

×

3272

      code = colDataSetVal(pDstUidCol, j, (const char*)&uidCol[i], false);

×

3273

      QUERY_CHECK_CODE(code, lino, _end);

×

3275

      colDataSetNULL(taosArrayGet(pDst->pDataBlock, GROUPID_COLUMN_INDEX), j);

×

3276

      colDataSetNULL(taosArrayGet(pDst->pDataBlock, CALCULATE_START_TS_COLUMN_INDEX), j);

×

3277

      colDataSetNULL(taosArrayGet(pDst->pDataBlock, CALCULATE_END_TS_COLUMN_INDEX), j);

×

3278

      colDataSetNULL(taosArrayGet(pDst->pDataBlock, TABLE_NAME_COLUMN_INDEX), j);

×

3279

      j++;

×

3283

  uint32_t cap = pDst->info.capacity;

×

3284

  pDst->info = pSrc->info;

×

3285

  pDst->info.rows = j;

×

3286

  pDst->info.capacity = cap;

×

3288

_end:

×

3289

  if (code != TSDB_CODE_SUCCESS) {

×

3290

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

3292

  return code;

×

3296

static int32_t setBlockGroupIdByUid(SStreamScanInfo* pInfo, SSDataBlock* pBlock) {

×

3297

  int32_t          code = TSDB_CODE_SUCCESS;

×

3298

  int32_t          lino = 0;

×

3299

  SColumnInfoData* pStartTsCol = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX);

×

3300

  TSKEY*           startTsCol = (TSKEY*)pStartTsCol->pData;

×

3301

  SColumnInfoData* pGpCol = taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX);

×

3302

  uint64_t*        gpCol = (uint64_t*)pGpCol->pData;

×

3303

  SColumnInfoData* pUidCol = taosArrayGet(pBlock->pDataBlock, UID_COLUMN_INDEX);

×

3304

  uint64_t*        uidCol = (uint64_t*)pUidCol->pData;

×

3305

  int32_t          rows = pBlock->info.rows;

×

3306

  if (!pInfo->partitionSup.needCalc) {

×

3307

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

×

3308

      uint64_t groupId = getGroupIdByUid(pInfo, uidCol[i]);

×

3309

      code = colDataSetVal(pGpCol, i, (const char*)&groupId, false);

×

3310

      QUERY_CHECK_CODE(code, lino, _end);

×

3314

_end:

×

3315

  if (code != TSDB_CODE_SUCCESS) {

×

3316

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

3318

  return code;

×

3321

static int32_t doCheckUpdate(SStreamScanInfo* pInfo, TSKEY endKey, SSDataBlock* pBlock) {

×

3322

  int32_t code = TSDB_CODE_SUCCESS;

×

3323

  int32_t lino = 0;

×

3324

  if (pInfo->pUpdateInfo) {

×

3325

    pInfo->pUpdateInfo->maxDataVersion = TMAX(pInfo->pUpdateInfo->maxDataVersion, pBlock->info.version);

×

3327

  if (!pInfo->igCheckUpdate && pInfo->pUpdateInfo) {

×

3328

    code = checkUpdateData(pInfo, true, pBlock, true);

×

3329

    QUERY_CHECK_CODE(code, lino, _end);

×

3330

    pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, endKey);

×

3331

    if (pInfo->pUpdateDataRes->info.rows > 0) {

×

3332

      pInfo->updateResIndex = 0;

×

3333

      if (pInfo->pUpdateDataRes->info.type == STREAM_CLEAR) {

×

3334

        pInfo->scanMode = STREAM_SCAN_FROM_UPDATERES;

×

3335

      } else if (pInfo->pUpdateDataRes->info.type == STREAM_INVERT) {

×

3336

        pInfo->scanMode = STREAM_SCAN_FROM_RES;

×

3338

      } else if (pInfo->pUpdateDataRes->info.type == STREAM_DELETE_DATA) {

×

3339

        pInfo->scanMode = STREAM_SCAN_FROM_DELETE_DATA;

×

3344

_end:

×

3345

  if (code != TSDB_CODE_SUCCESS) {

×

3346

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

3348

  return code;

×

3351

int32_t streamScanOperatorEncode(SStreamScanInfo* pInfo, void** pBuff, int32_t* pLen) {

×

3352

  int32_t   code = TSDB_CODE_SUCCESS;

×

3353

  int32_t   lino = 0;

×

3354

  int32_t   len = 0;

×

3355

  SEncoder* pEnCoder = NULL;

×

3356

  SEncoder* pScanEnCoder = NULL;

×

3358

  len += encodeSTimeWindowAggSupp(NULL, &pInfo->twAggSup);

×

3359

  SEncoder encoder = {0};

×

3360

  pEnCoder = &encoder;

×

3361

  tEncoderInit(pEnCoder, NULL, 0);

×

3362

  if (tStartEncode(pEnCoder) != 0) {

×

3363

    code = TSDB_CODE_STREAM_INTERNAL_ERROR;

×

3364

    QUERY_CHECK_CODE(code, lino, _end);

×

3366

  code = pInfo->stateStore.updateInfoSerialize(pEnCoder, pInfo->pUpdateInfo);

×

3367

  QUERY_CHECK_CODE(code, lino, _end);

×

3369

  if (tEncodeI64(pEnCoder, pInfo->lastScanRange.skey) < 0) {

×

3370

    code = TSDB_CODE_STREAM_INTERNAL_ERROR;

×

3371

    QUERY_CHECK_CODE(code, lino, _end);

×

3373

  if (tEncodeI64(pEnCoder, pInfo->lastScanRange.ekey) < 0) {

×

3374

    code = TSDB_CODE_STREAM_INTERNAL_ERROR;

×

3375

    QUERY_CHECK_CODE(code, lino, _end);

×

3378

  tEndEncode(pEnCoder);

×

3379

  len += encoder.pos;

×

3380

  tEncoderClear(pEnCoder);

×

3381

  pEnCoder = NULL;

×

3383

  *pBuff = taosMemoryCalloc(1, len);

×

3384

  if (!(*pBuff)) {

×

3385

    code = terrno;

×

3386

    QUERY_CHECK_CODE(code, lino, _end);

×

3388

  void* buf = *pBuff;

×

3389

  int32_t stwLen = encodeSTimeWindowAggSupp(&buf, &pInfo->twAggSup);

×

3391

  SEncoder scanEncoder = {0};

×

3392

  pScanEnCoder = &scanEncoder;

×

3393

  tEncoderInit(pScanEnCoder, buf, len - stwLen);

×

3394

  if (tStartEncode(pScanEnCoder) != 0) {

×

3395

    code = TSDB_CODE_FAILED;

×

3396

    QUERY_CHECK_CODE(code, lino, _end);

×

3398

  code = pInfo->stateStore.updateInfoSerialize(pScanEnCoder, pInfo->pUpdateInfo);

×

3399

  QUERY_CHECK_CODE(code, lino, _end);

×

3401

  if (tEncodeI64(pScanEnCoder, pInfo->lastScanRange.skey) < 0) {

×

3402

    code = TSDB_CODE_STREAM_INTERNAL_ERROR;

×

3403

    QUERY_CHECK_CODE(code, lino, _end);

×

3405

  if (tEncodeI64(pScanEnCoder, pInfo->lastScanRange.ekey) < 0) {

×

3406

    code = TSDB_CODE_STREAM_INTERNAL_ERROR;

×

3407

    QUERY_CHECK_CODE(code, lino, _end);

×

3410

  qDebug("%s last scan range %d. %" PRId64 ",%" PRId64, __func__, __LINE__, pInfo->lastScanRange.skey, pInfo->lastScanRange.ekey);

×

3412

  *pLen = len;

×

3414

_end:

×

3415

  if (code != TSDB_CODE_SUCCESS) {

×

3416

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

3418

  if (pEnCoder != NULL) {

×

3419

    tEndEncode(pEnCoder);

×

3420

    tEncoderClear(pEnCoder);

×

3422

  if (pScanEnCoder != NULL) {

×

3423

    tEndEncode(pScanEnCoder);

×

3424

    tEncoderClear(pScanEnCoder);

×

3426

  return code;

×

3429

void streamScanOperatorSaveCheckpoint(SStreamScanInfo* pInfo) {

×

3430

  int32_t code = TSDB_CODE_SUCCESS;

×

3431

  int32_t lino = 0;

×

3432

  if (!pInfo->pState) {

×

3433

    return;

×

3435

  if (needSaveStreamOperatorInfo(&pInfo->basic)) {

×

3436

    void*   pBuf = NULL;

×

3437

    int32_t len = 0;

×

3438

    code = streamScanOperatorEncode(pInfo, &pBuf, &len);

×

3439

    QUERY_CHECK_CODE(code, lino, _end);

×

3440

    pInfo->stateStore.streamStateSaveInfo(pInfo->pState, STREAM_SCAN_OP_CHECKPOINT_NAME,

×

3442

    taosMemoryFree(pBuf);

×

3443

    saveStreamOperatorStateComplete(&pInfo->basic);

×

3446

_end:

×

3447

  if (code != TSDB_CODE_SUCCESS) {

×

3448

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

3453

void streamScanOperatorDecode(void* pBuff, int32_t len, SStreamScanInfo* pInfo) {

×

3454

  int32_t   code = TSDB_CODE_SUCCESS;

×

3455

  int32_t   lino = 0;

×

3456

  SDecoder* pDeCoder = NULL;

×

3457

  if (!pBuff || len == 0) {

×

3458

    lino = __LINE__;

×

3459

    goto _end;

×

3461

  void* buf = pBuff;

×

3462

  buf = decodeSTimeWindowAggSupp(buf, &pInfo->twAggSup);

×

3463

  int32_t tlen = len - encodeSTimeWindowAggSupp(NULL, &pInfo->twAggSup);

×

3464

  if (tlen == 0) {

×

3465

    lino = __LINE__;

×

3466

    goto _end;

×

3469

  SDecoder decoder = {0};

×

3470

  pDeCoder = &decoder;

×

3471

  tDecoderInit(pDeCoder, buf, tlen);

×

3472

  if (tStartDecode(pDeCoder) < 0) {

×

3473

    lino = __LINE__;

×

3474

    goto _end;

×

3477

  void* pUpInfo = taosMemoryCalloc(1, sizeof(SUpdateInfo));

×

3478

  if (!pUpInfo) {

×

3479

    lino = __LINE__;

×

3480

    goto _end;

×

3482

  code = pInfo->stateStore.updateInfoDeserialize(pDeCoder, pUpInfo);

×

3483

  if (code == TSDB_CODE_SUCCESS) {

×

3484

    pInfo->stateStore.updateInfoDestroy(pInfo->pUpdateInfo);

×

3485

    pInfo->pUpdateInfo = pUpInfo;

×

3486

    qDebug("%s line:%d. stream scan updateinfo deserialize success", __func__, __LINE__);

×

3488

    taosMemoryFree(pUpInfo);

×

3489

    code = TSDB_CODE_SUCCESS;

×

3490

    qDebug("%s line:%d. stream scan did not have updateinfo", __func__, __LINE__);

×

3493

  if (tDecodeIsEnd(pDeCoder)) {

×

3494

    lino = __LINE__;

×

3495

    goto _end;

×

3498

  SET_WIN_KEY_INVALID(pInfo->lastScanRange.skey);

×

3499

  SET_WIN_KEY_INVALID(pInfo->lastScanRange.ekey);

×

3501

  if (tDecodeI64(pDeCoder, &pInfo->lastScanRange.skey) < 0) {

×

3502

    lino = __LINE__;

×

3503

    goto _end;

×

3506

  if (tDecodeI64(pDeCoder, &pInfo->lastScanRange.ekey) < 0) {

×

3507

    lino = __LINE__;

×

3508

    goto _end;

×

3510

  qDebug("%s last scan range %d. %" PRId64 ",%" PRId64, __func__, __LINE__, pInfo->lastScanRange.skey, pInfo->lastScanRange.ekey);

×

3512

_end:

×

3513

  if (pDeCoder != NULL) {

×

3514

    tEndDecode(pDeCoder);

×

3515

    tDecoderClear(pDeCoder);

×

3517

  qInfo("%s end at line %d", __func__, lino);

×

3518

×

3520

static bool hasScanRange(SStreamScanInfo* pInfo) {

×

3521

  SStreamAggSupporter* pSup = pInfo->windowSup.pStreamAggSup;

×

3522

  return pSup && pSup->pScanBlock->info.rows > 0 && (isStateWindow(pInfo) || isCountWindow(pInfo));

×

3525

static bool isStreamWindow(SStreamScanInfo* pInfo) {

×

3526

  return isIntervalWindow(pInfo) || isSessionWindow(pInfo) || isStateWindow(pInfo) || isCountWindow(pInfo) ||

×

3527

         isTimeSlice(pInfo);

×

3530

static int32_t copyGetResultBlock(SSDataBlock* dest, TSKEY start, TSKEY end) {

×

3531

  int32_t code = blockDataEnsureCapacity(dest, 1);

×

3532

  if (code != TSDB_CODE_SUCCESS) {

×

3533

    return code;

×

3535

  return appendDataToSpecialBlock(dest, &start, &end, NULL, NULL, NULL);

×

3538

static int32_t deletePartName(SStreamScanInfo* pInfo, SSDataBlock* pBlock, int32_t *deleteNum) {

×

3539

  int32_t code = TSDB_CODE_SUCCESS;

×

3540

  int32_t lino = 0;

×

3541

  for (int32_t i = 0; i < pBlock->info.rows; i++) {

×

3543

    SColumnInfoData* pGpIdCol = taosArrayGet(pBlock->pDataBlock, UID_COLUMN_INDEX);

×

3544

    SColumnInfoData* pTbnameCol = taosArrayGet(pBlock->pDataBlock, TABLE_NAME_COLUMN_INDEX);

×

3545

    int64_t*         gpIdCol = (int64_t*)pGpIdCol->pData;

×

3546

    void*            pParName = NULL;

×

3547

    int32_t          winCode = 0;

×

3548

    code = pInfo->stateStore.streamStateGetParName(pInfo->pStreamScanOp->pTaskInfo->streamInfo.pState, gpIdCol[i],

×

3550

    if (TSDB_CODE_SUCCESS == code && winCode != 0) {

×

3551

      qDebug("delete stream part Name for:%"PRId64 " not found", gpIdCol[i]);

×

3552

      colDataSetNULL(pTbnameCol, i);

×

3553

      continue;

×

3555

    (*deleteNum)++;

×

3556

    QUERY_CHECK_CODE(code, lino, _end);

×

3557

    char varTbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE + 1] = {0};

×

3558

    varDataSetLen(varTbName, strlen(pParName));

×

3559

    int64_t len = tsnprintf(varTbName + VARSTR_HEADER_SIZE, TSDB_TABLE_NAME_LEN + 1, "%s", pParName);

×

3560

    code = colDataSetVal(pTbnameCol, i, varTbName, false);

×

3561

    qDebug("delete stream part for:%"PRId64 " res tb: %s", gpIdCol[i], (char*)pParName);

×

3562

    pInfo->stateStore.streamStateFreeVal(pParName);

×

3563

    QUERY_CHECK_CODE(code, lino, _end);

×

3564

    code = pInfo->stateStore.streamStateDeleteParName(pInfo->pStreamScanOp->pTaskInfo->streamInfo.pState, gpIdCol[i]);

×

3565

    QUERY_CHECK_CODE(code, lino, _end);

×

3566

    pBlock->info.id.groupId = gpIdCol[i];

×

3568

    memcpy(pBlock->info.parTbName, varTbName + VARSTR_HEADER_SIZE, TSDB_TABLE_NAME_LEN + 1);

×

3571

_end:

×

3572

  if (code != TSDB_CODE_SUCCESS) {

×

3573

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

3575

  return code;

×

3578

static int32_t doStreamScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

×

3580

  int32_t        code = TSDB_CODE_SUCCESS;

×

3581

  int32_t        lino = 0;

×

3582

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

×

3583

  const char*    id = GET_TASKID(pTaskInfo);

×

3585

  SStorageAPI*     pAPI = &pTaskInfo->storageAPI;

×

3586

  SStreamScanInfo* pInfo = pOperator->info;

×

3587

  SStreamTaskInfo* pStreamInfo = &pTaskInfo->streamInfo;

×

3589

  qDebug("stream scan started, %s", id);

×

3591

  if (pStreamInfo->recoverStep == STREAM_RECOVER_STEP__PREPARE1 ||

×

3592

      pStreamInfo->recoverStep == STREAM_RECOVER_STEP__PREPARE2) {

×

3593

    STableScanInfo* pTSInfo = pInfo->pTableScanOp->info;

×

3594

    memcpy(&pTSInfo->base.cond, &pStreamInfo->tableCond, sizeof(SQueryTableDataCond));

×

3596

    if (pStreamInfo->recoverStep == STREAM_RECOVER_STEP__PREPARE1) {

×

3597

      pTSInfo->base.cond.startVersion = pStreamInfo->fillHistoryVer.minVer;

×

3598

      pTSInfo->base.cond.endVersion = pStreamInfo->fillHistoryVer.maxVer;

×

3600

      pTSInfo->base.cond.twindows = pStreamInfo->fillHistoryWindow;

×

3601

      qDebug("stream scan step1, verRange:%" PRId64 "-%" PRId64 " window:%" PRId64 "-%" PRId64 ", %s",

×

3604

      pStreamInfo->recoverStep = STREAM_RECOVER_STEP__SCAN1;

×

3605

      pStreamInfo->recoverScanFinished = false;

×

3607

      pTSInfo->base.cond.startVersion = pStreamInfo->fillHistoryVer.minVer;

×

3608

      pTSInfo->base.cond.endVersion = pStreamInfo->fillHistoryVer.maxVer;

×

3609

      pTSInfo->base.cond.twindows = pStreamInfo->fillHistoryWindow;

×

3610

      qDebug("stream scan step2 (scan wal), verRange:%" PRId64 " - %" PRId64 ", window:%" PRId64 "-%" PRId64 ", %s",

×

3613

      pStreamInfo->recoverStep = STREAM_RECOVER_STEP__NONE;

×

3616

    pAPI->tsdReader.tsdReaderClose(pTSInfo->base.dataReader);

×

3618

    pTSInfo->base.dataReader = NULL;

×

3619

    pInfo->pTableScanOp->status = OP_OPENED;

×

3621

    pTSInfo->scanTimes = 0;

×

3622

    pTSInfo->currentGroupId = -1;

×

3625

  if (pStreamInfo->recoverStep == STREAM_RECOVER_STEP__SCAN1) {

×

3626

    if (isTaskKilled(pTaskInfo)) {

×

3627

      qInfo("===stream===stream scan is killed. task id:%s, code %s", id, tstrerror(pTaskInfo->code));

×

3628

      (*ppRes) = NULL;

×

3629

      return code;

×

3632

    switch (pInfo->scanMode) {

×

3633

      case STREAM_SCAN_FROM_RES: {

×

3634

        pInfo->scanMode = STREAM_SCAN_FROM_READERHANDLE;

×

3635

        printSpecDataBlock(pInfo->pRecoverRes, getStreamOpName(pOperator->operatorType), "recover",

×

3636

                           GET_TASKID(pTaskInfo));

×

3637

        (*ppRes) = pInfo->pRecoverRes;

×

3638

        return code;

×

3640

      default:

×

3641

        break;

×

3644

    code = doTableScanNext(pInfo->pTableScanOp, &pInfo->pRecoverRes);

×

3645

    QUERY_CHECK_CODE(code, lino, _end);

×

3647

    if (pInfo->pRecoverRes != NULL) {

×

3648

      code = calBlockTbName(pInfo, pInfo->pRecoverRes, 0);

×

3649

      QUERY_CHECK_CODE(code, lino, _end);

×

3650

      if (!pInfo->igCheckUpdate && pInfo->pUpdateInfo) {

×

3651

        TSKEY maxTs = INT64_MIN;

×

3652

        code = pAPI->stateStore.updateInfoFillBlockData(pInfo->pUpdateInfo, pInfo->pRecoverRes, pInfo->primaryTsIndex,

×

3654

        QUERY_CHECK_CODE(code, lino, _end);

×

3655

        pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, maxTs);

×

3657

      if (pInfo->pCreateTbRes->info.rows > 0) {

×

3658

        pInfo->scanMode = STREAM_SCAN_FROM_RES;

×

3659

        printSpecDataBlock(pInfo->pCreateTbRes, getStreamOpName(pOperator->operatorType), "recover",

×

3660

                           GET_TASKID(pTaskInfo));

×

3661

        (*ppRes) = pInfo->pCreateTbRes;

×

3662

        return code;

×

3665

      qDebug("stream recover scan get block, rows %" PRId64, pInfo->pRecoverRes->info.rows);

×

3666

      printSpecDataBlock(pInfo->pRecoverRes, getStreamOpName(pOperator->operatorType), "recover",

×

3667

                         GET_TASKID(pTaskInfo));

×

3668

      (*ppRes) = pInfo->pRecoverRes;

×

3669

      return code;

×

3671

    pStreamInfo->recoverStep = STREAM_RECOVER_STEP__NONE;

×

3672

    STableScanInfo* pTSInfo = pInfo->pTableScanOp->info;

×

3673

    pAPI->tsdReader.tsdReaderClose(pTSInfo->base.dataReader);

×

3675

    pTSInfo->base.dataReader = NULL;

×

3677

    pTSInfo->base.cond.startVersion = -1;

×

3678

    pTSInfo->base.cond.endVersion = -1;

×

3680

    pStreamInfo->recoverScanFinished = true;

×

3681

    (*ppRes) = NULL;

×

3682

    return code;

×

3685

  size_t total = taosArrayGetSize(pInfo->pBlockLists);

×

3687

FETCH_NEXT_BLOCK:

×

3688

  if (pInfo->blockType == STREAM_INPUT__DATA_BLOCK) {

×

3689

    if (pInfo->validBlockIndex >= total) {

×

3691

      (*ppRes) = NULL;

×

3692

      return code;

×

3695

    int32_t current = pInfo->validBlockIndex++;

×

3696

    qDebug("process %d/%d input data blocks, %s", current, (int32_t)total, id);

×

3698

    SPackedData* pPacked = taosArrayGet(pInfo->pBlockLists, current);

×

3699

    QUERY_CHECK_NULL(pPacked, code, lino, _end, terrno);

×

3701

    SSDataBlock* pBlock = pPacked->pDataBlock;

×

3702

    if (pBlock->info.parTbName[0]) {

×

3704

          pAPI->stateStore.streamStatePutParName(pStreamInfo->pState, pBlock->info.id.groupId, pBlock->info.parTbName);

×

3705

      QUERY_CHECK_CODE(code, lino, _end);

×

3709

    pBlock->info.calWin.skey = INT64_MIN;

×

3710

    pBlock->info.calWin.ekey = INT64_MAX;

×

3711

    pBlock->info.dataLoad = 1;

×

3712

    if (pInfo->pUpdateInfo) {

×

3713

      pInfo->pUpdateInfo->maxDataVersion = TMAX(pInfo->pUpdateInfo->maxDataVersion, pBlock->info.version);

×

3716

    code = blockDataUpdateTsWindow(pBlock, 0);

×

3717

    QUERY_CHECK_CODE(code, lino, _end);

×

3718

    switch (pBlock->info.type) {

×

3719

      case STREAM_NORMAL:

×

3721

        printDataBlock(pBlock, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));

×

3722

        setStreamOperatorState(&pInfo->basic, pBlock->info.type);

×

3723

        (*ppRes) = pBlock;

×

3724

        return code;

×

3725

      case STREAM_RETRIEVE: {

×

3726

        pInfo->blockType = STREAM_INPUT__DATA_SUBMIT;

×

3727

        pInfo->scanMode = STREAM_SCAN_FROM_DATAREADER_RETRIEVE;

×

3728

        code = copyDataBlock(pInfo->pUpdateRes, pBlock);

×

3729

        QUERY_CHECK_CODE(code, lino, _end);

×

3730

        pInfo->updateResIndex = 0;

×

3731

        prepareRangeScan(pInfo, pInfo->pUpdateRes, &pInfo->updateResIndex, NULL);

×

3732

        pAPI->stateStore.updateInfoAddCloseWindowSBF(pInfo->pUpdateInfo);

×

3733

      } break;

×

3734

      case STREAM_DELETE_DATA: {

×

3735

        printSpecDataBlock(pBlock, getStreamOpName(pOperator->operatorType), "delete recv", GET_TASKID(pTaskInfo));

×

3736

        SSDataBlock* pDelBlock = NULL;

×

3737

        if (pInfo->tqReader) {

×

3738

          code = createSpecialDataBlock(STREAM_DELETE_DATA, &pDelBlock);

×

3739

          QUERY_CHECK_CODE(code, lino, _end);

×

3741

          code = filterDelBlockByUid(pDelBlock, pBlock, pInfo);

×

3742

          QUERY_CHECK_CODE(code, lino, _end);

×

3744

          pDelBlock = pBlock;

×

3747

        code = setBlockGroupIdByUid(pInfo, pDelBlock);

×

3748

        QUERY_CHECK_CODE(code, lino, _end);

×

3749

        code = rebuildDeleteBlockData(pDelBlock, &pStreamInfo->fillHistoryWindow, id);

×

3750

        QUERY_CHECK_CODE(code, lino, _end);

×

3751

        printSpecDataBlock(pDelBlock, getStreamOpName(pOperator->operatorType), "delete recv filtered",

×

3752

                           GET_TASKID(pTaskInfo));

×

3753

        if (pDelBlock->info.rows == 0) {

×

3754

          if (pInfo->tqReader) {

×

3755

            blockDataDestroy(pDelBlock);

×

3757

          goto FETCH_NEXT_BLOCK;

×

3760

        if (!isStreamWindow(pInfo)) {

×

3761

          code = generateDeleteResultBlock(pInfo, pDelBlock, pInfo->pDeleteDataRes);

×

3762

          QUERY_CHECK_CODE(code, lino, _end);

×

3763

          if (pInfo->partitionSup.needCalc) {

×

3764

            pInfo->pDeleteDataRes->info.type = STREAM_DELETE_DATA;

×

3766

            pInfo->pDeleteDataRes->info.type = STREAM_DELETE_RESULT;

×

3768

          blockDataDestroy(pDelBlock);

×

3770

          if (pInfo->pDeleteDataRes->info.rows > 0) {

×

3771

            printSpecDataBlock(pInfo->pDeleteDataRes, getStreamOpName(pOperator->operatorType), "delete result",

×

3772

                               GET_TASKID(pTaskInfo));

×

3773

            setStreamOperatorState(&pInfo->basic, pInfo->pDeleteDataRes->info.type);

×

3774

            (*ppRes) = pInfo->pDeleteDataRes;

×

3775

            return code;

×

3777

            goto FETCH_NEXT_BLOCK;

×

3780

          pInfo->blockType = STREAM_INPUT__DATA_SUBMIT;

×

3781

          pInfo->updateResIndex = 0;

×

3782

          code = generateScanRange(pInfo, pDelBlock, pInfo->pUpdateRes, STREAM_DELETE_DATA);

×

3783

          QUERY_CHECK_CODE(code, lino, _end);

×

3784

          prepareRangeScan(pInfo, pInfo->pUpdateRes, &pInfo->updateResIndex, NULL);

×

3785

          code = copyDataBlock(pInfo->pDeleteDataRes, pInfo->pUpdateRes);

×

3786

          QUERY_CHECK_CODE(code, lino, _end);

×

3787

          pInfo->pDeleteDataRes->info.type = STREAM_DELETE_DATA;

×

3788

          if (pInfo->tqReader) {

×

3789

            blockDataDestroy(pDelBlock);

×

3791

          if (pInfo->pDeleteDataRes->info.rows > 0) {

×

3792

            pInfo->scanMode = STREAM_SCAN_FROM_DATAREADER_RANGE;

×

3793

            printSpecDataBlock(pInfo->pDeleteDataRes, getStreamOpName(pOperator->operatorType), "delete result",

×

3794

                               GET_TASKID(pTaskInfo));

×

3795

            setStreamOperatorState(&pInfo->basic, pInfo->pDeleteDataRes->info.type);

×

3796

            (*ppRes) = pInfo->pDeleteDataRes;

×

3797

            return code;

×

3799

            goto FETCH_NEXT_BLOCK;

×

3803

      case STREAM_GET_RESULT: {

×

3804

        pInfo->blockType = STREAM_INPUT__DATA_SUBMIT;

×

3805

        pInfo->updateResIndex = 0;

×

3806

        pInfo->lastScanRange = pBlock->info.window;

×

3807

        TSKEY endKey = taosTimeGetIntervalEnd(pBlock->info.window.skey, &pInfo->interval);

×

3808

        if (pInfo->useGetResultRange == true) {

×

3809

          endKey = pBlock->info.window.ekey;

×

3811

        code = copyGetResultBlock(pInfo->pUpdateRes, pBlock->info.window.skey, endKey);

×

3812

        QUERY_CHECK_CODE(code, lino, _end);

×

3813

        pInfo->pUpdateInfo->maxDataVersion = -1;

×

3814

        prepareRangeScan(pInfo, pInfo->pUpdateRes, &pInfo->updateResIndex, NULL);

×

3815

        pInfo->scanMode = STREAM_SCAN_FROM_DATAREADER_RANGE;

×

3816

      } break;

×

3817

      case STREAM_DROP_CHILD_TABLE: {

×

3818

        int32_t deleteNum = 0;

×

3819

        code = deletePartName(pInfo, pBlock, &deleteNum);

×

3820

        QUERY_CHECK_CODE(code, lino, _end);

×

3821

        if (deleteNum == 0) goto FETCH_NEXT_BLOCK;

×

3822

      } break;

×

3823

      case STREAM_CHECKPOINT: {

×

3824

        qError("stream check point error. msg type: STREAM_INPUT__DATA_BLOCK");

×

3825

      } break;

×

3826

      default:

×

3827

        break;

×

3829

    printSpecDataBlock(pBlock, getStreamOpName(pOperator->operatorType), "block recv", GET_TASKID(pTaskInfo));

×

3830

    setStreamOperatorState(&pInfo->basic, pBlock->info.type);

×

3831

    (*ppRes) = pBlock;

×

3832

    return code;

×

3833

  } else if (pInfo->blockType == STREAM_INPUT__DATA_SUBMIT) {

×

3834

    qDebug("stream scan mode:%d, %s", pInfo->scanMode, id);

×

3835

    switch (pInfo->scanMode) {

×

3836

      case STREAM_SCAN_FROM_RES: {

×

3837

        pInfo->scanMode = STREAM_SCAN_FROM_READERHANDLE;

×

3838

        code = doCheckUpdate(pInfo, pInfo->pRes->info.window.ekey, pInfo->pRes);

×

3839

        QUERY_CHECK_CODE(code, lino, _end);

×

3840

        setStreamOperatorState(&pInfo->basic, pInfo->pRes->info.type);

×

3841

        code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);

×

3842

        QUERY_CHECK_CODE(code, lino, _end);

×

3843

        pInfo->pRes->info.dataLoad = 1;

×

3844

        code = blockDataUpdateTsWindow(pInfo->pRes, pInfo->primaryTsIndex);

×

3845

        QUERY_CHECK_CODE(code, lino, _end);

×

3846

        if (pInfo->pRes->info.rows > 0) {

×

3847

          printDataBlock(pInfo->pRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));

×

3848

          (*ppRes) = pInfo->pRes;

×

3849

          return code;

×

3851

      } break;

×

3852

      case STREAM_SCAN_FROM_DELETE_DATA: {

×

3853

        code = generateScanRange(pInfo, pInfo->pUpdateDataRes, pInfo->pUpdateRes, STREAM_PARTITION_DELETE_DATA);

×

3854

        QUERY_CHECK_CODE(code, lino, _end);

×

3855

        if (pInfo->pUpdateRes->info.rows > 0) {

×

3856

          prepareRangeScan(pInfo, pInfo->pUpdateRes, &pInfo->updateResIndex, NULL);

×

3857

          pInfo->scanMode = STREAM_SCAN_FROM_DATAREADER_RANGE;

×

3858

          code = copyDataBlock(pInfo->pDeleteDataRes, pInfo->pUpdateRes);

×

3859

          QUERY_CHECK_CODE(code, lino, _end);

×

3860

          pInfo->pDeleteDataRes->info.type = STREAM_DELETE_DATA;

×

3861

          (*ppRes) = pInfo->pDeleteDataRes;

×

3862

          return code;

×

3864

        qError("%s===stream=== %s failed at line %d since pInfo->pUpdateRes is empty", GET_TASKID(pTaskInfo), __func__,

×

3866

        blockDataCleanup(pInfo->pUpdateDataRes);

×

3867

        pInfo->scanMode = STREAM_SCAN_FROM_READERHANDLE;

×

3868

      } break;

×

3869

      case STREAM_SCAN_FROM_UPDATERES: {

×

3870

        code = generateScanRange(pInfo, pInfo->pUpdateDataRes, pInfo->pUpdateRes, STREAM_CLEAR);

×

3871

        QUERY_CHECK_CODE(code, lino, _end);

×

3872

        if (pInfo->pUpdateRes->info.rows > 0) {

×

3873

          prepareRangeScan(pInfo, pInfo->pUpdateRes, &pInfo->updateResIndex, NULL);

×

3874

          pInfo->scanMode = STREAM_SCAN_FROM_DATAREADER_RANGE;

×

3875

          (*ppRes) = pInfo->pUpdateRes;

×

3876

          return code;

×

3878

        qError("%s===stream=== %s failed at line %d since pInfo->pUpdateRes is empty", GET_TASKID(pTaskInfo), __func__,

×

3880

        blockDataCleanup(pInfo->pUpdateDataRes);

×

3881

        pInfo->scanMode = STREAM_SCAN_FROM_READERHANDLE;

×

3882

      } break;

×

3883

      case STREAM_SCAN_FROM_DATAREADER_RANGE:

×

3885

        if (pInfo->pRangeScanRes != NULL) {

×

3886

          (*ppRes) = pInfo->pRangeScanRes;

×

3887

          pInfo->pRangeScanRes = NULL;

×

3888

          return code;

×

3890

        SSDataBlock* pSDB = NULL;

×

3891

        code = doRangeScan(pInfo, pInfo->pUpdateRes, pInfo->primaryTsIndex, &pInfo->updateResIndex, &pSDB);

×

3892

        QUERY_CHECK_CODE(code, lino, _end);

×

3893

        if (pSDB) {

×

3894

          STableScanInfo* pTableScanInfo = pInfo->pTableScanOp->info;

×

3895

          pSDB->info.type = pInfo->scanMode == STREAM_SCAN_FROM_DATAREADER_RANGE ? STREAM_NORMAL : STREAM_PULL_DATA;

×

3896

          if (!pInfo->igCheckUpdate && pInfo->pUpdateInfo) {

×

3897

            code = checkUpdateData(pInfo, true, pSDB, false);

×

3898

            QUERY_CHECK_CODE(code, lino, _end);

×

3900

          printSpecDataBlock(pSDB, getStreamOpName(pOperator->operatorType), "update", GET_TASKID(pTaskInfo));

×

3901

          code = calBlockTbName(pInfo, pSDB, 0);

×

3902

          QUERY_CHECK_CODE(code, lino, _end);

×

3904

          if (pInfo->pCreateTbRes->info.rows > 0) {

×

3905

            printSpecDataBlock(pInfo->pCreateTbRes, getStreamOpName(pOperator->operatorType), "update",

×

3906

                               GET_TASKID(pTaskInfo));

×

3907

            (*ppRes) = pInfo->pCreateTbRes;

×

3908

            pInfo->pRangeScanRes = pSDB;

×

3909

            return code;

×

3912

          (*ppRes) = pSDB;

×

3913

          return code;

×

3915

        blockDataCleanup(pInfo->pUpdateDataRes);

×

3916

        pInfo->scanMode = STREAM_SCAN_FROM_READERHANDLE;

×

3917

      } break;

×

3918

      default:

×

3919

        break;

×

3922

    if (hasScanRange(pInfo)) {

×

3923

      pInfo->scanMode = STREAM_SCAN_FROM_DATAREADER_RANGE;

×

3924

      pInfo->updateResIndex = 0;

×

3925

      SStreamAggSupporter* pSup = pInfo->windowSup.pStreamAggSup;

×

3926

      code = copyDataBlock(pInfo->pUpdateRes, pSup->pScanBlock);

×

3927

      QUERY_CHECK_CODE(code, lino, _end);

×

3928

      blockDataCleanup(pSup->pScanBlock);

×

3929

      prepareRangeScan(pInfo, pInfo->pUpdateRes, &pInfo->updateResIndex, NULL);

×

3930

      pInfo->pUpdateRes->info.type = STREAM_DELETE_DATA;

×

3931

      printSpecDataBlock(pInfo->pUpdateRes, getStreamOpName(pOperator->operatorType), "rebuild", GET_TASKID(pTaskInfo));

×

3932

      (*ppRes) = pInfo->pUpdateRes;

×

3933

      return code;

×

3936

    SDataBlockInfo* pBlockInfo = &pInfo->pRes->info;

×

3937

    int32_t         totalBlocks = taosArrayGetSize(pInfo->pBlockLists);

×

3939

  NEXT_SUBMIT_BLK:

×

3941

      if (pInfo->readerFn.tqReaderCurrentBlockConsumed(pInfo->tqReader)) {

×

3942

        if (pInfo->validBlockIndex >= totalBlocks) {

×

3943

          pAPI->stateStore.updateInfoDestoryColseWinSBF(pInfo->pUpdateInfo);

×

3946

          qDebug("stream scan return empty, all %d submit blocks consumed, %s", totalBlocks, id);

×

3947

          (*ppRes) = NULL;

×

3948

          return code;

×

3951

        int32_t      current = pInfo->validBlockIndex++;

×

3952

        SPackedData* pSubmit = taosArrayGet(pInfo->pBlockLists, current);

×

3953

        QUERY_CHECK_NULL(pSubmit, code, lino, _end, terrno);

×

3955

        qDebug("set %d/%d as the input submit block, %s", current + 1, totalBlocks, id);

×

3956

        if (pAPI->tqReaderFn.tqReaderSetSubmitMsg(pInfo->tqReader, pSubmit->msgStr, pSubmit->msgLen, pSubmit->ver) <

×

3958

          qError("submit msg messed up when initializing stream submit block %p, current %d/%d, %s", pSubmit, current,

×

3960

          continue;

×

3964

      blockDataCleanup(pInfo->pRes);

×

3966

      while (pAPI->tqReaderFn.tqNextBlockImpl(pInfo->tqReader, id)) {

×

3967

        SSDataBlock* pRes = NULL;

×

3969

        code = pAPI->tqReaderFn.tqRetrieveBlock(pInfo->tqReader, &pRes, id);

×

3970

        qDebug("retrieve data from submit completed code:%s rows:%" PRId64 " %s", tstrerror(code), pRes->info.rows, id);

×

3972

        if (code != TSDB_CODE_SUCCESS || pRes->info.rows == 0) {

×

3973

          qDebug("retrieve data failed, try next block in submit block, %s", id);

×

3974

          continue;

×

3977

        code = setBlockIntoRes(pInfo, pRes, &pStreamInfo->fillHistoryWindow, false);

×

3978

        if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {

×

3979

          pInfo->pRes->info.rows = 0;

×

3980

          code = TSDB_CODE_SUCCESS;

×

3982

          QUERY_CHECK_CODE(code, lino, _end);

×

3985

        if (pInfo->pRes->info.rows == 0) {

×

3986

          continue;

×

3989

        if (pInfo->pCreateTbRes->info.rows > 0) {

×

3990

          pInfo->scanMode = STREAM_SCAN_FROM_RES;

×

3991

          qDebug("create table res exists, rows:%" PRId64 " return from stream scan, %s",

×

3993

          (*ppRes) = pInfo->pCreateTbRes;

×

3994

          return code;

×

3997

        code = doCheckUpdate(pInfo, pBlockInfo->window.ekey, pInfo->pRes);

×

3998

        QUERY_CHECK_CODE(code, lino, _end);

×

3999

        setStreamOperatorState(&pInfo->basic, pInfo->pRes->info.type);

×

4000

        code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);

×

4001

        QUERY_CHECK_CODE(code, lino, _end);

×

4003

        code = blockDataUpdateTsWindow(pInfo->pRes, pInfo->primaryTsIndex);

×

4004

        QUERY_CHECK_CODE(code, lino, _end);

×

4006

        int64_t numOfUpdateRes = pInfo->pUpdateDataRes->info.rows;

×

4007

        qDebug("%s %" PRId64 " rows in datablock, update res:%" PRId64, id, pBlockInfo->rows, numOfUpdateRes);

×

4008

        if (pBlockInfo->rows > 0 || numOfUpdateRes > 0) {

×

4013

      if (pBlockInfo->rows > 0 || pInfo->pUpdateDataRes->info.rows > 0) {

×

4016

        continue;

×

4021

    pInfo->numOfExec++;

×

4022

    pOperator->resultInfo.totalRows += pBlockInfo->rows;

×

4024

    qDebug("stream scan completed, and return source rows:%" PRId64 ", %s", pBlockInfo->rows, id);

×

4025

    if (pBlockInfo->rows > 0) {

×

4026

      printDataBlock(pInfo->pRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));

×

4027

      (*ppRes) = pInfo->pRes;

×

4028

      return code;

×

4031

    if (pInfo->pUpdateDataRes->info.rows > 0) {

×

4032

      goto FETCH_NEXT_BLOCK;

×

4035

    goto NEXT_SUBMIT_BLK;

×

4036

  } else if (pInfo->blockType == STREAM_INPUT__CHECKPOINT) {

×

4037

    if (pInfo->validBlockIndex >= total) {

×

4039

      (*ppRes) = NULL;

×

4040

      return code;

×

4043

    int32_t current = pInfo->validBlockIndex++;

×

4044

    qDebug("process %d/%d input data blocks, %s", current, (int32_t)total, id);

×

4046

    SPackedData* pData = taosArrayGet(pInfo->pBlockLists, current);

×

4047

    QUERY_CHECK_NULL(pData, code, lino, _end, terrno);

×

4048

    SSDataBlock* pBlock = taosArrayGet(pData->pDataBlock, 0);

×

4049

    QUERY_CHECK_NULL(pBlock, code, lino, _end, terrno);

×

4051

    if (pBlock->info.type == STREAM_CHECKPOINT) {

×

4052

      streamScanOperatorSaveCheckpoint(pInfo);

×

4055

    (*ppRes) = pInfo->pCheckpointRes;

×

4056

    return code;

×

4058

    qError("stream scan error, invalid block type %d, %s", pInfo->blockType, id);

×

4059

    code = TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;

×

4062

_end:

×

4063

  if (code != TSDB_CODE_SUCCESS) {

×

4064

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

4065

    pTaskInfo->code = code;

×

4066

    T_LONG_JMP(pTaskInfo->env, code);

×

4068

  (*ppRes) = NULL;

×

4069

  return code;

×

4072

static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) {

×

4073

  SSDataBlock* pRes = NULL;

×

4074

  int32_t      code = doStreamScanNext(pOperator, &pRes);

×

4075

  return pRes;

×

4077

static int32_t extractTableIdList(const STableListInfo* pTableListInfo, SArray** ppArrayRes) {

×

4078

  int32_t code = TSDB_CODE_SUCCESS;

×

4079

  int32_t lino = 0;

×

4080

  SArray* tableIdList = taosArrayInit(4, sizeof(uint64_t));

×

4081

  QUERY_CHECK_NULL(tableIdList, code, lino, _end, terrno);

×

4084

  int32_t size = 0;

×

4085

  code = tableListGetSize(pTableListInfo, &size);

×

4086

  QUERY_CHECK_CODE(code, lino, _end);

×

4087

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

×

4088

    STableKeyInfo* pkeyInfo = tableListGetInfo(pTableListInfo, i);

×

4089

    QUERY_CHECK_NULL(pkeyInfo, code, lino, _end, terrno);

×

4090

    void* tmp = taosArrayPush(tableIdList, &pkeyInfo->uid);

×

4091

    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

×

4094

  (*ppArrayRes) = tableIdList;

×

4096

_end:

×

4097

  if (code != TSDB_CODE_SUCCESS) {

×

4098

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

4100

  return code;

×

4103

static int32_t doRawScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

×

4104

  int32_t        code = TSDB_CODE_SUCCESS;

×

4105

  int32_t        lino = 0;

×

4106

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

×

4107

  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;

×

4109

  SStreamRawScanInfo* pInfo = pOperator->info;

×

4110

  pTaskInfo->streamInfo.btMetaRsp.batchMetaReq = NULL;  // use batchMetaReq != NULL to judge if data is meta

×

4111

  pTaskInfo->streamInfo.btMetaRsp.batchMetaLen = NULL;

×

4113

  qDebug("tmqsnap doRawScan called");

×

4114

  if (pTaskInfo->streamInfo.currentOffset.type == TMQ_OFFSET__SNAPSHOT_DATA) {

×

4115

    bool hasNext = false;

×

4116

    if (pInfo->dataReader && pInfo->sContext->withMeta != ONLY_META) {

×

4117

      code = pAPI->tsdReader.tsdNextDataBlock(pInfo->dataReader, &hasNext);

×

4118

      if (code != TSDB_CODE_SUCCESS) {

×

4119

        pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->dataReader);

×

4120

        QUERY_CHECK_CODE(code, lino, _end);

×

4124

    if (pInfo->dataReader && hasNext) {

×

4125

      if (isTaskKilled(pTaskInfo)) {

×

4126

        pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->dataReader);

×

4127

        return code;

×

4130

      SSDataBlock* pBlock = NULL;

×

4131

      code = pAPI->tsdReader.tsdReaderRetrieveDataBlock(pInfo->dataReader, &pBlock, NULL);

×

4132

      QUERY_CHECK_CODE(code, lino, _end);

×

4134

      if (pBlock && pBlock->info.rows > 0) {

×

4135

        bool hasPrimaryKey = pAPI->snapshotFn.taosXGetTablePrimaryKey(pInfo->sContext);

×

4136

        code = processPrimaryKey(pBlock, hasPrimaryKey, &pTaskInfo->streamInfo.currentOffset);

×

4137

        QUERY_CHECK_CODE(code, lino, _end);

×

4138

        qDebug("tmqsnap doRawScan get data uid:%" PRId64 "", pBlock->info.id.uid);

×

4139

        (*ppRes) = pBlock;

×

4140

        return code;

×

4144

    SMetaTableInfo mtInfo = {0};

×

4145

    code = pAPI->snapshotFn.getMetaTableInfoFromSnapshot(pInfo->sContext, &mtInfo);

×

4146

    QUERY_CHECK_CODE(code, lino, _end);

×

4147

    if (code != 0) {

×

4148

      tDeleteSchemaWrapper(mtInfo.schema);

×

4149

      QUERY_CHECK_CODE(code, lino, _end);

×

4151

    STqOffsetVal offset = {0};

×

4152

    if (mtInfo.uid == 0 || pInfo->sContext->withMeta == ONLY_META) {  // read snapshot done, change to get data from wal

×

4153

      qDebug("tmqsnap read snapshot done, change to get data from wal");

×

4154

      tqOffsetResetToLog(&offset, pInfo->sContext->snapVersion + 1);

×

4156

      SValue val = {0};

×

4157

      tqOffsetResetToData(&offset, mtInfo.uid, INT64_MIN, val);

×

4158

      qDebug("tmqsnap change get data uid:%" PRId64 "", mtInfo.uid);

×

4160

    tDeleteSchemaWrapper(mtInfo.schema);

×

4161

    code = qStreamPrepareScan(pTaskInfo, &offset, pInfo->sContext->subType);

×

4162

    QUERY_CHECK_CODE(code, lino, _end);

×

4163

    (*ppRes) = NULL;

×

4164

    return code;

×

4165

  } else if (pTaskInfo->streamInfo.currentOffset.type == TMQ_OFFSET__SNAPSHOT_META) {

×

4166

    SSnapContext* sContext = pInfo->sContext;

×

4167

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

×

4168

      void*   data = NULL;

×

4169

      int32_t dataLen = 0;

×

4170

      int16_t type = 0;

×

4171

      int64_t uid = 0;

×

4172

      if (pAPI->snapshotFn.getTableInfoFromSnapshot(sContext, &data, &dataLen, &type, &uid) < 0) {

×

4173

        qError("tmqsnap getTableInfoFromSnapshot error");

×

4174

        taosMemoryFreeClear(data);

×

4175

        break;

×

4178

      if (!sContext->queryMeta) {  // change to get data next poll request

×

4179

        STqOffsetVal offset = {0};

×

4180

        SValue       val = {0};

×

4181

        tqOffsetResetToData(&offset, 0, INT64_MIN, val);

×

4182

        code = qStreamPrepareScan(pTaskInfo, &offset, pInfo->sContext->subType);

×

4183

        QUERY_CHECK_CODE(code, lino, _end);

×

4184

        break;

×

4186

        tqOffsetResetToMeta(&pTaskInfo->streamInfo.currentOffset, uid);

×

4187

        SMqMetaRsp tmpMetaRsp = {0};

×

4188

        tmpMetaRsp.resMsgType = type;

×

4189

        tmpMetaRsp.metaRspLen = dataLen;

×

4190

        tmpMetaRsp.metaRsp = data;

×

4191

        if (!pTaskInfo->streamInfo.btMetaRsp.batchMetaReq) {

×

4192

          pTaskInfo->streamInfo.btMetaRsp.batchMetaReq = taosArrayInit(4, POINTER_BYTES);

×

4193

          QUERY_CHECK_NULL(pTaskInfo->streamInfo.btMetaRsp.batchMetaReq, code, lino, _end, terrno);

×

4195

          pTaskInfo->streamInfo.btMetaRsp.batchMetaLen = taosArrayInit(4, sizeof(int32_t));

×

4196

          QUERY_CHECK_NULL(pTaskInfo->streamInfo.btMetaRsp.batchMetaLen, code, lino, _end, terrno);

×

4198

        int32_t  tempRes = TSDB_CODE_SUCCESS;

×

4199

        uint32_t len = 0;

×

4200

        tEncodeSize(tEncodeMqMetaRsp, &tmpMetaRsp, len, tempRes);

×

4201

        if (TSDB_CODE_SUCCESS != tempRes) {

×

4202

          qError("tmqsnap tEncodeMqMetaRsp error");

×

4203

          taosMemoryFreeClear(data);

×

4204

          break;

×

4207

        int32_t tLen = sizeof(SMqRspHead) + len;

×

4208

        void*   tBuf = taosMemoryCalloc(1, tLen);

×

4209

        QUERY_CHECK_NULL(tBuf, code, lino, _end, terrno);

×

4211

        void*    metaBuff = POINTER_SHIFT(tBuf, sizeof(SMqRspHead));

×

4212

        SEncoder encoder = {0};

×

4213

        tEncoderInit(&encoder, metaBuff, len);

×

4214

        int32_t tempLen = tEncodeMqMetaRsp(&encoder, &tmpMetaRsp);

×

4215

        if (tempLen < 0) {

×

4216

          qError("tmqsnap tEncodeMqMetaRsp error");

×

4217

          tEncoderClear(&encoder);

×

4218

          taosMemoryFreeClear(tBuf);

×

4219

          taosMemoryFreeClear(data);

×

4220

          break;

×

4222

        taosMemoryFreeClear(data);

×

4223

        void* tmp = taosArrayPush(pTaskInfo->streamInfo.btMetaRsp.batchMetaReq, &tBuf);

×

4224

        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

×

4226

        tmp = taosArrayPush(pTaskInfo->streamInfo.btMetaRsp.batchMetaLen, &tLen);

×

4227

        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

×

4231

    (*ppRes) = NULL;

×

4232

    return code;

×

4235

_end:

×

4236

  if (code != TSDB_CODE_SUCCESS) {

×

4237

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

4238

    pTaskInfo->code = code;

×

4239

    T_LONG_JMP(pTaskInfo->env, code);

×

4242

  (*ppRes) = NULL;

×

4243

  return code;

×

4246

static void destroyRawScanOperatorInfo(void* param) {

×

4247

  SStreamRawScanInfo* pRawScan = (SStreamRawScanInfo*)param;

×

4248

  pRawScan->pAPI->tsdReader.tsdReaderClose(pRawScan->dataReader);

×

4249

  pRawScan->pAPI->snapshotFn.destroySnapshot(pRawScan->sContext);

×

4250

  tableListDestroy(pRawScan->pTableListInfo);

×

4251

  taosMemoryFree(pRawScan);

×

4252

×

4257

int32_t createRawScanOperatorInfo(SReadHandle* pHandle, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {

×

4263

  QRY_PARAM_CHECK(pOptrInfo);

×

4264

  int32_t code = TSDB_CODE_SUCCESS;

×

4265

  int32_t lino = 0;

×

4267

  SStreamRawScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamRawScanInfo));

×

4268

  SOperatorInfo*      pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));

×

4269

  if (pInfo == NULL || pOperator == NULL) {

×

4270

    code = terrno;

×

4271

    lino = __LINE__;

×

4272

    goto _end;

×

4275

  pInfo->pTableListInfo = tableListCreate();

×

4276

  QUERY_CHECK_NULL(pInfo->pTableListInfo, code, lino, _end, terrno);

×

4277

  pInfo->vnode = pHandle->vnode;

×

4278

  pInfo->pAPI = &pTaskInfo->storageAPI;

×

4280

  pInfo->sContext = pHandle->sContext;

×

4281

  setOperatorInfo(pOperator, "RawScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN, false, OP_NOT_OPENED, pInfo,

×

4284

  pOperator->fpSet = createOperatorFpSet(NULL, doRawScanNext, NULL, destroyRawScanOperatorInfo, optrDefaultBufFn, NULL,

×

4286

  *pOptrInfo = pOperator;

×

4287

  return code;

×

4289

_end:

×

4290

  if (code != TSDB_CODE_SUCCESS) {

×

4291

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

4293

  taosMemoryFree(pInfo);

×

4294

  taosMemoryFree(pOperator);

×

4295

  pTaskInfo->code = code;

×

4296

  return code;

×

4299

static void destroyStreamScanOperatorInfo(void* param) {

×

4300

  if (param == NULL) {

×

4301

    return;

×

4304

  SStreamScanInfo* pStreamScan = (SStreamScanInfo*)param;

×

4305

  if (pStreamScan->pTableScanOp && pStreamScan->pTableScanOp->info) {

×

4306

    destroyOperator(pStreamScan->pTableScanOp);

×

4309

  if (pStreamScan->tqReader != NULL && pStreamScan->readerFn.tqReaderClose != NULL) {

×

4310

    pStreamScan->readerFn.tqReaderClose(pStreamScan->tqReader);

×

4312

  if (pStreamScan->matchInfo.pList) {

×

4313

    taosArrayDestroy(pStreamScan->matchInfo.pList);

×

4315

  if (pStreamScan->pPseudoExpr) {

×

4316

    destroyExprInfo(pStreamScan->pPseudoExpr, pStreamScan->numOfPseudoExpr);

×

4317

    taosMemoryFree(pStreamScan->pPseudoExpr);

×

4320

  cleanupExprSupp(&pStreamScan->tbnameCalSup);

×

4321

  cleanupExprSupp(&pStreamScan->tagCalSup);

×

4323

  if (pStreamScan->stateStore.updateInfoDestroy) {

×

4324

    pStreamScan->stateStore.updateInfoDestroy(pStreamScan->pUpdateInfo);

×

4327

  blockDataDestroy(pStreamScan->pRes);

×

4328

  blockDataDestroy(pStreamScan->pUpdateRes);

×

4329

  blockDataDestroy(pStreamScan->pDeleteDataRes);

×

4330

  blockDataDestroy(pStreamScan->pUpdateDataRes);

×

4331

  blockDataDestroy(pStreamScan->pCreateTbRes);

×

4332

  taosArrayDestroy(pStreamScan->pBlockLists);

×

4333

  blockDataDestroy(pStreamScan->pCheckpointRes);

×

4335

  taosMemoryFree(pStreamScan);

×

4338

void streamScanReleaseState(SOperatorInfo* pOperator) {

×

4339

  int32_t          code = TSDB_CODE_SUCCESS;

×

4340

  int32_t          lino = 0;

×

4341

  SStreamScanInfo* pInfo = pOperator->info;

×

4342

  void*            pBuff = NULL;

×

4343

  SEncoder*        pEnCoder = NULL;

×

4344

  SEncoder*        pScanEnCoder = NULL;

×

4345

  if (!pInfo->pState) {

×

4346

    return;

×

4348

  if (!pInfo->pUpdateInfo) {

×

4349

    qDebug("stask:%s streamScanReleaseState cancel", GET_TASKID(pOperator->pTaskInfo));

×

4350

    return;

×

4352

  int32_t  len = 0;

×

4353

  SEncoder encoder = {0};

×

4354

  pEnCoder = &encoder;

×

4355

  tEncoderInit(pEnCoder, NULL, 0);

×

4356

  if (tStartEncode(pEnCoder) != 0) {

×

4357

    code = TSDB_CODE_FAILED;

×

4358

    QUERY_CHECK_CODE(code, lino, _end);

×

4360

  code = pInfo->stateStore.updateInfoSerialize(pEnCoder, pInfo->pUpdateInfo);

×

4361

  QUERY_CHECK_CODE(code, lino, _end);

×

4363

  tEndEncode(pEnCoder);

×

4364

  len += encoder.pos;

×

4365

  tEncoderClear(pEnCoder);

×

4366

  pEnCoder = NULL;

×

4368

  pBuff = taosMemoryCalloc(1, len);

×

4369

  if (!pBuff) {

×

4370

    code = terrno;

×

4371

    QUERY_CHECK_CODE(code, lino, _end);

×

4374

  SEncoder scanEncoder = {0};

×

4375

  pScanEnCoder = &scanEncoder;

×

4376

  tEncoderInit(pScanEnCoder, pBuff, len);

×

4377

  if (tStartEncode(pScanEnCoder) != 0) {

×

4378

    code = TSDB_CODE_FAILED;

×

4379

    QUERY_CHECK_CODE(code, lino, _end);

×

4381

  code = pInfo->stateStore.updateInfoSerialize(pScanEnCoder, pInfo->pUpdateInfo);

×

4382

  QUERY_CHECK_CODE(code, lino, _end);

×

4384

  tEndEncode(pScanEnCoder);

×

4385

  tEncoderClear(pScanEnCoder);

×

4386

  pScanEnCoder = NULL;

×

4388

  pInfo->stateStore.streamStateSaveInfo(pInfo->pState, STREAM_SCAN_OP_STATE_NAME, strlen(STREAM_SCAN_OP_STATE_NAME),

×

4390

_end:

×

4391

  if (code != TSDB_CODE_SUCCESS) {

×

4392

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

4394

  if (pEnCoder != NULL) {

×

4395

    tEndEncode(pEnCoder);

×

4396

    tEncoderClear(pEnCoder);

×

4398

  if (pScanEnCoder != NULL) {

×

4399

    tEndEncode(pScanEnCoder);

×

4400

    tEncoderClear(pScanEnCoder);

×

4402

  taosMemoryFree(pBuff);

×

4405

void streamScanReloadState(SOperatorInfo* pOperator) {

×

4406

  int32_t          code = TSDB_CODE_SUCCESS;

×

4407

  int32_t          lino = 0;

×

4408

  SDecoder*        pDeCoder = NULL;

×

4409

  SStreamScanInfo* pInfo = pOperator->info;

×

4410

  if (!pInfo->pState) {

×

4411

    return;

×

4413

  if (!pInfo->pUpdateInfo) {

×

4414

    qDebug("stask:%s streamScanReloadState cancel", GET_TASKID(pOperator->pTaskInfo));

×

4415

    return;

×

4417

  void*   pBuff = NULL;

×

4418

  int32_t len = 0;

×

4419

  code = pInfo->stateStore.streamStateGetInfo(pInfo->pState, STREAM_SCAN_OP_STATE_NAME,

×

4421

  QUERY_CHECK_CODE(code, lino, _end);

×

4423

  SUpdateInfo* pUpInfo = taosMemoryCalloc(1, sizeof(SUpdateInfo));

×

4424

  if (!pUpInfo) {

×

4425

    code = terrno;

×

4426

    QUERY_CHECK_CODE(code, lino, _end);

×

4429

  SDecoder decoder = {0};

×

4430

  pDeCoder = &decoder;

×

4431

  tDecoderInit(pDeCoder, pBuff, len);

×

4432

  if (tStartDecode(pDeCoder) < 0) {

×

4433

    lino = __LINE__;

×

4434

    goto _end;

×

4436

  int32_t winCode = pInfo->stateStore.updateInfoDeserialize(pDeCoder, pUpInfo);

×

4437

  taosMemoryFree(pBuff);

×

4438

  if (winCode == TSDB_CODE_SUCCESS && pInfo->pUpdateInfo) {

×

4439

    if (pInfo->pUpdateInfo->minTS < 0) {

×

4440

      pInfo->stateStore.updateInfoDestroy(pInfo->pUpdateInfo);

×

4441

      pInfo->pUpdateInfo = pUpInfo;

×

4443

      pInfo->stateStore.windowSBfDelete(pInfo->pUpdateInfo, 1);

×

4444

      code = pInfo->stateStore.windowSBfAdd(pInfo->pUpdateInfo, 1);

×

4445

      QUERY_CHECK_CODE(code, lino, _end);

×

4447

      QUERY_CHECK_CONDITION((pInfo->pUpdateInfo->minTS > pUpInfo->minTS), code, lino, _end,

×

4449

      pInfo->pUpdateInfo->maxDataVersion = TMAX(pInfo->pUpdateInfo->maxDataVersion, pUpInfo->maxDataVersion);

×

4450

      SHashObj* curMap = pInfo->pUpdateInfo->pMap;

×

4451

      void*     pIte = taosHashIterate(curMap, NULL);

×

4452

      while (pIte != NULL) {

×

4453

        size_t   keySize = 0;

×

4454

        int64_t* pUid = taosHashGetKey(pIte, &keySize);

×

4455

        code = taosHashPut(pUpInfo->pMap, pUid, sizeof(int64_t), pIte, sizeof(TSKEY));

×

4456

        if (code == TSDB_CODE_DUP_KEY) {

×

4457

          code = TSDB_CODE_SUCCESS;

×

4459

        QUERY_CHECK_CODE(code, lino, _end);

×

4461

        pIte = taosHashIterate(curMap, pIte);

×

4463

      taosHashCleanup(curMap);

×

4464

      pInfo->pUpdateInfo->pMap = pUpInfo->pMap;

×

4465

      pUpInfo->pMap = NULL;

×

4466

      pInfo->stateStore.updateInfoDestroy(pUpInfo);

×

4469

    pInfo->stateStore.updateInfoDestroy(pUpInfo);

×

4472

_end:

×

4473

  if (pDeCoder != NULL) {

×

4474

    tEndDecode(pDeCoder);

×

4475

    tDecoderClear(pDeCoder);

×

4477

  if (code != TSDB_CODE_SUCCESS) {

×

4478

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

4482

int32_t addPrimaryKeyCol(SSDataBlock* pBlock, uint8_t type, int32_t bytes) {

×

4483

  int32_t code = TSDB_CODE_SUCCESS;

×

4484

  int32_t lino = 0;

×

4485

  pBlock->info.rowSize += bytes;

×

4486

  SColumnInfoData infoData = {0};

×

4487

  infoData.info.type = type;

×

4488

  infoData.info.bytes = bytes;

×

4489

  void* tmp = taosArrayPush(pBlock->pDataBlock, &infoData);

×

4490

  QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

×

4492

_end:

×

4493

  if (code != TSDB_CODE_SUCCESS) {

×

4494

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

4496

  return code;

×

4499

int32_t createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode, SNode* pTagCond,

×

4502

  QRY_PARAM_CHECK(pOptrInfo);

×

4504

  int32_t          code = TSDB_CODE_SUCCESS;

×

4505

  int32_t          lino = 0;

×

4506

  SArray*          pColIds = NULL;

×

4507

  SStreamScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamScanInfo));

×

4508

  SOperatorInfo*   pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));

×

4509

  SStorageAPI*     pAPI = &pTaskInfo->storageAPI;

×

4510

  const char*      idstr = pTaskInfo->id.str;

×

4512

  if (pInfo == NULL || pOperator == NULL) {

×

4513

    code = terrno;

×

4514

    goto _error;

×

4517

  SScanPhysiNode*     pScanPhyNode = &pTableScanNode->scan;

×

4518

  SDataBlockDescNode* pDescNode = pScanPhyNode->node.pOutputDataBlockDesc;

×

4520

  pInfo->pTagCond = pTagCond;

×

4521

  pInfo->pGroupTags = pTableScanNode->pGroupTags;

×

4523

  int32_t numOfCols = 0;

×

4524

  code = extractColMatchInfo(pScanPhyNode->pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo);

×

4525

  if (code != TSDB_CODE_SUCCESS) {

×

4526

    goto _error;

×

4529

  SDataType pkType = {0};

×

4530

  pInfo->primaryKeyIndex = -1;

×

4531

  pInfo->basic.primaryPkIndex = -1;

×

4532

  int32_t numOfOutput = taosArrayGetSize(pInfo->matchInfo.pList);

×

4533

  pColIds = taosArrayInit(numOfOutput, sizeof(int16_t));

×

4534

  QUERY_CHECK_NULL(pColIds, code, lino, _error, terrno);

×

4536

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

×

4537

    SColMatchItem* id = taosArrayGet(pInfo->matchInfo.pList, i);

×

4538

    QUERY_CHECK_NULL(id, code, lino, _error, terrno);

×

4540

    int16_t colId = id->colId;

×

4541

    void*   tmp = taosArrayPush(pColIds, &colId);

×

4542

    QUERY_CHECK_NULL(tmp, code, lino, _error, terrno);

×

4544

    if (id->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {

×

4545

      pInfo->primaryTsIndex = id->dstSlotId;

×

4547

    if (id->isPk) {

×

4548

      pInfo->primaryKeyIndex = id->dstSlotId;

×

4549

      pInfo->basic.primaryPkIndex = id->dstSlotId;

×

4550

      pkType = id->dataType;

×

4554

  pInfo->pPartTbnameSup = NULL;

×

4555

  if (pTableScanNode->pSubtable != NULL) {

×

4556

    SExprInfo* pSubTableExpr = taosMemoryCalloc(1, sizeof(SExprInfo));

×

4557

    if (pSubTableExpr == NULL) {

×

4558

      code = terrno;

×

4559

      goto _error;

×

4562

    pInfo->tbnameCalSup.pExprInfo = pSubTableExpr;

×

4563

    code = createExprFromOneNode(pSubTableExpr, pTableScanNode->pSubtable, 0);

×

4564

    QUERY_CHECK_CODE(code, lino, _error);

×

4566

    if (initExprSupp(&pInfo->tbnameCalSup, pSubTableExpr, 1, &pTaskInfo->storageAPI.functionStore) != 0) {

×

4567

      goto _error;

×

4571

  if (pTableScanNode->pTags != NULL) {

×

4573

    SExprInfo* pTagExpr = createExpr(pTableScanNode->pTags, &numOfTags);

×

4574

    if (pTagExpr == NULL) {

×

4575

      goto _error;

×

4577

    code = initExprSupp(&pInfo->tagCalSup, pTagExpr, numOfTags, &pTaskInfo->storageAPI.functionStore);

×

4578

    if (code != 0) {

×

4579

      goto _error;

×

4583

  pInfo->pBlockLists = taosArrayInit(4, sizeof(SPackedData));

×

4584

  TSDB_CHECK_NULL(pInfo->pBlockLists, code, lino, _error, terrno);

×

4586

  if (pHandle->vnode) {

×

4587

    SOperatorInfo* pTableScanOp = NULL;

×

4588

    code = createTableScanOperatorInfo(pTableScanNode, pHandle, pTableListInfo, pTaskInfo, &pTableScanOp);

×

4589

    if (pTableScanOp == NULL || code != 0) {

×

4590

      qError("createTableScanOperatorInfo error, code:%d", pTaskInfo->code);

×

4591

      goto _error;

×

4594

    STableScanInfo* pTSInfo = (STableScanInfo*)pTableScanOp->info;

×

4595

    if (pHandle->version > 0) {

×

4596

      pTSInfo->base.cond.endVersion = pHandle->version;

×

4599

    STableKeyInfo* pList = NULL;

×

4600

    int32_t        num = 0;

×

4601

    code = tableListGetGroupList(pTableListInfo, 0, &pList, &num);

×

4602

    QUERY_CHECK_CODE(code, lino, _error);

×

4604

    if (pHandle->initTableReader) {

×

4605

      pTSInfo->scanMode = TABLE_SCAN__TABLE_ORDER;

×

4606

      pTSInfo->base.dataReader = NULL;

×

4609

    if (pHandle->initTqReader) {

×

4610

      pInfo->tqReader = pAPI->tqReaderFn.tqReaderOpen(pHandle->vnode);

×

4611

      QUERY_CHECK_NULL(pInfo->tqReader, code, lino, _error, terrno);

×

4613

      pInfo->tqReader = pHandle->tqReader;

×

4614

      QUERY_CHECK_NULL(pInfo->tqReader, code, lino, _error, TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);

×

4617

    pInfo->pUpdateInfo = NULL;

×

4618

    pInfo->pTableScanOp = pTableScanOp;

×

4619

    if (pInfo->pTableScanOp->pTaskInfo->streamInfo.pState) {

×

4620

      pAPI->stateStore.streamStateSetNumber(pInfo->pTableScanOp->pTaskInfo->streamInfo.pState, -1,

×

4624

    pInfo->readHandle = *pHandle;

×

4625

    pTaskInfo->streamInfo.snapshotVer = pHandle->version;

×

4626

    pInfo->pCreateTbRes = buildCreateTableBlock(&pInfo->tbnameCalSup, &pInfo->tagCalSup);

×

4627

    QUERY_CHECK_NULL(pInfo->pCreateTbRes, code, lino, _error, terrno);

×

4629

    code = blockDataEnsureCapacity(pInfo->pCreateTbRes, 8);

×

4630

    QUERY_CHECK_CODE(code, lino, _error);

×

4633

    pAPI->tqReaderFn.tqReaderSetColIdList(pInfo->tqReader, pColIds);

×

4635

    SArray* tableIdList = NULL;

×

4636

    code = extractTableIdList(((STableScanInfo*)(pInfo->pTableScanOp->info))->base.pTableListInfo, &tableIdList);

×

4637

    QUERY_CHECK_CODE(code, lino, _error);

×

4638

    pAPI->tqReaderFn.tqReaderSetQueryTableList(pInfo->tqReader, tableIdList, idstr);

×

4639

    taosArrayDestroy(tableIdList);

×

4640

    memcpy(&pTaskInfo->streamInfo.tableCond, &pTSInfo->base.cond, sizeof(SQueryTableDataCond));

×

4642

    taosArrayDestroy(pColIds);

×

4643

    tableListDestroy(pTableListInfo);

×

4647

  pColIds = NULL;

×

4650

  if (pTableScanNode->scan.pScanPseudoCols != NULL) {

×

4651

    code = createExprInfo(pTableScanNode->scan.pScanPseudoCols, NULL, &pInfo->pPseudoExpr, &pInfo->numOfPseudoExpr);

×

4652

    QUERY_CHECK_CODE(code, lino, _error);

×

4655

  code = filterInitFromNode((SNode*)pScanPhyNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);

×

4656

  QUERY_CHECK_CODE(code, lino, _error);

×

4658

  pInfo->pRes = createDataBlockFromDescNode(pDescNode);

×

4659

  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);

×

4660

  code = createSpecialDataBlock(STREAM_CLEAR, &pInfo->pUpdateRes);

×

4661

  QUERY_CHECK_CODE(code, lino, _error);

×

4663

  pInfo->scanMode = STREAM_SCAN_FROM_READERHANDLE;

×

4664

  pInfo->windowSup = (SWindowSupporter){.pStreamAggSup = NULL, .gap = -1, .parentType = QUERY_NODE_PHYSICAL_PLAN};

×

4665

  pInfo->groupId = 0;

×

4666

  pInfo->igCheckGroupId = false;

×

4667

  pInfo->pStreamScanOp = pOperator;

×

4668

  pInfo->deleteDataIndex = 0;

×

4669

  code = createSpecialDataBlock(STREAM_DELETE_DATA, &pInfo->pDeleteDataRes);

×

4670

  QUERY_CHECK_CODE(code, lino, _error);

×

4672

  pInfo->updateWin = (STimeWindow){.skey = INT64_MAX, .ekey = INT64_MAX};

×

4673

  code = createSpecialDataBlock(STREAM_CLEAR, &pInfo->pUpdateDataRes);

×

4674

  QUERY_CHECK_CODE(code, lino, _error);

×

4676

  if (hasPrimaryKeyCol(pInfo)) {

×

4677

    code = addPrimaryKeyCol(pInfo->pUpdateDataRes, pkType.type, pkType.bytes);

×

4678

    QUERY_CHECK_CODE(code, lino, _error);

×

4680

    pInfo->pkColType = pkType.type;

×

4681

    pInfo->pkColLen = pkType.bytes;

×

4684

  pInfo->assignBlockUid = pTableScanNode->assignBlockUid;

×

4685

  pInfo->partitionSup.needCalc = false;

×

4686

  pInfo->igCheckUpdate = pTableScanNode->igCheckUpdate;

×

4687

  pInfo->igExpired = pTableScanNode->igExpired;

×

4688

  pInfo->twAggSup.maxTs = INT64_MIN;

×

4689

  pInfo->pState = pTaskInfo->streamInfo.pState;

×

4690

  pInfo->stateStore = pTaskInfo->storageAPI.stateStore;

×

4691

  pInfo->readerFn = pTaskInfo->storageAPI.tqReaderFn;

×

4692

  pInfo->pFillSup = NULL;

×

4693

  pInfo->useGetResultRange = false;

×

4694

  pInfo->pRangeScanRes = NULL;

×

4696

  code = createSpecialDataBlock(STREAM_CHECKPOINT, &pInfo->pCheckpointRes);

×

4697

  QUERY_CHECK_CODE(code, lino, _error);

×

4699

  SET_WIN_KEY_INVALID(pInfo->lastScanRange.skey);

×

4700

  SET_WIN_KEY_INVALID(pInfo->lastScanRange.ekey);

×

4702

  if (pTaskInfo->streamInfo.pState) {

×

4703

    void*   buff = NULL;

×

4704

    int32_t len = 0;

×

4705

    int32_t res = pAPI->stateStore.streamStateGetInfo(pTaskInfo->streamInfo.pState, STREAM_SCAN_OP_CHECKPOINT_NAME,

×

4707

    if (res == TSDB_CODE_SUCCESS) {

×

4708

      streamScanOperatorDecode(buff, len, pInfo);

×

4709

      taosMemoryFree(buff);

×

4713

  setOperatorInfo(pOperator, STREAM_SCAN_OP_NAME, QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN, false, OP_NOT_OPENED, pInfo,

×

4715

  pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock);

×

4717

  __optr_fn_t nextFn = (pTaskInfo->execModel == OPTR_EXEC_MODEL_STREAM) ? doStreamScanNext : doQueueScanNext;

×

4718

  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, nextFn, NULL, destroyStreamScanOperatorInfo, optrDefaultBufFn,

×

4720

  setOperatorStreamStateFn(pOperator, streamScanReleaseState, streamScanReloadState);

×

4722

  *pOptrInfo = pOperator;

×

4723

  return code;

×

4725

_error:

×

4726

  if (pColIds != NULL) {

×

4727

    taosArrayDestroy(pColIds);

×

4730

  if (pInfo != NULL) {

×

4731

    STableScanInfo* p = (STableScanInfo*) pInfo->pTableScanOp->info;

×

4732

    if (p != NULL) {

×

4733

      p->base.pTableListInfo = NULL;

×

4735

    destroyStreamScanOperatorInfo(pInfo);

×

4738

  if (pOperator != NULL) {

×

4739

    pOperator->info = NULL;

×

4740

    destroyOperator(pOperator);

×

4742

  pTaskInfo->code = code;

×

4743

  return code;

×

4746

static int32_t doTagScanOneTable(SOperatorInfo* pOperator, SSDataBlock* pRes, SMetaReader* mr, SStorageAPI* pAPI) {

×

4747

  int32_t        code = TSDB_CODE_SUCCESS;

×

4748

  int32_t        lino = 0;

×

4749

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

×

4750

  STagScanInfo*  pInfo = pOperator->info;

×

4751

  SExprInfo*     pExprInfo = &pOperator->exprSupp.pExprInfo[0];

×

4752

  int32_t        count = pRes->info.rows;

×

4754

  STableKeyInfo* item = tableListGetInfo(pInfo->pTableListInfo, pInfo->curPos);

×

4755

  if (!item) {

×

4756

    qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", item->uid, tstrerror(terrno),

×

4758

    tDecoderClear(&(*mr).coder);

×

4759

    goto _end;

×

4762

  code = pAPI->metaReaderFn.getTableEntryByUid(mr, item->uid);

×

4763

  tDecoderClear(&(*mr).coder);

×

4764

  if (code != TSDB_CODE_SUCCESS) {

×

4765

    qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", item->uid, tstrerror(terrno),

×

4767

    goto _end;

×

4771

  for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {

×

4772

    SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);

×

4775

    if (FUNCTION_TYPE_TBNAME == pExprInfo[j].pExpr->_function.functionType) {

×

4776

      STR_TO_VARSTR(str, (*mr).me.name);

×

4777

      code = colDataSetVal(pDst, (count), str, false);

×

4778

      QUERY_CHECK_CODE(code, lino, _end);

×

4779

    } else if (FUNCTION_TYPE_TBUID == pExprInfo[j].pExpr->_function.functionType) {

×

4780

      code = colDataSetVal(pDst, (count), (char*)&(*mr).me.uid, false);

×

4781

      QUERY_CHECK_CODE(code, lino, _end);

×

4782

    } else if (FUNCTION_TYPE_VGID == pExprInfo[j].pExpr->_function.functionType) {

×

4783

      code = colDataSetVal(pDst, (count), (char*)&pTaskInfo->id.vgId, false);

×

4784

      QUERY_CHECK_CODE(code, lino, _end);

×

4786

      STagVal val = {0};

×

4787

      val.cid = pExprInfo[j].base.pParam[0].pCol->colId;

×

4788

      const char* p = pAPI->metaFn.extractTagVal((*mr).me.ctbEntry.pTags, pDst->info.type, &val);

×

4790

      char* data = NULL;

×

4791

      if (pDst->info.type != TSDB_DATA_TYPE_JSON && p != NULL) {

×

4792

        data = tTagValToData((const STagVal*)p, false);

×

4794

        data = (char*)p;

×

4797

      code = colDataSetVal(pDst, (count), data,

×

4798

                           (data == NULL) || (pDst->info.type == TSDB_DATA_TYPE_JSON && tTagIsJsonNull(data)));

×

4799

      QUERY_CHECK_CODE(code, lino, _end);

×

4801

      if ((pDst->info.type != TSDB_DATA_TYPE_JSON) && (p != NULL) && IS_VAR_DATA_TYPE(((const STagVal*)p)->type) &&

×

4803

        taosMemoryFree(data);

×

4808

_end:

×

4809

  if (code != TSDB_CODE_SUCCESS) {

×

4810

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

4811

    pTaskInfo->code = code;

×

4813

    pRes->info.rows++;

×

4816

  return code;

×

4819

static void tagScanFreeUidTag(void* p) {

×

4820

  STUidTagInfo* pInfo = p;

×

4821

  if (pInfo->pTagVal != NULL) {

×

4822

    taosMemoryFree(pInfo->pTagVal);

×

4824

×

4826

static int32_t tagScanCreateResultData(SDataType* pType, int32_t numOfRows, SScalarParam* pParam) {

×

4827

  SColumnInfoData* pColumnData = taosMemoryCalloc(1, sizeof(SColumnInfoData));

×

4828

  if (pColumnData == NULL) {

×

4829

    return terrno;

×

4832

  pColumnData->info.type = pType->type;

×

4833

  pColumnData->info.bytes = pType->bytes;

×

4834

  pColumnData->info.scale = pType->scale;

×

4835

  pColumnData->info.precision = pType->precision;

×

4837

  int32_t code = colInfoDataEnsureCapacity(pColumnData, numOfRows, true);

×

4838

  if (code != TSDB_CODE_SUCCESS) {

×

4839

    terrno = code;

×

4840

    taosMemoryFree(pColumnData);

×

4841

    return terrno;

×

4844

  pParam->columnData = pColumnData;

×

4845

  pParam->colAlloced = true;

×

4846

  return TSDB_CODE_SUCCESS;

×

4849

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

×

4850

  int32_t                code = TSDB_CODE_SUCCESS;

×

4851

  int32_t                lino = 0;

×

4852

  STagScanFilterContext* pCtx = (STagScanFilterContext*)pContext;

×

4853

  SColumnNode*           pSColumnNode = NULL;

×

4854

  if (QUERY_NODE_COLUMN == nodeType((*pNode))) {

×

4855

    pSColumnNode = *(SColumnNode**)pNode;

×

4856

  } else if (QUERY_NODE_FUNCTION == nodeType((*pNode))) {

×

4857

    SFunctionNode* pFuncNode = *(SFunctionNode**)(pNode);

×

4858

    if (pFuncNode->funcType == FUNCTION_TYPE_TBNAME) {

×

4859

      pSColumnNode = NULL;

×

4860

      pCtx->code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pSColumnNode);

×

4861

      if (NULL == pSColumnNode) {

×

4862

        return DEAL_RES_ERROR;

×

4864

      pSColumnNode->colId = -1;

×

4865

      pSColumnNode->colType = COLUMN_TYPE_TBNAME;

×

4866

      pSColumnNode->node.resType.type = TSDB_DATA_TYPE_VARCHAR;

×

4867

      pSColumnNode->node.resType.bytes = TSDB_TABLE_FNAME_LEN - 1 + VARSTR_HEADER_SIZE;

×

4868

      nodesDestroyNode(*pNode);

×

4869

      *pNode = (SNode*)pSColumnNode;

×

4871

      return DEAL_RES_CONTINUE;

×

4874

    return DEAL_RES_CONTINUE;

×

4877

  void* data = taosHashGet(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId));

×

4878

  if (!data) {

×

4879

    code = taosHashPut(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode)));

×

4880

    if (code == TSDB_CODE_DUP_KEY) {

×

4881

      code = TSDB_CODE_SUCCESS;

×

4883

    QUERY_CHECK_CODE(code, lino, _end);

×

4884

    pSColumnNode->slotId = pCtx->index++;

×

4885

    SColumnInfo cInfo = {.colId = pSColumnNode->colId,

×

4886

                         .type = pSColumnNode->node.resType.type,

×

4887

                         .bytes = pSColumnNode->node.resType.bytes};

×

4888

    void*       tmp = taosArrayPush(pCtx->cInfoList, &cInfo);

×

4889

    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

×

4891

    SColumnNode* col = *(SColumnNode**)data;

×

4892

    pSColumnNode->slotId = col->slotId;

×

4895

_end:

×

4896

  if (code != TSDB_CODE_SUCCESS) {

×

4897

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

4898

    return DEAL_RES_ERROR;

×

4900

  return DEAL_RES_CONTINUE;

×

4903

static int32_t tagScanFilterByTagCond(SArray* aUidTags, SNode* pTagCond, SArray* aFilterIdxs, void* pVnode,

×

4905

  int32_t code = TSDB_CODE_SUCCESS;

×

4906

  int32_t lino = 0;

×

4907

  int32_t numOfTables = taosArrayGetSize(aUidTags);

×

4908

  SArray* pBlockList = NULL;

×

4910

  SSDataBlock* pResBlock = createTagValBlockForFilter(pInfo->filterCtx.cInfoList, numOfTables, aUidTags, pVnode, pAPI);

×

4911

  QUERY_CHECK_NULL(pResBlock, code, lino, _end, terrno);

×

4913

  pBlockList = taosArrayInit(1, POINTER_BYTES);

×

4914

  QUERY_CHECK_NULL(pBlockList, code, lino, _end, terrno);

×

4916

  void* tmp = taosArrayPush(pBlockList, &pResBlock);

×

4917

  QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

×

4919

  SDataType type = {.type = TSDB_DATA_TYPE_BOOL, .bytes = sizeof(bool)};

×

4921

  SScalarParam output = {0};

×

4922

  code = tagScanCreateResultData(&type, numOfTables, &output);

×

4923

  QUERY_CHECK_CODE(code, lino, _end);

×

4925

  code = scalarCalculate(pTagCond, pBlockList, &output);

×

4926

  QUERY_CHECK_CODE(code, lino, _end);

×

4928

  bool* result = (bool*)output.columnData->pData;

×

4929

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

×

4930

    if (result[i]) {

×

4931

      void* tmp = taosArrayPush(aFilterIdxs, &i);

×

4932

      QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

×

4936

  colDataDestroy(output.columnData);

×

4937

  taosMemoryFreeClear(output.columnData);

×

4939

_end:

×

4940

  blockDataDestroy(pResBlock);

×

4941

  taosArrayDestroy(pBlockList);

×

4942

  if (code != TSDB_CODE_SUCCESS) {

×

4943

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

4945

  return code;

×

4948

static int32_t tagScanFillOneCellWithTag(SOperatorInfo* pOperator, const STUidTagInfo* pUidTagInfo,

×

4951

  int32_t code = TSDB_CODE_SUCCESS;

×

4952

  int32_t lino = 0;

×

4953

  if (QUERY_NODE_FUNCTION == pExprInfo->pExpr->nodeType) {

×

4954

    if (FUNCTION_TYPE_TBNAME == pExprInfo->pExpr->_function.functionType) {  // tbname

×

4955

      char str[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};

×

4956

      STR_TO_VARSTR(str, "ctbidx");

×

4958

      code = colDataSetVal(pColInfo, rowIndex, str, false);

×

4959

      QUERY_CHECK_CODE(code, lino, _end);

×

4960

    } else if (FUNCTION_TYPE_TBUID == pExprInfo->pExpr->_function.functionType) {

×

4961

      code = colDataSetVal(pColInfo, rowIndex, (char*)&pUidTagInfo->uid, false);

×

4962

      QUERY_CHECK_CODE(code, lino, _end);

×

4963

    } else if (FUNCTION_TYPE_VGID == pExprInfo->pExpr->_function.functionType) {

×

4964

      code = colDataSetVal(pColInfo, rowIndex, (char*)&pOperator->pTaskInfo->id.vgId, false);

×

4965

      QUERY_CHECK_CODE(code, lino, _end);

×

4968

    STagVal tagVal = {0};

×

4969

    tagVal.cid = pExprInfo->base.pParam[0].pCol->colId;

×

4970

    if (pUidTagInfo->pTagVal == NULL) {

×

4971

      colDataSetNULL(pColInfo, rowIndex);

×

4973

      const char* p = pAPI->metaFn.extractTagVal(pUidTagInfo->pTagVal, pColInfo->info.type, &tagVal);

×

4975

      if (p == NULL || (pColInfo->info.type == TSDB_DATA_TYPE_JSON && ((STag*)p)->nTag == 0)) {

×

4976

        colDataSetNULL(pColInfo, rowIndex);

×

4977

      } else if (pColInfo->info.type == TSDB_DATA_TYPE_JSON) {

×

4978

        code = colDataSetVal(pColInfo, rowIndex, p, false);

×

4979

        QUERY_CHECK_CODE(code, lino, _end);

×

4980

      } else if (IS_VAR_DATA_TYPE(pColInfo->info.type)) {

×

4981

        char* tmp = taosMemoryMalloc(tagVal.nData + VARSTR_HEADER_SIZE + 1);

×

4982

        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

×

4984

        varDataSetLen(tmp, tagVal.nData);

×

4985

        memcpy(tmp + VARSTR_HEADER_SIZE, tagVal.pData, tagVal.nData);

×

4986

        code = colDataSetVal(pColInfo, rowIndex, tmp, false);

×

4987

        taosMemoryFree(tmp);

×

4988

        QUERY_CHECK_CODE(code, lino, _end);

×

4990

        code = colDataSetVal(pColInfo, rowIndex, (const char*)&tagVal.i64, false);

×

4991

        QUERY_CHECK_CODE(code, lino, _end);

×

4996

_end:

×

4997

  if (code != TSDB_CODE_SUCCESS) {

×

4998

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

5000

  return code;

×

5003

static int32_t tagScanFillResultBlock(SOperatorInfo* pOperator, SSDataBlock* pRes, SArray* aUidTags,

×

5005

  int32_t       code = TSDB_CODE_SUCCESS;

×

5006

  int32_t       lino = 0;

×

5007

  STagScanInfo* pInfo = pOperator->info;

×

5008

  SExprInfo*    pExprInfo = &pOperator->exprSupp.pExprInfo[0];

×

5009

  if (!ignoreFilterIdx) {

×

5010

    size_t szTables = taosArrayGetSize(aFilterIdxs);

×

5011

    for (int i = 0; i < szTables; ++i) {

×

5012

      int32_t       idx = *(int32_t*)taosArrayGet(aFilterIdxs, i);

×

5013

      STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, idx);

×

5014

      QUERY_CHECK_NULL(pUidTagInfo, code, lino, _end, terrno);

×

5015

      for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {

×

5016

        SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);

×

5017

        QUERY_CHECK_NULL(pDst, code, lino, _end, terrno);

×

5018

        code = tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode);

×

5019

        QUERY_CHECK_CODE(code, lino, _end);

×

5023

    size_t szTables = taosArrayGetSize(aUidTags);

×

5024

    for (int i = 0; i < szTables; ++i) {

×

5025

      STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, i);

×

5026

      QUERY_CHECK_NULL(pUidTagInfo, code, lino, _end, terrno);

×

5027

      for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {

×

5028

        SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);

×

5029

        QUERY_CHECK_NULL(pDst, code, lino, _end, terrno);

×

5030

        code = tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode);

×

5031

        QUERY_CHECK_CODE(code, lino, _end);

×

5036

_end:

×

5037

  if (code != TSDB_CODE_SUCCESS) {

×

5038

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

5040

  return code;

×

5043

static int32_t doTagScanFromCtbIdxNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

×

5044

  int32_t        code = TSDB_CODE_SUCCESS;

×

5045

  int32_t        lino = 0;

×

5046

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

×

5047

  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;

×

5049

  STagScanInfo* pInfo = pOperator->info;

×

5050

  SSDataBlock*  pRes = pInfo->pRes;

×

5052

  QRY_PARAM_CHECK(ppRes);

×

5054

  if (pOperator->status == OP_EXEC_DONE) {

×

5055

    return TSDB_CODE_SUCCESS;

×

5057

  blockDataCleanup(pRes);

×

5059

  if (pInfo->pCtbCursor == NULL) {

×

5060

    pInfo->pCtbCursor = pAPI->metaFn.openCtbCursor(pInfo->readHandle.vnode, pInfo->suid, 1);

×

5061

    QUERY_CHECK_NULL(pInfo->pCtbCursor, code, lino, _end, terrno);

×

5063

    code = pAPI->metaFn.resumeCtbCursor(pInfo->pCtbCursor, 0);

×

5064

    QUERY_CHECK_CODE(code, lino, _end);

×

5067

  SArray* aUidTags = pInfo->aUidTags;

×

5068

  SArray* aFilterIdxs = pInfo->aFilterIdxs;

×

5069

  int32_t count = 0;

×

5070

  bool    ctbCursorFinished = false;

×

5071

  while (1) {

×

5072

    taosArrayClearEx(aUidTags, tagScanFreeUidTag);

×

5073

    taosArrayClear(aFilterIdxs);

×

5075

    int32_t numTables = 0;

×

5076

    while (numTables < pOperator->resultInfo.capacity) {

×

5077

      SMCtbCursor* pCur = pInfo->pCtbCursor;

×

5078

      tb_uid_t     uid = pAPI->metaFn.ctbCursorNext(pInfo->pCtbCursor);

×

5079

      if (uid == 0) {

×

5080

        ctbCursorFinished = true;

×

5081

        break;

×

5083

      STUidTagInfo info = {.uid = uid, .pTagVal = pCur->pVal};

×

5084

      info.pTagVal = taosMemoryMalloc(pCur->vLen);

×

5085

      QUERY_CHECK_NULL(info.pTagVal, code, lino, _end, terrno);

×

5087

      memcpy(info.pTagVal, pCur->pVal, pCur->vLen);

×

5088

      void* tmp = taosArrayPush(aUidTags, &info);

×

5089

      QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

×

5090

      ++numTables;

×

5093

    if (numTables == 0) {

×

5094

      break;

×

5096

    bool ignoreFilterIdx = true;

×

5097

    if (pInfo->pTagCond != NULL) {

×

5098

      ignoreFilterIdx = false;

×

5099

      code = tagScanFilterByTagCond(aUidTags, pInfo->pTagCond, aFilterIdxs, pInfo->readHandle.vnode, pAPI, pInfo);

×

5100

      QUERY_CHECK_CODE(code, lino, _end);

×

5102

      ignoreFilterIdx = true;

×

5105

    code = tagScanFillResultBlock(pOperator, pRes, aUidTags, aFilterIdxs, ignoreFilterIdx, pAPI);

×

5106

    QUERY_CHECK_CODE(code, lino, _end);

×

5108

    count = ignoreFilterIdx ? taosArrayGetSize(aUidTags) : taosArrayGetSize(aFilterIdxs);

×

5110

    if (count != 0) {

×

5111

      break;

×

5115

  if (count > 0) {

×

5116

    pAPI->metaFn.pauseCtbCursor(pInfo->pCtbCursor);

×

5118

  if (count == 0 || ctbCursorFinished) {

×

5119

    pAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);

×

5120

    pInfo->pCtbCursor = NULL;

×

5121

    setOperatorCompleted(pOperator);

×

5124

  pRes->info.rows = count;

×

5125

  bool bLimitReached = applyLimitOffset(&pInfo->limitInfo, pRes, pTaskInfo);

×

5126

  if (bLimitReached) {

×

5127

    setOperatorCompleted(pOperator);

×

5130

  pOperator->resultInfo.totalRows += pRes->info.rows;

×

5131

  (*ppRes) = (pRes->info.rows == 0) ? NULL : pInfo->pRes;

×

5133

_end:

×

5134

  if (code != TSDB_CODE_SUCCESS) {

×

5135

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

5136

    pTaskInfo->code = code;

×

5137

    T_LONG_JMP(pTaskInfo->env, code);

×

5140

  return code;

×

5143

static int32_t doTagScanFromMetaEntryNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

×

5144

  int32_t code = TSDB_CODE_SUCCESS;

×

5145

  int32_t lino = 0;

×

5146

  if (pOperator->status == OP_EXEC_DONE) {

×

5147

    (*ppRes) = NULL;

×

5148

    return code;

×

5151

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

×

5152

  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;

×

5154

  STagScanInfo* pInfo = pOperator->info;

×

5155

  SExprInfo*    pExprInfo = &pOperator->exprSupp.pExprInfo[0];

×

5156

  SSDataBlock*  pRes = pInfo->pRes;

×

5157

  blockDataCleanup(pRes);

×

5159

  int32_t size = 0;

×

5160

  code = tableListGetSize(pInfo->pTableListInfo, &size);

×

5161

  QUERY_CHECK_CODE(code, lino, _end);

×

5163

  if (size == 0) {

×

5164

    setTaskStatus(pTaskInfo, TASK_COMPLETED);

×

5165

    (*ppRes) = NULL;

×

5166

    return code;

×

5169

  SMetaReader mr = {0};

×

5170

  pAPI->metaReaderFn.initReader(&mr, pInfo->readHandle.vnode, META_READER_LOCK, &pAPI->metaFn);

×

5171

  pRes->info.rows = 0;

×

5173

  while (pInfo->curPos < size && pRes->info.rows < pOperator->resultInfo.capacity) {

×

5174

    code = doTagScanOneTable(pOperator, pRes, &mr, &pTaskInfo->storageAPI);

×

5175

    if (code != TSDB_CODE_OUT_OF_MEMORY && code != TSDB_CODE_QRY_REACH_QMEM_THRESHOLD && code != TSDB_CODE_QRY_QUERY_MEM_EXHAUSTED) {

×

5177

      code = TSDB_CODE_SUCCESS;

×

5179

    QUERY_CHECK_CODE(code, lino, _end);

×

5181

    if (++pInfo->curPos >= size) {

×

5182

      setOperatorCompleted(pOperator);

×

5186

  pAPI->metaReaderFn.clearReader(&mr);

×

5187

  bool bLimitReached = applyLimitOffset(&pInfo->limitInfo, pRes, pTaskInfo);

×

5188

  if (bLimitReached) {

×

5189

    setOperatorCompleted(pOperator);

×

5193

  if (pOperator->status == OP_EXEC_DONE) {

×

5194

    setTaskStatus(pTaskInfo, TASK_COMPLETED);

×

5197

  pOperator->resultInfo.totalRows += pRes->info.rows;

×

5199

  (*ppRes) = (pRes->info.rows == 0) ? NULL : pInfo->pRes;

×

5201

_end:

×

5202

  if (code != TSDB_CODE_SUCCESS) {

×

5203

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

5204

    pTaskInfo->code = code;

×

5205

    T_LONG_JMP(pTaskInfo->env, code);

×

5207

  return code;

×

5210

static SSDataBlock* doTagScanFromMetaEntry(SOperatorInfo* pOperator) {

×

5211

  SSDataBlock* pRes = NULL;

×

5212

  int32_t      code = doTagScanFromMetaEntryNext(pOperator, &pRes);

×

5213

  return pRes;

×

5216

static void destroyTagScanOperatorInfo(void* param) {

×

5217

  STagScanInfo* pInfo = (STagScanInfo*)param;

×

5218

  if (pInfo->pCtbCursor != NULL && pInfo->pStorageAPI != NULL) {

×

5219

    pInfo->pStorageAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);

×

5221

  taosHashCleanup(pInfo->filterCtx.colHash);

×

5222

  taosArrayDestroy(pInfo->filterCtx.cInfoList);

×

5223

  taosArrayDestroy(pInfo->aFilterIdxs);

×

5224

  taosArrayDestroyEx(pInfo->aUidTags, tagScanFreeUidTag);

×

5226

  blockDataDestroy(pInfo->pRes);

×

5227

  taosArrayDestroy(pInfo->matchInfo.pList);

×

5228

  tableListDestroy(pInfo->pTableListInfo);

×

5230

  pInfo->pRes = NULL;

×

5231

  pInfo->pTableListInfo = NULL;

×

5232

  taosMemoryFreeClear(param);

×

5233

×

5235

int32_t createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysiNode* pTagScanNode,

×

5238

  QRY_PARAM_CHECK(pOptrInfo);

×

5240

  int32_t         code = TSDB_CODE_SUCCESS;

×

5241

  int32_t         lino = 0;

×

5242

  SScanPhysiNode* pPhyNode = (SScanPhysiNode*)pTagScanNode;

×

5243

  STagScanInfo*   pInfo = taosMemoryCalloc(1, sizeof(STagScanInfo));

×

5244

  SOperatorInfo*  pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));

×

5245

  if (pInfo == NULL || pOperator == NULL) {

×

5246

    code = terrno;

×

5247

    goto _error;

×

5250

  SDataBlockDescNode* pDescNode = pPhyNode->node.pOutputDataBlockDesc;

×

5252

  int32_t    numOfExprs = 0;

×

5253

  SExprInfo* pExprInfo = NULL;

×

5255

  code = createExprInfo(pPhyNode->pScanPseudoCols, NULL, &pExprInfo, &numOfExprs);

×

5256

  QUERY_CHECK_CODE(code, lino, _error);

×

5258

  code = initExprSupp(&pOperator->exprSupp, pExprInfo, numOfExprs, &pTaskInfo->storageAPI.functionStore);

×

5259

  QUERY_CHECK_CODE(code, lino, _error);

×

5261

  int32_t num = 0;

×

5262

  code = extractColMatchInfo(pPhyNode->pScanPseudoCols, pDescNode, &num, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo);

×

5263

  QUERY_CHECK_CODE(code, lino, _error);

×

5265

  pInfo->pTagCond = pTagCond;

×

5266

  pInfo->pTagIndexCond = pTagIndexCond;

×

5267

  pInfo->suid = pPhyNode->suid;

×

5268

  pInfo->pStorageAPI = &pTaskInfo->storageAPI;

×

5270

  pInfo->pTableListInfo = pTableListInfo;

×

5271

  pInfo->pRes = createDataBlockFromDescNode(pDescNode);

×

5272

  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);

×

5274

  pInfo->readHandle = *pReadHandle;

×

5275

  pInfo->curPos = 0;

×

5277

  initLimitInfo(pPhyNode->node.pLimit, pPhyNode->node.pSlimit, &pInfo->limitInfo);

×

5278

  setOperatorInfo(pOperator, "TagScanOperator", QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN, false, OP_NOT_OPENED, pInfo,

×

5280

  initResultSizeInfo(&pOperator->resultInfo, 4096);

×

5281

  code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);

×

5282

  QUERY_CHECK_CODE(code, lino, _error);

×

5284

  if (pTagScanNode->onlyMetaCtbIdx) {

×

5285

    pInfo->aUidTags = taosArrayInit(pOperator->resultInfo.capacity, sizeof(STUidTagInfo));

×

5286

    QUERY_CHECK_NULL(pInfo->aUidTags, code, lino, _error, terrno);

×

5288

    pInfo->aFilterIdxs = taosArrayInit(pOperator->resultInfo.capacity, sizeof(int32_t));

×

5289

    QUERY_CHECK_NULL(pInfo->aFilterIdxs, code, lino, _error, terrno);

×

5291

    pInfo->filterCtx.colHash =

×

5292

        taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT), false, HASH_NO_LOCK);

×

5293

    QUERY_CHECK_NULL(pInfo->filterCtx.colHash, code, lino, _error, terrno);

×

5295

    pInfo->filterCtx.cInfoList = taosArrayInit(4, sizeof(SColumnInfo));

×

5296

    QUERY_CHECK_NULL(pInfo->filterCtx.cInfoList, code, lino, _error, terrno);

×

5298

    if (pInfo->pTagCond != NULL) {

×

5299

      nodesRewriteExprPostOrder(&pTagCond, tagScanRewriteTagColumn, (void*)&pInfo->filterCtx);

×

5303

  __optr_fn_t tagScanNextFn = (pTagScanNode->onlyMetaCtbIdx) ? doTagScanFromCtbIdxNext : doTagScanFromMetaEntryNext;

×

5304

  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, tagScanNextFn, NULL, destroyTagScanOperatorInfo,

×

5306

  *pOptrInfo = pOperator;

×

5307

  return code;

×

5309

_error:

×

5310

  if (pInfo) {

×

5311

    pInfo->pTableListInfo = NULL;

×

5314

  if (pInfo != NULL) destroyTagScanOperatorInfo(pInfo);

×

5315

  if (pOperator != NULL) {

×

5316

    pOperator->info = NULL;

×

5317

    destroyOperator(pOperator);

×

5319

  return code;

×

5324

static int32_t subTblRowCompareTsFn(const void* pLeft, const void* pRight, void* param) {

×

5325

  int32_t                 left = *(int32_t*)pLeft;

×

5326

  int32_t                 right = *(int32_t*)pRight;

×

5327

  STmsSubTablesMergeInfo* pInfo = (STmsSubTablesMergeInfo*)param;

×

5329

  int32_t leftIdx = pInfo->aInputs[left].rowIdx;

×

5330

  int32_t rightIdx = pInfo->aInputs[right].rowIdx;

×

5332

  if (leftIdx == -1) {

×

5333

    return 1;

×

5334

  } else if (rightIdx == -1) {

×

5335

    return -1;

×

5338

  int64_t leftTs = pInfo->aInputs[left].aTs[leftIdx];

×

5339

  int64_t rightTs = pInfo->aInputs[right].aTs[rightIdx];

×

5340

  int32_t ret = leftTs > rightTs ? 1 : ((leftTs < rightTs) ? -1 : 0);

×

5341

  if (pInfo->pTsOrderInfo->order == TSDB_ORDER_DESC) {

×

5342

    ret = -1 * ret;

×

5344

  return ret;

×

5347

static int32_t subTblRowCompareTsPkFn(const void* pLeft, const void* pRight, void* param) {

×

5348

  int32_t                 left = *(int32_t*)pLeft;

×

5349

  int32_t                 right = *(int32_t*)pRight;

×

5350

  STmsSubTablesMergeInfo* pInfo = (STmsSubTablesMergeInfo*)param;

×

5352

  int32_t leftIdx = pInfo->aInputs[left].rowIdx;

×

5353

  int32_t rightIdx = pInfo->aInputs[right].rowIdx;

×

5355

  if (leftIdx == -1) {

×

5356

    return 1;

×

5357

  } else if (rightIdx == -1) {

×

5358

    return -1;

×

5361

  int64_t leftTs = pInfo->aInputs[left].aTs[leftIdx];

×

5362

  int64_t rightTs = pInfo->aInputs[right].aTs[rightIdx];

×

5363

  int32_t ret = leftTs > rightTs ? 1 : ((leftTs < rightTs) ? -1 : 0);

×

5364

  if (pInfo->pTsOrderInfo->order == TSDB_ORDER_DESC) {

×

5365

    ret = -1 * ret;

×

5367

  if (ret == 0 && pInfo->pPkOrderInfo) {

×

5368

    ret = tsortComparBlockCell(pInfo->aInputs[left].pInputBlock, pInfo->aInputs[right].pInputBlock, leftIdx, rightIdx,

×

5369

                               pInfo->pPkOrderInfo);

×

5371

  return ret;

×

5374

int32_t dumpQueryTableCond(const SQueryTableDataCond* src, SQueryTableDataCond* dst) {

×

5375

  int32_t code = TSDB_CODE_SUCCESS;

×

5376

  int32_t lino = 0;

×

5377

  memcpy((void*)dst, (void*)src, sizeof(SQueryTableDataCond));

×

5378

  dst->colList = taosMemoryCalloc(src->numOfCols, sizeof(SColumnInfo));

×

5379

  QUERY_CHECK_NULL(dst->colList, code, lino, _end, terrno);

×

5380

  for (int i = 0; i < src->numOfCols; i++) {

×

5381

    dst->colList[i] = src->colList[i];

×

5384

_end:

×

5385

  if (code != TSDB_CODE_SUCCESS) {

×

5386

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

5388

  return code;

×

5391

static int32_t fetchNextSubTableBlockFromReader(SOperatorInfo* pOperator, STmsSubTableInput* pInput,

×

5393

  int32_t code = 0;

×

5395

  STableMergeScanInfo*    pInfo = pOperator->info;

×

5396

  SReadHandle*            pHandle = &pInfo->base.readHandle;

×

5397

  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;

×

5398

  SExecTaskInfo*          pTaskInfo = pOperator->pTaskInfo;

×

5399

  const SStorageAPI*      pAPI = &pTaskInfo->storageAPI;

×

5401

  blockDataCleanup(pInput->pReaderBlock);

×

5402

  if (!pInput->bInMemReader) {

×

5403

    code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, pInput->pKeyInfo, 1, pInput->pReaderBlock,

×

5404

                                         (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL);

×

5405

    if (code != 0) {

×

5406

      return code;

×

5410

  pInfo->base.dataReader = pInput->pReader;

×

5412

  while (true) {

×

5413

    bool hasNext = false;

×

5414

    code = pAPI->tsdReader.tsdNextDataBlock(pInfo->base.dataReader, &hasNext);

×

5415

    if (code != 0) {

×

5416

      pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->base.dataReader);

×

5417

      pInfo->base.dataReader = NULL;

×

5418

      return code;

×

5421

    if (!hasNext || isTaskKilled(pTaskInfo)) {

×

5422

      if (isTaskKilled(pTaskInfo)) {

×

5423

        pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->base.dataReader);

×

5424

        pInfo->base.dataReader = NULL;

×

5425

        return code;

×

5428

      *pSubTableHasBlock = false;

×

5429

      break;

×

5432

    if (pInput->tblCond.order == TSDB_ORDER_ASC) {

×

5433

      pInput->tblCond.twindows.skey = pInput->pReaderBlock->info.window.ekey + 1;

×

5435

      pInput->tblCond.twindows.ekey = pInput->pReaderBlock->info.window.skey - 1;

×

5438

    uint32_t status = 0;

×

5439

    code = loadDataBlock(pOperator, &pInfo->base, pInput->pReaderBlock, &status);

×

5440

    if (code != 0) {

×

5441

      pInfo->base.dataReader = NULL;

×

5442

      return code;

×

5445

    if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {

×

5446

      *pSubTableHasBlock = false;

×

5447

      break;

×

5449

    if (status == FUNC_DATA_REQUIRED_FILTEROUT || pInput->pReaderBlock->info.rows == 0) {

×

5450

      continue;

×

5453

    *pSubTableHasBlock = true;

×

5454

    break;

×

5457

  if (*pSubTableHasBlock) {

×

5458

    pInput->pReaderBlock->info.id.groupId =

×

5459

        tableListGetTableGroupId(pInfo->base.pTableListInfo, pInput->pReaderBlock->info.id.uid);

×

5460

    pOperator->resultInfo.totalRows += pInput->pReaderBlock->info.rows;

×

5462

  if (!pInput->bInMemReader || !*pSubTableHasBlock) {

×

5463

    pAPI->tsdReader.tsdReaderClose(pInput->pReader);

×

5464

    pInput->pReader = NULL;

×

5467

  pInfo->base.dataReader = NULL;

×

5468

  return TSDB_CODE_SUCCESS;

×

5471

static int32_t setGroupStartEndIndex(STableMergeScanInfo* pInfo) {

×

5472

  pInfo->bGroupProcessed = false;

×

5474

  int32_t numOfTables = 0;

×

5475

  int32_t code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);

×

5476

  if (code != TSDB_CODE_SUCCESS) {

×

5477

    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));

×

5478

    return code;

×

5481

  int32_t i = pInfo->tableStartIndex + 1;

×

5482

  for (; i < numOfTables; ++i) {

×

5483

    STableKeyInfo* tableKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i);

×

5484

    if (!tableKeyInfo) {

×

5485

      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));

×

5486

      return terrno;

×

5488

    if (tableKeyInfo->groupId != pInfo->groupId) {

×

5489

      break;

×

5492

  pInfo->tableEndIndex = i - 1;

×

5493

  return TSDB_CODE_SUCCESS;

×

5496

static int32_t openSubTablesMergeSort(STmsSubTablesMergeInfo* pSubTblsInfo) {

×

5497

  for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {

×

5498

    STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;

×

5499

    if (pInput->rowIdx == -1) {

×

5500

      continue;

×

5503

    if (pInput->type == SUB_TABLE_MEM_BLOCK) {

×

5504

      pInput->rowIdx = 0;

×

5505

      pInput->pageIdx = -1;

×

5508

    pInput->pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;

×

5509

    SColumnInfoData* col = taosArrayGet(pInput->pInputBlock->pDataBlock, pSubTblsInfo->pTsOrderInfo->slotId);

×

5510

    if (!col) {

×

5511

      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));

×

5512

      return terrno;

×

5514

    pInput->aTs = (int64_t*)col->pData;

×

5517

  __merge_compare_fn_t mergeCompareFn = (!pSubTblsInfo->pPkOrderInfo) ? subTblRowCompareTsFn : subTblRowCompareTsPkFn;

×

5518

  return tMergeTreeCreate(&pSubTblsInfo->pTree, pSubTblsInfo->numSubTables, pSubTblsInfo, mergeCompareFn);

×

5521

static int32_t initSubTablesMergeInfo(STableMergeScanInfo* pInfo) {

×

5522

  int32_t code = setGroupStartEndIndex(pInfo);

×

5523

  if (code != TSDB_CODE_SUCCESS) {

×

5524

    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));

×

5525

    return code;

×

5527

  STmsSubTablesMergeInfo* pSubTblsInfo = taosMemoryCalloc(1, sizeof(STmsSubTablesMergeInfo));

×

5528

  if (pSubTblsInfo == NULL) {

×

5529

    return terrno;

×

5531

  pSubTblsInfo->pTsOrderInfo = taosArrayGet(pInfo->pSortInfo, 0);

×

5532

  if (!pSubTblsInfo->pTsOrderInfo) {

×

5533

    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));

×

5534

    return terrno;

×

5536

  if (taosArrayGetSize(pInfo->pSortInfo) == 2) {

×

5537

    pSubTblsInfo->pPkOrderInfo = taosArrayGet(pInfo->pSortInfo, 1);

×

5538

    if (!pSubTblsInfo->pPkOrderInfo) {

×

5539

      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));

×

5540

      return terrno;

×

5543

    pSubTblsInfo->pPkOrderInfo = NULL;

×

5545

  pSubTblsInfo->numSubTables = pInfo->tableEndIndex - pInfo->tableStartIndex + 1;

×

5546

  pSubTblsInfo->aInputs = taosMemoryCalloc(pSubTblsInfo->numSubTables, sizeof(STmsSubTableInput));

×

5547

  if (pSubTblsInfo->aInputs == NULL) {

×

5548

    taosMemoryFree(pSubTblsInfo);

×

5549

    return terrno;

×

5551

  int32_t bufPageSize = pInfo->bufPageSize;

×

5552

  int32_t inMemSize = (pSubTblsInfo->numSubTables - pSubTblsInfo->numTableBlocksInMem) * bufPageSize;

×

5553

  code = createDiskbasedBuf(&pSubTblsInfo->pBlocksBuf, pInfo->bufPageSize, inMemSize, "blocksExternalBuf", tsTempDir);

×

5554

  if (code != TSDB_CODE_SUCCESS) {

×

5555

    taosMemoryFree(pSubTblsInfo->aInputs);

×

5556

    taosMemoryFree(pSubTblsInfo);

×

5557

    return code;

×

5559

  pSubTblsInfo->numTableBlocksInMem = pSubTblsInfo->numSubTables;

×

5560

  pSubTblsInfo->numInMemReaders = pSubTblsInfo->numSubTables;

×

5562

  pInfo->pSubTablesMergeInfo = pSubTblsInfo;

×

5563

  return TSDB_CODE_SUCCESS;

×

5566

static int32_t initSubTableInputs(SOperatorInfo* pOperator, STableMergeScanInfo* pInfo) {

×

5567

  int32_t        code = TSDB_CODE_SUCCESS;

×

5568

  int32_t        lino = 0;

×

5569

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

×

5570

  SReadHandle*   pHandle = &pInfo->base.readHandle;

×

5571

  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;

×

5573

  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;

×

5575

  for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {

×

5576

    STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;

×

5577

    pInput->type = SUB_TABLE_MEM_BLOCK;

×

5579

    code = dumpQueryTableCond(&pInfo->base.cond, &pInput->tblCond);

×

5580

    QUERY_CHECK_CODE(code, lino, _end);

×

5582

    code = createOneDataBlock(pInfo->pResBlock, false, &pInput->pReaderBlock);

×

5583

    QUERY_CHECK_CODE(code, lino, _end);

×

5585

    code = createOneDataBlock(pInfo->pResBlock, false, &pInput->pPageBlock);

×

5586

    QUERY_CHECK_CODE(code, lino, _end);

×

5588

    STableKeyInfo* keyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i + pInfo->tableStartIndex);

×

5589

    pInput->pKeyInfo = keyInfo;

×

5591

    if (isTaskKilled(pTaskInfo)) {

×

5592

      T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);

×

5595

    if (i + 1 < pSubTblsInfo->numInMemReaders) {

×

5596

      code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, keyInfo, 1, pInput->pReaderBlock,

×

5597

                                           (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL);

×

5598

      QUERY_CHECK_CODE(code, lino, _end);

×

5599

      pInput->bInMemReader = true;

×

5601

      pInput->pReader = NULL;

×

5602

      pInput->bInMemReader = false;

×

5604

    bool hasNext = true;

×

5605

    code = fetchNextSubTableBlockFromReader(pOperator, pInput, &hasNext);

×

5606

    QUERY_CHECK_CODE(code, lino, _end);

×

5607

    if (!hasNext) {

×

5608

      pInput->rowIdx = -1;

×

5609

      ++pSubTblsInfo->numSubTablesCompleted;

×

5610

      continue;

×

5612

      pInput->rowIdx = 0;

×

5613

      pInput->pageIdx = -1;

×

5617

_end:

×

5618

  if (code != TSDB_CODE_SUCCESS) {

×

5619

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

5621

  return code;

×

5624

static void adjustSubTableFromMemBlock(SOperatorInfo* pOperatorInfo, STmsSubTablesMergeInfo* pSubTblsInfo) {

×

5625

  int32_t              code = TSDB_CODE_SUCCESS;

×

5626

  int32_t              lino = 0;

×

5627

  SExecTaskInfo*       pTaskInfo = pOperatorInfo->pTaskInfo;

×

5628

  STableMergeScanInfo* pInfo = pOperatorInfo->info;

×

5629

  STmsSubTableInput*   pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);

×

5630

  bool                 hasNext = true;

×

5631

  code = fetchNextSubTableBlockFromReader(pOperatorInfo, pInput, &hasNext);

×

5632

  QUERY_CHECK_CODE(code, lino, _end);

×

5634

  if (!hasNext) {

×

5635

    pInput->rowIdx = -1;

×

5636

    ++pSubTblsInfo->numSubTablesCompleted;

×

5638

    pInput->rowIdx = 0;

×

5641

_end:

×

5642

  if (code != TSDB_CODE_SUCCESS) {

×

5643

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

5644

    pTaskInfo->code = code;

×

5645

    T_LONG_JMP(pTaskInfo->env, code);

×

5647

×

5649

static int32_t adjustSubTableForNextRow(SOperatorInfo* pOperatorInfo, STmsSubTablesMergeInfo* pSubTblsInfo) {

×

5650

  STableMergeScanInfo* pInfo = pOperatorInfo->info;

×

5651

  STmsSubTableInput*   pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);

×

5653

  SSDataBlock* pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;

×

5654

  if (pInput->rowIdx < pInputBlock->info.rows - 1) {

×

5655

    ++pInput->rowIdx;

×

5656

  } else if (pInput->rowIdx == pInputBlock->info.rows - 1) {

×

5657

    if (pInput->type == SUB_TABLE_MEM_BLOCK) {

×

5658

      adjustSubTableFromMemBlock(pOperatorInfo, pSubTblsInfo);

×

5660

    if (pInput->rowIdx != -1) {

×

5661

      SColumnInfoData* col = taosArrayGet(pInputBlock->pDataBlock, pSubTblsInfo->pTsOrderInfo->slotId);

×

5662

      if (!col) {

×

5663

        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));

×

5664

        return terrno;

×

5666

      pInput->pInputBlock = pInputBlock;

×

5667

      pInput->aTs = (int64_t*)col->pData;

×

5671

  return tMergeTreeAdjust(pSubTblsInfo->pTree, tMergeTreeGetAdjustIndex(pSubTblsInfo->pTree));

×

5674

static int32_t appendChosenRowToDataBlock(STmsSubTablesMergeInfo* pSubTblsInfo, SSDataBlock* pBlock) {

×

5675

  int32_t            code = TSDB_CODE_SUCCESS;

×

5676

  int32_t            lino = 0;

×

5677

  STmsSubTableInput* pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);

×

5678

  SSDataBlock*       pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;

×

5680

  for (int32_t i = 0; i < taosArrayGetSize(pBlock->pDataBlock); ++i) {

×

5681

    SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, i);

×

5682

    QUERY_CHECK_NULL(pColInfo, code, lino, _end, terrno);

×

5684

    SColumnInfoData* pSrcColInfo = taosArrayGet(pInputBlock->pDataBlock, i);

×

5685

    QUERY_CHECK_NULL(pSrcColInfo, code, lino, _end, terrno);

×

5686

    bool isNull = colDataIsNull(pSrcColInfo, pInputBlock->info.rows, pInput->rowIdx, NULL);

×

5688

    if (isNull) {

×

5689

      code = colDataSetVal(pColInfo, pBlock->info.rows, NULL, true);

×

5690

      QUERY_CHECK_CODE(code, lino, _end);

×

5692

      if (pSrcColInfo->pData != NULL) {

×

5693

        char* pData = colDataGetData(pSrcColInfo, pInput->rowIdx);

×

5694

        code = colDataSetVal(pColInfo, pBlock->info.rows, pData, false);

×

5695

        QUERY_CHECK_CODE(code, lino, _end);

×

5699

  pBlock->info.dataLoad = 1;

×

5700

  pBlock->info.scanFlag = pInputBlock->info.scanFlag;

×

5701

  pBlock->info.rows += 1;

×

5703

_end:

×

5704

  if (code != TSDB_CODE_SUCCESS) {

×

5705

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

5707

  return code;

×

5710

static int32_t getSubTablesSortedBlock(SOperatorInfo* pOperator, SSDataBlock* pBlock, int32_t capacity,

×

5712

  int32_t                 code = TSDB_CODE_SUCCESS;

×

5713

  int32_t                 lino = 0;

×

5714

  STableMergeScanInfo*    pInfo = pOperator->info;

×

5715

  SExecTaskInfo*          pTaskInfo = pOperator->pTaskInfo;

×

5716

  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;

×

5717

  bool                    finished = false;

×

5719

  QRY_PARAM_CHECK(pResBlock);

×

5721

  blockDataCleanup(pBlock);

×

5723

  while (true) {

×

5725

      if (pSubTblsInfo->numSubTablesCompleted >= pSubTblsInfo->numSubTables) {

×

5726

        finished = true;

×

5727

        break;

×

5730

      code = appendChosenRowToDataBlock(pSubTblsInfo, pBlock);

×

5731

      QUERY_CHECK_CODE(code, lino, _end);

×

5733

      code = adjustSubTableForNextRow(pOperator, pSubTblsInfo);

×

5734

      QUERY_CHECK_CODE(code, lino, _end);

×

5736

      if (pBlock->info.rows >= capacity) {

×

5737

        break;

×

5741

    if (isTaskKilled(pTaskInfo)) {

×

5742

      return pTaskInfo->code;

×

5745

    bool limitReached = applyLimitOffset(&pInfo->limitInfo, pBlock, pTaskInfo);

×

5746

    if (finished || limitReached || pBlock->info.rows > 0) {

×

5751

  if (pBlock->info.rows > 0) {

×

5752

    *pResBlock = pBlock;

×

5755

_end:

×

5756

  if (code != TSDB_CODE_SUCCESS) {

×

5757

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

5758

    pTaskInfo->code = code;

×

5760

  return code;

×

5763

static int32_t startSubTablesTableMergeScan(SOperatorInfo* pOperator) {

×

5764

  int32_t              code = TSDB_CODE_SUCCESS;

×

5765

  int32_t              lino = 0;

×

5766

  STableMergeScanInfo* pInfo = pOperator->info;

×

5768

  code = initSubTablesMergeInfo(pInfo);

×

5769

  QUERY_CHECK_CODE(code, lino, _end);

×

5771

  code = initSubTableInputs(pOperator, pInfo);

×

5772

  QUERY_CHECK_CODE(code, lino, _end);

×

5774

  code = openSubTablesMergeSort(pInfo->pSubTablesMergeInfo);

×

5775

  QUERY_CHECK_CODE(code, lino, _end);

×

5777

_end:

×

5778

  if (code != TSDB_CODE_SUCCESS) {

×

5779

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

5781

  return code;

×

5784

static void stopSubTablesTableMergeScan(STableMergeScanInfo* pInfo) {

×

5785

  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;

×

5786

  if (pSubTblsInfo != NULL) {

×

5787

    tMergeTreeDestroy(&pSubTblsInfo->pTree);

×

5789

    for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {

×

5790

      STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;

×

5791

      taosMemoryFree(pInput->tblCond.colList);

×

5792

      blockDataDestroy(pInput->pReaderBlock);

×

5793

      blockDataDestroy(pInput->pPageBlock);

×

5794

      taosArrayDestroy(pInput->aBlockPages);

×

5795

      pInfo->base.readerAPI.tsdReaderClose(pInput->pReader);

×

5796

      pInput->pReader = NULL;

×

5799

    destroyDiskbasedBuf(pSubTblsInfo->pBlocksBuf);

×

5800

    taosMemoryFree(pSubTblsInfo->aInputs);

×

5802

    taosMemoryFree(pSubTblsInfo);

×

5803

    pInfo->pSubTablesMergeInfo = NULL;

×

5807

×

5809

int32_t doTableMergeScanParaSubTablesNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

×

5810

  QRY_PARAM_CHECK(ppRes);

×

5812

  int32_t lino = 0;

×

5813

  int32_t tableListSize = 0;

×

5814

  int64_t st = taosGetTimestampUs();

×

5816

  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;

×

5817

  STableMergeScanInfo* pInfo = pOperator->info;

×

5819

  if (pOperator->status == OP_EXEC_DONE) {

×

5820

    return TSDB_CODE_SUCCESS;

×

5823

  int32_t code = pOperator->fpSet._openFn(pOperator);

×

5824

  QUERY_CHECK_CODE(code, lino, _end);

×

5826

  code = tableListGetSize(pInfo->base.pTableListInfo, &tableListSize);

×

5827

  QUERY_CHECK_CODE(code, lino, _end);

×

5829

  if (!pInfo->hasGroupId) {

×

5830

    pInfo->hasGroupId = true;

×

5832

    if (tableListSize == 0) {

×

5833

      setOperatorCompleted(pOperator);

×

5834

      (*ppRes) = NULL;

×

5835

      return code;

×

5838

    pInfo->tableStartIndex = 0;

×

5839

    STableKeyInfo* pTmpGpId = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);

×

5840

    QUERY_CHECK_NULL(pTmpGpId, code, lino, _end, terrno);

×

5841

    pInfo->groupId = pTmpGpId->groupId;

×

5842

    code = startSubTablesTableMergeScan(pOperator);

×

5843

    QUERY_CHECK_CODE(code, lino, _end);

×

5846

  SSDataBlock* pBlock = NULL;

×

5847

  while (pInfo->tableStartIndex < tableListSize) {

×

5848

    if (isTaskKilled(pTaskInfo)) {

×

5849

      break;

×

5852

    code = getSubTablesSortedBlock(pOperator, pInfo->pResBlock, pOperator->resultInfo.capacity, &pBlock);

×

5853

    QUERY_CHECK_CODE(code, lino, _end);

×

5855

    if (pBlock == NULL && !pInfo->bGroupProcessed && pInfo->needCountEmptyTable) {

×

5856

      STableKeyInfo* tbInfo = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);

×

5857

      QUERY_CHECK_NULL(tbInfo, code, lino, _end, terrno);

×

5859

      pBlock = getOneRowResultBlock(pTaskInfo, &pInfo->base, pInfo->pResBlock, tbInfo);

×

5862

    if (pBlock != NULL) {

×

5863

      pBlock->info.id.groupId = pInfo->groupId;

×

5864

      pOperator->resultInfo.totalRows += pBlock->info.rows;

×

5865

      pInfo->bGroupProcessed = true;

×

5866

      break;

×

5869

      stopSubTablesTableMergeScan(pInfo);

×

5870

      if (pInfo->tableEndIndex >= tableListSize - 1) {

×

5871

        setOperatorCompleted(pOperator);

×

5872

        break;

×

5875

      pInfo->tableStartIndex = pInfo->tableEndIndex + 1;

×

5876

      STableKeyInfo* pTmpGpId = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);

×

5877

      QUERY_CHECK_NULL(pTmpGpId, code, lino, _end, terrno);

×

5879

      pInfo->groupId = pTmpGpId->groupId;

×

5880

      code = startSubTablesTableMergeScan(pOperator);

×

5881

      QUERY_CHECK_CODE(code, lino, _end);

×

5882

      resetLimitInfoForNextGroup(&pInfo->limitInfo);

×

5886

  pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;

×

5888

_end:

×

5889

  if (code != TSDB_CODE_SUCCESS) {

×

5890

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

5891

    pTaskInfo->code = code;

×

5892

    T_LONG_JMP(pTaskInfo->env, code);

×

5894

    (*ppRes) = pBlock;

×

5897

  return code;

×

5900

static void tableMergeScanDoSkipTable(uint64_t uid, void* pTableMergeOpInfo) {

×

5901

  int32_t              code = TSDB_CODE_SUCCESS;

×

5902

  int32_t              lino = 0;

×

5903

  SOperatorInfo*       pOperator = (SOperatorInfo*)pTableMergeOpInfo;

×

5904

  STableMergeScanInfo* pInfo = pOperator->info;

×

5905

  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;

×

5907

  if (pInfo->mSkipTables == NULL) {

×

5908

    pInfo->mSkipTables = taosHashInit(pInfo->tableEndIndex - pInfo->tableStartIndex + 1,

×

5910

    QUERY_CHECK_NULL(pInfo->mSkipTables, code, lino, _end, terrno);

×

5912

  int bSkip = 1;

×

5913

  if (pInfo->mSkipTables != NULL) {

×

5914

    code = taosHashPut(pInfo->mSkipTables, &uid, sizeof(uid), &bSkip, sizeof(bSkip));

×

5915

    if (code == TSDB_CODE_DUP_KEY) {

×

5916

      code = TSDB_CODE_SUCCESS;

×

5918

    QUERY_CHECK_CODE(code, lino, _end);

×

5921

_end:

×

5922

  if (code != TSDB_CODE_SUCCESS) {

×

5923

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

5924

    pTaskInfo->code = code;

×

5925

    T_LONG_JMP(pTaskInfo->env, code);

×

5927

×

5929

static int32_t doGetBlockForTableMergeScan(SOperatorInfo* pOperator, bool* pFinished, bool* pSkipped) {

×

5930

  STableMergeScanInfo* pInfo = pOperator->info;

×

5931

  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;

×

5932

  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;

×

5933

  SSDataBlock*         pBlock = pInfo->pReaderBlock;

×

5934

  int32_t              code = 0;

×

5935

  bool                 hasNext = false;

×

5936

  STsdbReader*         reader = pInfo->base.dataReader;

×

5938

  code = pAPI->tsdReader.tsdNextDataBlock(reader, &hasNext);

×

5939

  if (code != 0) {

×

5940

    pAPI->tsdReader.tsdReaderReleaseDataBlock(reader);

×

5941

    qError("table merge scan fetch next data block error code: %d, %s", code, GET_TASKID(pTaskInfo));

×

5942

    pTaskInfo->code = code;

×

5943

    return code;

×

5946

  if (!hasNext || isTaskKilled(pTaskInfo)) {

×

5947

    if (isTaskKilled(pTaskInfo)) {

×

5948

      qInfo("table merge scan fetch next data block found task killed. %s", GET_TASKID(pTaskInfo));

×

5949

      pAPI->tsdReader.tsdReaderReleaseDataBlock(reader);

×

5951

    *pFinished = true;

×

5952

    return code;

×

5955

  uint32_t status = 0;

×

5956

  code = loadDataBlock(pOperator, &pInfo->base, pBlock, &status);

×

5958

  if (code != TSDB_CODE_SUCCESS) {

×

5959

    qInfo("table merge scan load datablock code %d, %s", code, GET_TASKID(pTaskInfo));

×

5960

    pTaskInfo->code = code;

×

5961

    return code;

×

5964

  if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {

×

5965

    *pFinished = true;

×

5966

    return code;

×

5970

  if (status == FUNC_DATA_REQUIRED_FILTEROUT || pBlock->info.rows == 0) {

×

5971

    *pSkipped = true;

×

5972

    return code;

×

5975

  return code;

×

5978

static int32_t getBlockForTableMergeScan(void* param, SSDataBlock** ppBlock) {

×

5979

  STableMergeScanSortSourceParam* source = param;

×

5981

  SOperatorInfo*       pOperator = source->pOperator;

×

5982

  STableMergeScanInfo* pInfo = pOperator->info;

×

5983

  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;

×

5984

  SSDataBlock*         pBlock = NULL;

×

5985

  int64_t              st = taosGetTimestampUs();

×

5986

  int32_t              code = TSDB_CODE_SUCCESS;

×

5989

    if (pInfo->rtnNextDurationBlocks) {

×

5990

      qDebug("%s table merge scan return already fetched new duration blocks. index %d num of blocks %d",

×

5993

      if (pInfo->nextDurationBlocksIdx < pInfo->numNextDurationBlocks) {

×

5994

        pBlock = pInfo->nextDurationBlocks[pInfo->nextDurationBlocksIdx];

×

5995

        ++pInfo->nextDurationBlocksIdx;

×

5997

        for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {

×

5998

          blockDataDestroy(pInfo->nextDurationBlocks[i]);

×

5999

          pInfo->nextDurationBlocks[i] = NULL;

×

6002

        pInfo->rtnNextDurationBlocks = false;

×

6003

        pInfo->nextDurationBlocksIdx = 0;

×

6004

        pInfo->numNextDurationBlocks = 0;

×

6005

        continue;

×

6008

      bool bFinished = false;

×

6009

      bool bSkipped = false;

×

6011

      code = doGetBlockForTableMergeScan(pOperator, &bFinished, &bSkipped);

×

6012

      if (code != 0) {

×

6013

        return code;

×

6016

      pBlock = pInfo->pReaderBlock;

×

6017

      qDebug("%s table merge scan fetch block. finished %d skipped %d next-duration-block %d new-fileset %d",

×

6019

      if (bFinished) {

×

6020

        pInfo->bNewFilesetEvent = false;

×

6021

        break;

×

6024

      if (pInfo->bNextDurationBlockEvent || pInfo->bNewFilesetEvent) {

×

6025

        if (!bSkipped) {

×

6026

          code = createOneDataBlock(pBlock, true, &pInfo->nextDurationBlocks[pInfo->numNextDurationBlocks]);

×

6027

          if (code) {

×

6028

            *ppBlock = NULL;

×

6029

            return code;

×

6032

          ++pInfo->numNextDurationBlocks;

×

6033

          if (pInfo->numNextDurationBlocks > 2) {

×

6034

            qError("%s table merge scan prefetch %d next duration blocks. end early.", GET_TASKID(pTaskInfo),

×

6036

            pInfo->bNewFilesetEvent = false;

×

6037

            break;

×

6041

        if (pInfo->bNewFilesetEvent) {

×

6042

          pInfo->rtnNextDurationBlocks = true;

×

6043

          *ppBlock = NULL;

×

6044

          return code;

×

6047

        if (pInfo->bNextDurationBlockEvent) {

×

6048

          pInfo->bNextDurationBlockEvent = false;

×

6049

          continue;

×

6052

      if (bSkipped) continue;

×

6055

    pBlock->info.id.groupId = tableListGetTableGroupId(pInfo->base.pTableListInfo, pBlock->info.id.uid);

×

6057

    pOperator->resultInfo.totalRows += pBlock->info.rows;

×

6058

    pInfo->base.readRecorder.elapsedTime += (taosGetTimestampUs() - st) / 1000.0;

×

6059

    *ppBlock = pBlock;

×

6061

    return code;

×

6064

  *ppBlock = NULL;

×

6065

  return code;

×

6068

int32_t generateSortByTsPkInfo(SArray* colMatchInfo, int32_t order, SArray** ppSortArray) {

×

6069

  int32_t code = TSDB_CODE_SUCCESS;

×

6070

  int32_t lino = 0;

×

6071

  SArray* pSortInfo = taosArrayInit(1, sizeof(SBlockOrderInfo));

×

6072

  QUERY_CHECK_NULL(pSortInfo, code, lino, _end, terrno);

×

6073

  SBlockOrderInfo biTs = {0};

×

6074

  SBlockOrderInfo biPk = {0};

×

6076

  int32_t tsTargetSlotId = 0;

×

6077

  int32_t pkTargetSlotId = -1;

×

6078

  for (int32_t i = 0; i < taosArrayGetSize(colMatchInfo); ++i) {

×

6079

    SColMatchItem* colInfo = taosArrayGet(colMatchInfo, i);

×

6080

    QUERY_CHECK_NULL(colInfo, code, lino, _end, terrno);

×

6081

    if (colInfo->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {

×

6082

      tsTargetSlotId = colInfo->dstSlotId;

×

6083

      biTs.order = order;

×

6084

      biTs.slotId = tsTargetSlotId;

×

6085

      biTs.nullFirst = (order == TSDB_ORDER_ASC);

×

6086

      biTs.compFn = getKeyComparFunc(TSDB_DATA_TYPE_TIMESTAMP, order);

×

6089

    if (colInfo->isPk) {

×

6090

      pkTargetSlotId = colInfo->dstSlotId;

×

6091

      biPk.order = order;

×

6092

      biPk.slotId = pkTargetSlotId;

×

6093

      biPk.nullFirst = (order == TSDB_ORDER_ASC);

×

6094

      biPk.compFn = getKeyComparFunc(colInfo->dataType.type, order);

×

6098

  void* tmp = taosArrayPush(pSortInfo, &biTs);

×

6099

  QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

×

6100

  if (pkTargetSlotId != -1) {

×

6101

    tmp = taosArrayPush(pSortInfo, &biPk);

×

6102

    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

×

6105

  (*ppSortArray) = pSortInfo;

×

6107

_end:

×

6108

  if (code != TSDB_CODE_SUCCESS) {

×

6109

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

6111

  return code;

×

6114

void tableMergeScanTsdbNotifyCb(ETsdReaderNotifyType type, STsdReaderNotifyInfo* info, void* param) {

×

6115

  STableMergeScanInfo* pTmsInfo = param;

×

6116

  if (type == TSD_READER_NOTIFY_DURATION_START) {

×

6117

    pTmsInfo->bNewFilesetEvent = true;

×

6118

  } else if (type == TSD_READER_NOTIFY_NEXT_DURATION_BLOCK) {

×

6119

    pTmsInfo->bNextDurationBlockEvent = true;

×

6121

  qDebug("table merge scan receive notification. type %d, fileset %d", type, info->duration.filesetId);

×

6123

  return;

×

6126

int32_t startDurationForGroupTableMergeScan(SOperatorInfo* pOperator) {

×

6127

  STableMergeScanInfo* pInfo = pOperator->info;

×

6128

  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;

×

6130

  int32_t code = TSDB_CODE_SUCCESS;

×

6131

  int32_t lino = 0;

×

6132

  int32_t numOfTable = pInfo->tableEndIndex - pInfo->tableStartIndex + 1;

×

6134

  qDebug("%s table merge scan start duration ", GET_TASKID(pTaskInfo));

×

6135

  pInfo->bNewFilesetEvent = false;

×

6136

  pInfo->bNextDurationBlockEvent = false;

×

6138

  pInfo->sortBufSize = 2048 * pInfo->bufPageSize;

×

6139

  int32_t numOfBufPage = pInfo->sortBufSize / pInfo->bufPageSize;

×

6141

  pInfo->pSortHandle = NULL;

×

6142

  code = tsortCreateSortHandle(pInfo->pSortInfo, SORT_BLOCK_TS_MERGE, pInfo->bufPageSize, numOfBufPage,

×

6143

                               pInfo->pSortInputBlock, pTaskInfo->id.str, 0, 0, 0, &pInfo->pSortHandle);

×

6144

  if (code) {

×

6145

    return code;

×

6148

  if (pInfo->bSortRowId && numOfTable != 1) {

×

6149

    int32_t memSize = 512 * 1024 * 1024;

×

6150

    code = tsortSetSortByRowId(pInfo->pSortHandle, memSize);

×

6151

    QUERY_CHECK_CODE(code, lino, _end);

×

6154

  tsortSetMergeLimit(pInfo->pSortHandle, pInfo->mergeLimit);

×

6155

  tsortSetMergeLimitReachedFp(pInfo->pSortHandle, tableMergeScanDoSkipTable, pOperator);

×

6156

  tsortSetAbortCheckFn(pInfo->pSortHandle, isTaskKilled, pOperator->pTaskInfo);

×

6158

  tsortSetFetchRawDataFp(pInfo->pSortHandle, getBlockForTableMergeScan, NULL, NULL);

×

6159

  QUERY_CHECK_CODE(code, lino, _end);

×

6161

  STableMergeScanSortSourceParam* param = taosMemoryCalloc(1, sizeof(STableMergeScanSortSourceParam));

×

6162

  QUERY_CHECK_NULL(param, code, lino, _end, terrno);

×

6163

  param->pOperator = pOperator;

×

6165

  SSortSource* ps = taosMemoryCalloc(1, sizeof(SSortSource));

×

6166

  if (ps == NULL) {

×

6167

    taosMemoryFree(param);

×

6168

    QUERY_CHECK_NULL(ps, code, lino, _end, terrno);

×

6171

  ps->param = param;

×

6172

  ps->onlyRef = false;

×

6173

  code = tsortAddSource(pInfo->pSortHandle, ps);

×

6174

  QUERY_CHECK_CODE(code, lino, _end);

×

6176

  if (numOfTable == 1) {

×

6177

    tsortSetSingleTableMerge(pInfo->pSortHandle);

×

6179

    code = tsortOpen(pInfo->pSortHandle);

×

6180

    QUERY_CHECK_CODE(code, lino, _end);

×

6183

_end:

×

6184

  if (code != TSDB_CODE_SUCCESS) {

×

6185

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

6187

  return code;

×

6190

void stopDurationForGroupTableMergeScan(SOperatorInfo* pOperator) {

×

6191

  STableMergeScanInfo* pInfo = pOperator->info;

×

6192

  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;

×

6193

  qDebug("%s table merge scan stop duration ", GET_TASKID(pTaskInfo));

×

6195

  SSortExecInfo sortExecInfo = tsortGetSortExecInfo(pInfo->pSortHandle);

×

6196

  pInfo->sortExecInfo.sortMethod = sortExecInfo.sortMethod;

×

6197

  pInfo->sortExecInfo.sortBuffer = sortExecInfo.sortBuffer;

×

6198

  pInfo->sortExecInfo.loops += sortExecInfo.loops;

×

6199

  pInfo->sortExecInfo.readBytes += sortExecInfo.readBytes;

×

6200

  pInfo->sortExecInfo.writeBytes += sortExecInfo.writeBytes;

×

6202

  tsortDestroySortHandle(pInfo->pSortHandle);

×

6203

  pInfo->pSortHandle = NULL;

×

6204

×

6206

void startGroupTableMergeScan(SOperatorInfo* pOperator) {

×

6207

  int32_t              code = TSDB_CODE_SUCCESS;

×

6208

  int32_t              lino = 0;

×

6209

  STableMergeScanInfo* pInfo = pOperator->info;

×

6210

  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;

×

6211

  SReadHandle*         pHandle = &pInfo->base.readHandle;

×

6212

  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;

×

6213

  qDebug("%s table merge scan start group %" PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId);

×

6216

    int32_t numOfTables = 0;

×

6217

    code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);

×

6218

    QUERY_CHECK_CODE(code, lino, _end);

×

6220

    int32_t i = pInfo->tableStartIndex + 1;

×

6221

    for (; i < numOfTables; ++i) {

×

6222

      STableKeyInfo* tableKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i);

×

6223

      QUERY_CHECK_NULL(tableKeyInfo, code, lino, _end, terrno);

×

6224

      if (tableKeyInfo->groupId != pInfo->groupId) {

×

6225

        break;

×

6228

    pInfo->tableEndIndex = i - 1;

×

6230

  pInfo->bGroupProcessed = false;

×

6231

  int32_t tableStartIdx = pInfo->tableStartIndex;

×

6232

  int32_t tableEndIdx = pInfo->tableEndIndex;

×

6234

  int32_t        numOfTable = tableEndIdx - tableStartIdx + 1;

×

6235

  STableKeyInfo* startKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, tableStartIdx);

×

6236

  code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInfo->base.cond, startKeyInfo, numOfTable, pInfo->pReaderBlock,

×

6237

                                       (void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), &pInfo->mSkipTables);

×

6238

  QUERY_CHECK_CODE(code, lino, _end);

×

6239

  if (pInfo->filesetDelimited) {

×

6240

    pAPI->tsdReader.tsdSetFilesetDelimited(pInfo->base.dataReader);

×

6242

  pAPI->tsdReader.tsdSetSetNotifyCb(pInfo->base.dataReader, tableMergeScanTsdbNotifyCb, pInfo);

×

6244

  code = startDurationForGroupTableMergeScan(pOperator);

×

6245

  QUERY_CHECK_CODE(code, lino, _end);

×

6247

_end:

×

6248

  if (code != TSDB_CODE_SUCCESS) {

×

6249

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

6250

    pTaskInfo->code = code;

×

6251

    T_LONG_JMP(pTaskInfo->env, code);

×

6253

×

6255

void stopGroupTableMergeScan(SOperatorInfo* pOperator) {

×

6256

  STableMergeScanInfo* pInfo = pOperator->info;

×

6257

  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;

×

6258

  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;

×

6260

  stopDurationForGroupTableMergeScan(pOperator);

×

6262

  if (pInfo->base.dataReader != NULL) {

×

6263

    pAPI->tsdReader.tsdReaderClose(pInfo->base.dataReader);

×

6264

    pInfo->base.dataReader = NULL;

×

6266

  for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {

×

6267

    if (pInfo->nextDurationBlocks[i]) {

×

6268

      blockDataDestroy(pInfo->nextDurationBlocks[i]);

×

6269

      pInfo->nextDurationBlocks[i] = NULL;

×

6271

    pInfo->numNextDurationBlocks = 0;

×

6272

    pInfo->nextDurationBlocksIdx = 0;

×

6274

  resetLimitInfoForNextGroup(&pInfo->limitInfo);

×

6275

  taosHashCleanup(pInfo->mSkipTables);

×

6276

  pInfo->mSkipTables = NULL;

×

6277

  qDebug("%s table merge scan stop group %" PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId);

×

6278

×

6282

SSDataBlock* getSortedTableMergeScanBlockData(SSortHandle* pHandle, SSDataBlock* pResBlock, int32_t capacity,

×

6284

  STableMergeScanInfo* pInfo = pOperator->info;

×

6285

  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;

×

6286

  STupleHandle*        pTupleHandle = NULL;

×

6288

  blockDataCleanup(pResBlock);

×

6290

  while (1) {

×

6291

    while (1) {

×

6292

      pTupleHandle = NULL;

×

6293

      int32_t code = tsortNextTuple(pHandle, &pTupleHandle);

×

6294

      if (code != TSDB_CODE_SUCCESS) {

×

6295

        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));

×

6296

        T_LONG_JMP(pOperator->pTaskInfo->env, code);

×

6298

      if (pTupleHandle == NULL) {

×

6299

        break;

×

6302

      code = tsortAppendTupleToBlock(pInfo->pSortHandle, pResBlock, pTupleHandle);

×

6303

      if (code != TSDB_CODE_SUCCESS) {

×

6304

        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));

×

6305

        T_LONG_JMP(pOperator->pTaskInfo->env, terrno);

×

6308

      if (pResBlock->info.rows >= capacity) {

×

6309

        break;

×

6313

    if (tsortIsClosed(pHandle)) {

×

6314

      terrno = TSDB_CODE_TSC_QUERY_CANCELLED;

×

6315

      T_LONG_JMP(pOperator->pTaskInfo->env, terrno);

×

6318

    bool limitReached = applyLimitOffset(&pInfo->limitInfo, pResBlock, pTaskInfo);

×

6319

    qDebug("%s get sorted row block, rows:%" PRId64 ", limit:%" PRId64, GET_TASKID(pTaskInfo), pResBlock->info.rows,

×

6321

    if (pTupleHandle == NULL || limitReached || pResBlock->info.rows > 0) {

×

6325

  return (pResBlock->info.rows > 0) ? pResBlock : NULL;

×

6328

int32_t doTableMergeScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

×

6329

  if (pOperator->status == OP_EXEC_DONE) {

×

6330

    (*ppRes) = NULL;

×

6331

    return TSDB_CODE_SUCCESS;

×

6334

  int32_t              code = TSDB_CODE_SUCCESS;

×

6335

  int32_t              lino = 0;

×

6336

  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;

×

6337

  STableMergeScanInfo* pInfo = pOperator->info;

×

6339

  code = pOperator->fpSet._openFn(pOperator);

×

6340

  QUERY_CHECK_CODE(code, lino, _end);

×

6342

  int64_t st = taosGetTimestampUs();

×

6344

  int32_t tableListSize = 0;

×

6345

  code = tableListGetSize(pInfo->base.pTableListInfo, &tableListSize);

×

6346

  QUERY_CHECK_CODE(code, lino, _end);

×

6348

  if (!pInfo->hasGroupId) {

×

6349

    pInfo->hasGroupId = true;

×

6351

    if (tableListSize == 0) {

×

6352

      setOperatorCompleted(pOperator);

×

6353

      (*ppRes) = NULL;

×

6354

      return code;

×

6356

    pInfo->tableStartIndex = 0;

×

6357

    STableKeyInfo* tmp = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);

×

6358

    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

×

6359

    pInfo->groupId = tmp->groupId;

×

6360

    startGroupTableMergeScan(pOperator);

×

6363

  SSDataBlock* pBlock = NULL;

×

6364

  while (pInfo->tableStartIndex < tableListSize) {

×

6365

    if (isTaskKilled(pTaskInfo)) {

×

6366

      goto _end;

×

6369

    pBlock = getSortedTableMergeScanBlockData(pInfo->pSortHandle, pInfo->pResBlock, pOperator->resultInfo.capacity,

×

6371

    if (pBlock == NULL && !pInfo->bGroupProcessed && pInfo->needCountEmptyTable) {

×

6372

      STableKeyInfo* tbInfo = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);

×

6373

      QUERY_CHECK_NULL(tbInfo, code, lino, _end, terrno);

×

6374

      pBlock = getOneRowResultBlock(pTaskInfo, &pInfo->base, pInfo->pResBlock, tbInfo);

×

6376

    if (pBlock != NULL) {

×

6377

      pBlock->info.id.groupId = pInfo->groupId;

×

6378

      pOperator->resultInfo.totalRows += pBlock->info.rows;

×

6379

      pInfo->bGroupProcessed = true;

×

6380

      break;

×

6382

      if (pInfo->bNewFilesetEvent) {

×

6383

        stopDurationForGroupTableMergeScan(pOperator);

×

6384

        code = startDurationForGroupTableMergeScan(pOperator);

×

6385

        QUERY_CHECK_CODE(code, lino, _end);

×

6388

        stopGroupTableMergeScan(pOperator);

×

6389

        if (pInfo->tableEndIndex >= tableListSize - 1) {

×

6390

          setOperatorCompleted(pOperator);

×

6391

          break;

×

6394

        pInfo->tableStartIndex = pInfo->tableEndIndex + 1;

×

6395

        STableKeyInfo* tmp = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);

×

6396

        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

×

6397

        pInfo->groupId = tmp->groupId;

×

6398

        startGroupTableMergeScan(pOperator);

×

6399

        resetLimitInfoForNextGroup(&pInfo->limitInfo);

×

6404

  pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;

×

6406

_end:

×

6407

  if (code != TSDB_CODE_SUCCESS) {

×

6408

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

6409

    pTaskInfo->code = code;

×

6410

    T_LONG_JMP(pTaskInfo->env, code);

×

6412

    (*ppRes) = pBlock;

×

6415

  return code;

×

6418

static SSDataBlock* doTableMergeScan(SOperatorInfo* pOperator) {

×

6419

  SSDataBlock* pRes = NULL;

×

6420

  int32_t      code = doTableMergeScanNext(pOperator, &pRes);

×

6421

  return pRes;

×

6424

void destroyTableMergeScanOperatorInfo(void* param) {

×

6425

  STableMergeScanInfo* pTableScanInfo = (STableMergeScanInfo*)param;

×

6428

  if (pTableScanInfo->base.readerAPI.tsdReaderClose != NULL) {

×

6429

    pTableScanInfo->base.readerAPI.tsdReaderClose(pTableScanInfo->base.dataReader);

×

6430

    pTableScanInfo->base.dataReader = NULL;

×

6433

  for (int32_t i = 0; i < pTableScanInfo->numNextDurationBlocks; ++i) {

×

6434

    if (pTableScanInfo->nextDurationBlocks[i] != NULL) {

×

6435

      blockDataDestroy(pTableScanInfo->nextDurationBlocks[i]);

×

6436

      pTableScanInfo->nextDurationBlocks[i] = NULL;

×

6440

  tsortDestroySortHandle(pTableScanInfo->pSortHandle);

×

6441

  pTableScanInfo->pSortHandle = NULL;

×

6442

  taosHashCleanup(pTableScanInfo->mSkipTables);

×

6443

  pTableScanInfo->mSkipTables = NULL;

×

6444

  blockDataDestroy(pTableScanInfo->pSortInputBlock);

×

6445

  pTableScanInfo->pSortInputBlock = NULL;

×

6448

  cleanupQueryTableDataCond(&pTableScanInfo->base.cond);

×

6449

  destroyTableScanBase(&pTableScanInfo->base, &pTableScanInfo->base.readerAPI);

×

6451

  blockDataDestroy(pTableScanInfo->pResBlock);

×

6452

  pTableScanInfo->pResBlock = NULL;

×

6455

  blockDataDestroy(pTableScanInfo->pReaderBlock);

×

6456

  pTableScanInfo->pReaderBlock = NULL;

×

6457

  taosArrayDestroy(pTableScanInfo->pSortInfo);

×

6459

  stopSubTablesTableMergeScan(pTableScanInfo);

×

6461

  taosMemoryFreeClear(param);

×

6462

×

6464

int32_t getTableMergeScanExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len) {

×

6465

  if (pOptr == NULL) {

×

6466

    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_INVALID_PARA));

×

6467

    return TSDB_CODE_INVALID_PARA;

×

6470

  STableMergeScanExecInfo* execInfo = taosMemoryCalloc(1, sizeof(STableMergeScanExecInfo));

×

6471

  if (!execInfo) {

×

6472

    return terrno;

×

6474

  STableMergeScanInfo* pInfo = pOptr->info;

×

6475

  execInfo->blockRecorder = pInfo->base.readRecorder;

×

6476

  execInfo->sortExecInfo = pInfo->sortExecInfo;

×

6478

  *pOptrExplain = execInfo;

×

6479

  *len = sizeof(STableMergeScanExecInfo);

×

6481

  return TSDB_CODE_SUCCESS;

×

6484

int32_t createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle,

×

6487

  QRY_PARAM_CHECK(pOptrInfo);

×

6489

  int32_t              code = TSDB_CODE_SUCCESS;

×

6490

  int32_t              lino = 0;

×

6491

  STableMergeScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableMergeScanInfo));

×

6492

  SOperatorInfo*       pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));

×

6493

  if (pInfo == NULL || pOperator == NULL) {

×

6494

    code = terrno;

×

6495

    goto _error;

×

6498

  SDataBlockDescNode* pDescNode = pTableScanNode->scan.node.pOutputDataBlockDesc;

×

6500

  int32_t numOfCols = 0;

×

6501

  code = extractColMatchInfo(pTableScanNode->scan.pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID,

×

6503

  QUERY_CHECK_CODE(code, lino, _error);

×

6505

  code = initQueryTableDataCond(&pInfo->base.cond, pTableScanNode, readHandle);

×

6506

  QUERY_CHECK_CODE(code, lino, _error);

×

6508

  if (pTableScanNode->scan.pScanPseudoCols != NULL) {

×

6509

    SExprSupp* pSup = &pInfo->base.pseudoSup;

×

6510

    code = createExprInfo(pTableScanNode->scan.pScanPseudoCols, NULL, &pSup->pExprInfo, &pSup->numOfExprs);

×

6511

    QUERY_CHECK_CODE(code, lino, _error);

×

6513

    pSup->pCtx = createSqlFunctionCtx(pSup->pExprInfo, pSup->numOfExprs, &pSup->rowEntryInfoOffset,

×

6515

    QUERY_CHECK_NULL(pSup->pCtx, code, lino, _error, terrno);

×

6518

  pInfo->scanInfo = (SScanInfo){.numOfAsc = pTableScanNode->scanSeq[0], .numOfDesc = pTableScanNode->scanSeq[1]};

×

6520

  pInfo->base.metaCache.pTableMetaEntryCache = taosLRUCacheInit(1024 * 128, -1, .5);

×

6521

  QUERY_CHECK_NULL(pInfo->base.metaCache.pTableMetaEntryCache, code, lino, _error, terrno);

×

6523

  pInfo->base.readerAPI = pTaskInfo->storageAPI.tsdReader;

×

6524

  pInfo->base.dataBlockLoadFlag = FUNC_DATA_REQUIRED_DATA_LOAD;

×

6525

  pInfo->base.scanFlag = MAIN_SCAN;

×

6526

  pInfo->base.readHandle = *readHandle;

×

6528

  pInfo->readIdx = -1;

×

6530

  pInfo->base.limitInfo.limit.limit = -1;

×

6531

  pInfo->base.limitInfo.slimit.limit = -1;

×

6532

  pInfo->base.pTableListInfo = pTableListInfo;

×

6534

  pInfo->sample.sampleRatio = pTableScanNode->ratio;

×

6535

  pInfo->sample.seed = taosGetTimestampSec();

×

6537

  code = filterInitFromNode((SNode*)pTableScanNode->scan.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);

×

6538

  QUERY_CHECK_CODE(code, lino, _error);

×

6540

  initLimitInfo(pTableScanNode->scan.node.pLimit, pTableScanNode->scan.node.pSlimit, &pInfo->limitInfo);

×

6542

  pInfo->mergeLimit = -1;

×

6543

  bool hasLimit = pInfo->limitInfo.limit.limit != -1 || pInfo->limitInfo.limit.offset != -1;

×

6544

  if (hasLimit) {

×

6545

    pInfo->mergeLimit = pInfo->limitInfo.limit.limit + pInfo->limitInfo.limit.offset;

×

6546

    pInfo->mSkipTables = NULL;

×

6549

  initResultSizeInfo(&pOperator->resultInfo, 1024);

×

6550

  pInfo->pResBlock = createDataBlockFromDescNode(pDescNode);

×

6551

  QUERY_CHECK_NULL(pInfo->pResBlock, code, lino, _error, terrno);

×

6552

  code = blockDataEnsureCapacity(pInfo->pResBlock, pOperator->resultInfo.capacity);

×

6553

  QUERY_CHECK_CODE(code, lino, _error);

×

6554

  if (!hasLimit && blockDataGetRowSize(pInfo->pResBlock) >= 256 && !pTableScanNode->smallDataTsSort) {

×

6555

    pInfo->bSortRowId = true;

×

6557

    pInfo->bSortRowId = false;

×

6560

  code = prepareDataBlockBuf(pInfo->pResBlock, &pInfo->base.matchInfo);

×

6561

  QUERY_CHECK_CODE(code, lino, _error);

×

6563

  code = generateSortByTsPkInfo(pInfo->base.matchInfo.pList, pInfo->base.cond.order, &pInfo->pSortInfo);

×

6564

  QUERY_CHECK_CODE(code, lino, _error);

×

6566

  code = createOneDataBlock(pInfo->pResBlock, false, &pInfo->pReaderBlock);

×

6567

  QUERY_CHECK_CODE(code, lino, _error);

×

6569

  pInfo->needCountEmptyTable = tsCountAlwaysReturnValue && pTableScanNode->needCountEmptyTable;

×

6571

  int32_t  rowSize = pInfo->pResBlock->info.rowSize;

×

6572

  uint32_t nCols = taosArrayGetSize(pInfo->pResBlock->pDataBlock);

×

6574

  pInfo->bufPageSize = getProperSortPageSize(rowSize, nCols);

×

6577

  code = createOneDataBlock(pInfo->pResBlock, false, &pInfo->pSortInputBlock);

×

6578

  QUERY_CHECK_CODE(code, lino, _error);

×

6580

  if (!tsExperimental) {

×

6581

    pInfo->filesetDelimited = false;

×

6583

    pInfo->filesetDelimited = pTableScanNode->filesetDelimited;

×

6586

  setOperatorInfo(pOperator, "TableMergeScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN, false, OP_NOT_OPENED,

×

6588

  pOperator->exprSupp.numOfExprs = numOfCols;

×

6590

  pOperator->fpSet = createOperatorFpSet(

×

6591

      optrDummyOpenFn, pTableScanNode->paraTablesSort ? doTableMergeScanParaSubTablesNext : doTableMergeScanNext, NULL,

×

6594

  pOperator->cost.openCost = 0;

×

6596

  *pOptrInfo = pOperator;

×

6597

  return code;

×

6599

_error:

×

6600

  if (code != TSDB_CODE_SUCCESS) {

×

6601

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

6603

  pTaskInfo->code = code;

×

6604

  if (pInfo != NULL) {

×

6605

    pInfo->base.pTableListInfo = NULL;

×

6606

    destroyTableMergeScanOperatorInfo(pInfo);

×

6608

  if (pOperator != NULL) {

×

6609

    pOperator->info = NULL;

×

6610

    destroyOperator(pOperator);

×

6612

  return code;

×

6636

int32_t tblCountScanGetGroupTagsSlotId(const SNodeList* scanCols, STableCountScanSupp* supp) {

×

6637

  if (scanCols != NULL) {

×

6638

    SNode* pNode = NULL;

×

6639

    FOREACH(pNode, scanCols) {

×

6640

      if (nodeType(pNode) != QUERY_NODE_TARGET) {

×

6641

        return TSDB_CODE_QRY_SYS_ERROR;

×

6643

      STargetNode* targetNode = (STargetNode*)pNode;

×

6644

      if (nodeType(targetNode->pExpr) != QUERY_NODE_COLUMN) {

×

6645

        return TSDB_CODE_QRY_SYS_ERROR;

×

6647

      SColumnNode* colNode = (SColumnNode*)(targetNode->pExpr);

×

6648

      if (strcmp(colNode->colName, GROUP_TAG_DB_NAME) == 0) {

×

6649

        supp->dbNameSlotId = targetNode->slotId;

×

6650

      } else if (strcmp(colNode->colName, GROUP_TAG_STABLE_NAME) == 0) {

×

6651

        supp->stbNameSlotId = targetNode->slotId;

×

6655

  return TSDB_CODE_SUCCESS;

×

6658

int32_t tblCountScanGetCountSlotId(const SNodeList* pseudoCols, STableCountScanSupp* supp) {

×

6659

  if (pseudoCols != NULL) {

×

6660

    SNode* pNode = NULL;

×

6661

    FOREACH(pNode, pseudoCols) {

×

6662

      if (nodeType(pNode) != QUERY_NODE_TARGET) {

×

6663

        return TSDB_CODE_QRY_SYS_ERROR;

×

6665

      STargetNode* targetNode = (STargetNode*)pNode;

×

6666

      if (nodeType(targetNode->pExpr) != QUERY_NODE_FUNCTION) {

×

6667

        return TSDB_CODE_QRY_SYS_ERROR;

×

6669

      SFunctionNode* funcNode = (SFunctionNode*)(targetNode->pExpr);

×

6670

      if (funcNode->funcType == FUNCTION_TYPE_TABLE_COUNT) {

×

6671

        supp->tbCountSlotId = targetNode->slotId;

×

6675

  return TSDB_CODE_SUCCESS;

×

6678

int32_t tblCountScanGetInputs(SNodeList* groupTags, SName* tableName, STableCountScanSupp* supp) {

×

6679

  if (groupTags != NULL) {

×

6680

    SNode* pNode = NULL;

×

6681

    FOREACH(pNode, groupTags) {

×

6682

      if (nodeType(pNode) != QUERY_NODE_COLUMN) {

×

6683

        return TSDB_CODE_QRY_SYS_ERROR;

×

6685

      SColumnNode* colNode = (SColumnNode*)pNode;

×

6686

      if (strcmp(colNode->colName, GROUP_TAG_DB_NAME) == 0) {

×

6687

        supp->groupByDbName = true;

×

6689

      if (strcmp(colNode->colName, GROUP_TAG_STABLE_NAME) == 0) {

×

6690

        supp->groupByStbName = true;

×

6694

    tstrncpy(supp->dbNameFilter, tNameGetDbNameP(tableName), TSDB_DB_NAME_LEN);

×

6695

    tstrncpy(supp->stbNameFilter, tNameGetTableName(tableName), TSDB_TABLE_NAME_LEN);

×

6697

  return TSDB_CODE_SUCCESS;

×

6700

int32_t getTableCountScanSupp(SNodeList* groupTags, SName* tableName, SNodeList* scanCols, SNodeList* pseudoCols,

×

6702

  int32_t code = 0;

×

6703

  code = tblCountScanGetInputs(groupTags, tableName, supp);

×

6704

  if (code != TSDB_CODE_SUCCESS) {

×

6705

    qError("%s get table count scan supp. get inputs error", GET_TASKID(taskInfo));

×

6706

    return code;

×

6709

  supp->dbNameSlotId = -1;

×

6710

  supp->stbNameSlotId = -1;

×

6711

  supp->tbCountSlotId = -1;

×

6713

  code = tblCountScanGetGroupTagsSlotId(scanCols, supp);

×

6714

  if (code != TSDB_CODE_SUCCESS) {

×

6715

    qError("%s get table count scan supp. get group tags slot id error", GET_TASKID(taskInfo));

×

6716

    return code;

×

6719

  code = tblCountScanGetCountSlotId(pseudoCols, supp);

×

6720

  if (code != TSDB_CODE_SUCCESS) {

×

6721

    qError("%s get table count scan supp. get count error", GET_TASKID(taskInfo));

×

6722

    return code;

×

6724

  return code;

×

6727

int32_t createTableCountScanOperatorInfo(SReadHandle* readHandle, STableCountScanPhysiNode* pTblCountScanNode,

×

6729

  QRY_PARAM_CHECK(pOptrInfo);

×

6731

  int32_t                      code = TSDB_CODE_SUCCESS;

×

6732

  int32_t                      lino = 0;

×

6733

  SScanPhysiNode*              pScanNode = &pTblCountScanNode->scan;

×

6734

  STableCountScanOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STableCountScanOperatorInfo));

×

6735

  SOperatorInfo*               pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));

×

6736

  if (!pInfo || !pOperator) {

×

6737

    code = terrno;

×

6738

    goto _error;

×

6741

  pInfo->readHandle = *readHandle;

×

6743

  SDataBlockDescNode* pDescNode = pScanNode->node.pOutputDataBlockDesc;

×

6744

  initResultSizeInfo(&pOperator->resultInfo, 1);

×

6745

  pInfo->pRes = createDataBlockFromDescNode(pDescNode);

×

6746

  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);

×

6748

  code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);

×

6749

  QUERY_CHECK_CODE(code, lino, _error);

×

6751

  code = getTableCountScanSupp(pTblCountScanNode->pGroupTags, &pTblCountScanNode->scan.tableName,

×

6754

  QUERY_CHECK_CODE(code, lino, _error);

×

6756

  setOperatorInfo(pOperator, "TableCountScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN, false, OP_NOT_OPENED,

×

6758

  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableCountScanNext, NULL, destoryTableCountScanOperator,

×

6760

  *pOptrInfo = pOperator;

×

6761

  return code;

×

6763

_error:

×

6764

  if (pInfo != NULL) {

×

6765

    destoryTableCountScanOperator(pInfo);

×

6767

  if (pOperator != NULL) {

×

6768

    pOperator->info = NULL;

×

6769

    destroyOperator(pOperator);

×

6771

  pTaskInfo->code = code;

×

6772

  return code;

×

6775

int32_t fillTableCountScanDataBlock(STableCountScanSupp* pSupp, char* dbName, char* stbName, int64_t count,

×

6777

  int32_t code = TSDB_CODE_SUCCESS;

×

6778

  int32_t lino = 0;

×

6779

  if (pSupp->dbNameSlotId != -1) {

×

6780

    QUERY_CHECK_CONDITION((strlen(dbName) > 0), code, lino, _end, TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);

×

6781

    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->dbNameSlotId);

×

6782

    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);

×

6784

    char varDbName[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};

×

6785

    tstrncpy(varDataVal(varDbName), dbName, TSDB_DB_NAME_LEN);

×

6787

    varDataSetLen(varDbName, strlen(dbName));

×

6788

    code = colDataSetVal(colInfoData, 0, varDbName, false);

×

6789

    QUERY_CHECK_CODE(code, lino, _end);

×

6792

  if (pSupp->stbNameSlotId != -1) {

×

6793

    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->stbNameSlotId);

×

6794

    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);

×

6795

    if (strlen(stbName) != 0) {

×

6796

      char varStbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};

×

6797

      tstrncpy(varDataVal(varStbName), stbName, TSDB_TABLE_NAME_LEN);

×

6798

      varDataSetLen(varStbName, strlen(stbName));

×

6799

      code = colDataSetVal(colInfoData, 0, varStbName, false);

×

6800

      QUERY_CHECK_CODE(code, lino, _end);

×

6806

  if (pSupp->tbCountSlotId != -1) {

×

6807

    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->tbCountSlotId);

×

6808

    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);

×

6809

    code = colDataSetVal(colInfoData, 0, (char*)&count, false);

×

6810

    QUERY_CHECK_CODE(code, lino, _end);

×

6812

  pRes->info.rows = 1;

×

6814

_end:

×

6815

  if (code != TSDB_CODE_SUCCESS) {

×

6816

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

6818

  return code;

×

6821

static SSDataBlock* buildSysDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo) {

×

6822

  STableCountScanSupp* pSupp = &pInfo->supp;

×

6823

  SSDataBlock*         pRes = pInfo->pRes;

×

6826

  getInfosDbMeta(NULL, &infodbTableNum);

×

6827

  infodbTableNum -= 1;

×

6829

  getPerfDbMeta(NULL, &perfdbTableNum);

×

6831

  if (pSupp->groupByDbName || pSupp->groupByStbName) {

×

6832

    buildSysDbGroupedTableCount(pOperator, pInfo, pSupp, pRes, infodbTableNum, perfdbTableNum);

×

6833

    return (pRes->info.rows > 0) ? pRes : NULL;

×

6835

    buildSysDbFilterTableCount(pOperator, pSupp, pRes, infodbTableNum, perfdbTableNum);

×

6836

    return (pRes->info.rows > 0) ? pRes : NULL;

×

6840

static void buildSysDbFilterTableCount(SOperatorInfo* pOperator, STableCountScanSupp* pSupp, SSDataBlock* pRes,

×

6842

  int32_t        code = TSDB_CODE_SUCCESS;

×

6843

  int32_t        lino = 0;

×

6844

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

×

6845

  if (strcmp(pSupp->dbNameFilter, TSDB_INFORMATION_SCHEMA_DB) == 0) {

×

6846

    code = fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB, "", infodbTableNum, pRes);

×

6847

    QUERY_CHECK_CODE(code, lino, _end);

×

6848

  } else if (strcmp(pSupp->dbNameFilter, TSDB_PERFORMANCE_SCHEMA_DB) == 0) {

×

6849

    code = fillTableCountScanDataBlock(pSupp, TSDB_PERFORMANCE_SCHEMA_DB, "", perfdbTableNum, pRes);

×

6850

    QUERY_CHECK_CODE(code, lino, _end);

×

6851

  } else if (strlen(pSupp->dbNameFilter) == 0) {

×

6852

    code = fillTableCountScanDataBlock(pSupp, "", "", infodbTableNum + perfdbTableNum, pRes);

×

6853

    QUERY_CHECK_CODE(code, lino, _end);

×

6856

_end:

×

6857

  if (code != TSDB_CODE_SUCCESS) {

×

6858

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

6859

    pTaskInfo->code = code;

×

6860

    T_LONG_JMP(pTaskInfo->env, code);

×

6862

  setOperatorCompleted(pOperator);

×

6863

×

6865

static void buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,

×

6868

  int32_t        code = TSDB_CODE_SUCCESS;

×

6869

  int32_t        lino = 0;

×

6870

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

×

6871

  if (pInfo->currGrpIdx == 0) {

×

6872

    uint64_t groupId = 0;

×

6873

    if (pSupp->groupByDbName) {

×

6874

      groupId = calcGroupId(TSDB_INFORMATION_SCHEMA_DB, strlen(TSDB_INFORMATION_SCHEMA_DB));

×

6876

      groupId = calcGroupId("", 0);

×

6879

    pRes->info.id.groupId = groupId;

×

6880

    code = fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB, "", infodbTableNum, pRes);

×

6881

    QUERY_CHECK_CODE(code, lino, _end);

×

6882

  } else if (pInfo->currGrpIdx == 1) {

×

6883

    uint64_t groupId = 0;

×

6884

    if (pSupp->groupByDbName) {

×

6885

      groupId = calcGroupId(TSDB_PERFORMANCE_SCHEMA_DB, strlen(TSDB_PERFORMANCE_SCHEMA_DB));

×

6887

      groupId = calcGroupId("", 0);

×

6890

    pRes->info.id.groupId = groupId;

×

6891

    code = fillTableCountScanDataBlock(pSupp, TSDB_PERFORMANCE_SCHEMA_DB, "", perfdbTableNum, pRes);

×

6892

    QUERY_CHECK_CODE(code, lino, _end);

×

6894

    setOperatorCompleted(pOperator);

×

6896

  pInfo->currGrpIdx++;

×

6898

_end:

×

6899

  if (code != TSDB_CODE_SUCCESS) {

×

6900

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

6901

    pTaskInfo->code = code;

×

6902

    T_LONG_JMP(pTaskInfo->env, code);

×

6904

×

6906

static int32_t doTableCountScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

×

6907

  int32_t                      code = TSDB_CODE_SUCCESS;

×

6908

  SExecTaskInfo*               pTaskInfo = pOperator->pTaskInfo;

×

6909

  STableCountScanOperatorInfo* pInfo = pOperator->info;

×

6910

  STableCountScanSupp*         pSupp = &pInfo->supp;

×

6911

  SSDataBlock*                 pRes = pInfo->pRes;

×

6913

  blockDataCleanup(pRes);

×

6914

  QRY_PARAM_CHECK(ppRes);

×

6916

  if (pOperator->status == OP_EXEC_DONE) {

×

6917

    return code;

×

6920

  if (pInfo->readHandle.mnd != NULL) {

×

6921

    (*ppRes) = buildSysDbTableCount(pOperator, pInfo);

×

6922

    return code;

×

6925

  code = buildVnodeDbTableCount(pOperator, pInfo, pSupp, pRes);

×

6926

  if (code != TSDB_CODE_SUCCESS) {

×

6927

    qError("%s failed since %s", __func__, tstrerror(code));

×

6928

    pTaskInfo->code = code;

×

6929

    T_LONG_JMP(pTaskInfo->env, code);

×

6931

  if (pRes->info.rows > 0) {

×

6932

    *ppRes = pRes;

×

6935

  return code;

×

6938

static int32_t buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,

×

6940

  int32_t        code = TSDB_CODE_SUCCESS;

×

6941

  int32_t        lino = 0;

×

6942

  const char*    db = NULL;

×

6943

  int32_t        vgId = 0;

×

6944

  char           dbName[TSDB_DB_NAME_LEN] = {0};

×

6945

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

×

6946

  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;

×

6949

  pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, &db, &vgId, NULL, NULL);

×

6950

  SName sn = {0};

×

6952

  code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB);

×

6953

  QUERY_CHECK_CODE(code, lino, _end);

×

6955

  code = tNameGetDbName(&sn, dbName);

×

6956

  QUERY_CHECK_CODE(code, lino, _end);

×

6958

  if (pSupp->groupByDbName || pSupp->groupByStbName) {

×

6959

    code = buildVnodeGroupedTableCount(pOperator, pInfo, pSupp, pRes, vgId, dbName);

×

6961

    code = buildVnodeFilteredTbCount(pOperator, pInfo, pSupp, pRes, dbName);

×

6964

_end:

×

6965

  if (code != TSDB_CODE_SUCCESS) {

×

6966

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

6967

    pTaskInfo->code = code;

×

6970

  return code;

×

6973

static int32_t buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,

×

6975

  int32_t        code = TSDB_CODE_SUCCESS;

×

6976

  int32_t        lino = 0;

×

6977

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

×

6978

  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;

×

6980

  if (pSupp->groupByStbName) {

×

6981

    if (pInfo->stbUidList == NULL) {

×

6982

      pInfo->stbUidList = taosArrayInit(16, sizeof(tb_uid_t));

×

6983

      QUERY_CHECK_NULL(pInfo->stbUidList, code, lino, _end, terrno);

×

6984

      code = pAPI->metaFn.storeGetTableList(pInfo->readHandle.vnode, TSDB_SUPER_TABLE, pInfo->stbUidList);

×

6985

      QUERY_CHECK_CODE(code, lino, _end);

×

6988

    if (pInfo->currGrpIdx < taosArrayGetSize(pInfo->stbUidList)) {

×

6989

      tb_uid_t stbUid = *(tb_uid_t*)taosArrayGet(pInfo->stbUidList, pInfo->currGrpIdx);

×

6990

      code = buildVnodeGroupedStbTableCount(pInfo, pSupp, pRes, dbName, stbUid, pAPI);

×

6991

      QUERY_CHECK_CODE(code, lino, _end);

×

6993

      pInfo->currGrpIdx++;

×

6994

    } else if (pInfo->currGrpIdx == taosArrayGetSize(pInfo->stbUidList)) {

×

6995

      code = buildVnodeGroupedNtbTableCount(pInfo, pSupp, pRes, dbName, pAPI);

×

6996

      QUERY_CHECK_CODE(code, lino, _end);

×

6998

      pInfo->currGrpIdx++;

×

7000

      setOperatorCompleted(pOperator);

×

7003

    uint64_t groupId = calcGroupId(dbName, strlen(dbName));

×

7004

    pRes->info.id.groupId = groupId;

×

7006

    int64_t dbTableCount = 0;

×

7007

    pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, &dbTableCount, NULL);

×

7008

    code = fillTableCountScanDataBlock(pSupp, dbName, "", dbTableCount, pRes);

×

7009

    QUERY_CHECK_CODE(code, lino, _end);

×

7010

    setOperatorCompleted(pOperator);

×

7013

_end:

×

7014

  if (code != TSDB_CODE_SUCCESS) {

×

7015

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

7016

    pTaskInfo->code = code;

×

7018

  return code;

×

7021

static int32_t buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,

×

7023

  int32_t        code = TSDB_CODE_SUCCESS;

×

7024

  int32_t        lino = 0;

×

7025

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

×

7026

  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;

×

7028

  if (strlen(pSupp->dbNameFilter) != 0) {

×

7029

    if (strlen(pSupp->stbNameFilter) != 0) {

×

7030

      uint64_t uid = 0;

×

7031

      code = pAPI->metaFn.getTableUidByName(pInfo->readHandle.vnode, pSupp->stbNameFilter, &uid);

×

7032

      QUERY_CHECK_CODE(code, lino, _end);

×

7034

      int64_t numOfChildTables = 0;

×

7035

      code = pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, uid, &numOfChildTables, NULL);

×

7036

      QUERY_CHECK_CODE(code, lino, _end);

×

7038

      code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, numOfChildTables, pRes);

×

7039

      QUERY_CHECK_CODE(code, lino, _end);

×

7041

      int64_t tbNumVnode = 0;

×

7042

      pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, &tbNumVnode, NULL);

×

7043

      code = fillTableCountScanDataBlock(pSupp, dbName, "", tbNumVnode, pRes);

×

7044

      QUERY_CHECK_CODE(code, lino, _end);

×

7047

    int64_t tbNumVnode = 0;

×

7048

    pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, &tbNumVnode, NULL);

×

7049

    code = fillTableCountScanDataBlock(pSupp, dbName, "", tbNumVnode, pRes);

×

7050

    QUERY_CHECK_CODE(code, lino, _end);

×

7053

_end:

×

7054

  if (code != TSDB_CODE_SUCCESS) {

×

7055

    pTaskInfo->code = code;

×

7056

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

7059

  setOperatorCompleted(pOperator);

×

7060

  return code;

×

7063

static int32_t buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,

×

7065

  int32_t code = TSDB_CODE_SUCCESS;

×

7066

  int32_t lino = 0;

×

7067

  char    fullStbName[TSDB_TABLE_FNAME_LEN] = {0};

×

7068

  if (pSupp->groupByDbName) {

×

7069

    snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s.%s", dbName, "");

×

7072

  uint64_t groupId = calcGroupId(fullStbName, strlen(fullStbName));

×

7073

  pRes->info.id.groupId = groupId;

×

7075

  int64_t numOfTables = 0;

×

7076

  pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, NULL, &numOfTables);

×

7078

  if (numOfTables != 0) {

×

7079

    code = fillTableCountScanDataBlock(pSupp, dbName, "", numOfTables, pRes);

×

7082

_end:

×

7083

  if (code != TSDB_CODE_SUCCESS) {

×

7084

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

7086

  return code;

×

7089

static int32_t buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,

×

7091

  int32_t code = TSDB_CODE_SUCCESS;

×

7092

  int32_t lino = 0;

×

7093

  char    stbName[TSDB_TABLE_NAME_LEN] = {0};

×

7094

  code = pAPI->metaFn.getTableNameByUid(pInfo->readHandle.vnode, stbUid, stbName);

×

7095

  QUERY_CHECK_CODE(code, lino, _end);

×

7097

  char fullStbName[TSDB_TABLE_FNAME_LEN] = {0};

×

7098

  if (pSupp->groupByDbName) {

×

7099

    (void)snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s.%s", dbName, varDataVal(stbName));

×

7101

    (void)snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s", varDataVal(stbName));

×

7104

  uint64_t groupId = calcGroupId(fullStbName, strlen(fullStbName));

×

7105

  pRes->info.id.groupId = groupId;

×

7107

  int64_t ctbNum = 0;

×

7108

  code = pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, stbUid, &ctbNum, NULL);

×

7109

  QUERY_CHECK_CODE(code, lino, _end);

×

7110

  code = fillTableCountScanDataBlock(pSupp, dbName, varDataVal(stbName), ctbNum, pRes);

×

7111

  QUERY_CHECK_CODE(code, lino, _end);

×

7113

_end:

×

7114

  if (code != TSDB_CODE_SUCCESS) {

×

7115

    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

7117

  return code;

×

7120

static void destoryTableCountScanOperator(void* param) {

×

7121

  STableCountScanOperatorInfo* pTableCountScanInfo = param;

×

7122

  blockDataDestroy(pTableCountScanInfo->pRes);

×

7124

  taosArrayDestroy(pTableCountScanInfo->stbUidList);

×

7125

  taosMemoryFreeClear(param);

×

7126

×

taosdata / TDengine / #3599

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

taosdata / TDengine / #3599

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