taosdata/TDengine | Build 3814 | source/libs/executor/src/hashjoinoperator.c | Coveralls

32

bool hJoinBlkReachThreshold(SHJoinOperatorInfo* pInfo, int64_t blkRows) {

×

33

  if (INT64_MAX == pInfo->ctx.limit || pInfo->pFinFilter != NULL) {

×

34

    return blkRows >= pInfo->blkThreshold;

×

37

  return (pInfo->execInfo.resRows + blkRows) >= pInfo->ctx.limit;

×

40

int32_t hJoinHandleMidRemains(SHJoinOperatorInfo* pJoin, SHJoinCtx* pCtx) {

×

41

  TSWAP(pJoin->midBlk, pJoin->finBlk);

×

43

  pCtx->midRemains = false;

×

45

  return TSDB_CODE_SUCCESS;

×

48

int32_t hJoinCopyMergeMidBlk(SHJoinCtx* pCtx, SSDataBlock** ppMid, SSDataBlock** ppFin) {

×

49

  SSDataBlock* pLess = *ppMid;

×

50

  SSDataBlock* pMore = *ppFin;

×

62

  int32_t totalRows = pMore->info.rows + pLess->info.rows;

×

63

  if (totalRows <= pMore->info.capacity) {

×

64

    HJ_ERR_RET(blockDataMerge(pMore, pLess));

×

65

    blockDataCleanup(pLess);

×

66

    pCtx->midRemains = false;

×

68

    int32_t copyRows = pMore->info.capacity - pMore->info.rows;

×

69

    HJ_ERR_RET(blockDataMergeNRows(pMore, pLess, pLess->info.rows - copyRows, copyRows));

×

70

    blockDataShrinkNRows(pLess, copyRows);

×

71

    pCtx->midRemains = true;

×

80

  return TSDB_CODE_SUCCESS;

×

83

int32_t hJoinSetImplFp(SHJoinOperatorInfo* pJoin) {

×

84

  switch (pJoin->joinType) {

×

85

    case JOIN_TYPE_INNER:

×

86

      pJoin->joinFp = hInnerJoinDo;

×

87

      break;

×

88

    case JOIN_TYPE_LEFT:

×

90

      switch (pJoin->subType) {

×

91

        case JOIN_STYPE_OUTER:

×

93

          break;

×

94

        default:

×

95

          break;

×

97

      break;

×

99

    default:

×

100

      break;

×

103

  return TSDB_CODE_SUCCESS;

×

107

int32_t hJoinLaunchPrimExpr(SSDataBlock* pBlock, SHJoinTableCtx* pTable, int32_t startIdx, int32_t endIdx) {

×

108

  if (NULL == pTable->primExpr) {

×

109

    return TSDB_CODE_SUCCESS;

×

112

  SHJoinPrimExprCtx* pCtx = &pTable->primCtx;

×

113

  SColumnInfoData* pPrimIn = taosArrayGet(pBlock->pDataBlock, pTable->primCol->srcSlot);

×

114

  SColumnInfoData* pPrimOut = taosArrayGet(pBlock->pDataBlock, pTable->primCtx.targetSlotId);

×

115

  if (0 != pCtx->timezoneUnit) {

×

116

    for (int32_t i = startIdx; i <= endIdx; ++i) {

×

117

      ((int64_t*)pPrimOut->pData)[i] = ((int64_t*)pPrimIn->pData)[i] - (((int64_t*)pPrimIn->pData)[i] + pCtx->timezoneUnit) % pCtx->truncateUnit;

×

120

    for (int32_t i = startIdx; i <= endIdx; ++i) {

×

121

      ((int64_t*)pPrimOut->pData)[i] = ((int64_t*)pPrimIn->pData)[i] / pCtx->truncateUnit * pCtx->truncateUnit;

×

125

  return TSDB_CODE_SUCCESS;

×

129

static int64_t hJoinGetSingleKeyRowsNum(SBufRowInfo* pRow) {

×

130

  int64_t rows = 0;

×

131

  while (pRow) {

×

132

    rows++;

×

133

    pRow = pRow->next;

×

135

  return rows;

×

138

static int64_t hJoinGetRowsNumOfKeyHash(SSHashObj* pHash) {

×

139

  SGroupData* pGroup = NULL;

×

140

  int32_t iter = 0;

×

141

  int64_t rowsNum = 0;

×

143

  while (NULL != (pGroup = tSimpleHashIterate(pHash, pGroup, &iter))) {

×

144

    int32_t* pKey = tSimpleHashGetKey(pGroup, NULL);

×

145

    int64_t rows = hJoinGetSingleKeyRowsNum(pGroup->rows);

×

147

    rowsNum += rows;

×

150

  return rowsNum;

×

153

static int32_t hJoinInitKeyColsInfo(SHJoinTableCtx* pTable, SNodeList* pList) {

×

154

  pTable->keyNum = LIST_LENGTH(pList);

×

156

  pTable->keyCols = taosMemoryMalloc(pTable->keyNum * sizeof(SHJoinColInfo));

×

157

  if (NULL == pTable->keyCols) {

×

158

    return terrno;

×

161

  int64_t bufSize = 0;

×

162

  int32_t i = 0;

×

163

  SNode* pNode = NULL;

×

164

  FOREACH(pNode, pList) {

×

165

    SColumnNode* pColNode = (SColumnNode*)pNode;

×

166

    pTable->keyCols[i].srcSlot = pColNode->slotId;

×

167

    pTable->keyCols[i].vardata = IS_VAR_DATA_TYPE(pColNode->node.resType.type);

×

168

    pTable->keyCols[i].bytes = pColNode->node.resType.bytes;

×

169

    bufSize += pColNode->node.resType.bytes;

×

170

    ++i;

×

173

  if (pTable->keyNum > 1) {

×

174

    pTable->keyBuf = taosMemoryMalloc(bufSize);

×

175

    if (NULL == pTable->keyBuf) {

×

176

      return terrno;

×

180

  return TSDB_CODE_SUCCESS;

×

183

static void hJoinGetValColsNum(SNodeList* pList, int32_t blkId, int32_t* colNum) {

×

184

  *colNum = 0;

×

186

  SNode* pNode = NULL;

×

187

  FOREACH(pNode, pList) {

×

188

    STargetNode* pTarget = (STargetNode*)pNode;

×

189

    SColumnNode* pCol = (SColumnNode*)pTarget->pExpr;

×

190

    if (pCol->dataBlockId == blkId) {

×

191

      (*colNum)++;

×

194

×

196

static bool hJoinIsValColInKeyCols(int16_t slotId, int32_t keyNum, SHJoinColInfo* pKeys, int32_t* pKeyIdx) {

×

197

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

×

198

    if (pKeys[i].srcSlot == slotId) {

×

199

      *pKeyIdx = i;

×

200

      return true;

×

204

  return false;

×

207

static int32_t hJoinInitValColsInfo(SHJoinTableCtx* pTable, SNodeList* pList) {

×

208

  hJoinGetValColsNum(pList, pTable->blkId, &pTable->valNum);

×

209

  if (pTable->valNum == 0) {

×

210

    return TSDB_CODE_SUCCESS;

×

213

  pTable->valCols = taosMemoryMalloc(pTable->valNum * sizeof(SHJoinColInfo));

×

214

  if (NULL == pTable->valCols) {

×

215

    return terrno;

×

218

  int32_t i = 0;

×

219

  int32_t colNum = 0;

×

220

  SNode* pNode = NULL;

×

221

  FOREACH(pNode, pList) {

×

222

    STargetNode* pTarget = (STargetNode*)pNode;

×

223

    SColumnNode* pColNode = (SColumnNode*)pTarget->pExpr;

×

224

    if (pColNode->dataBlockId == pTable->blkId) {

×

225

      if (hJoinIsValColInKeyCols(pColNode->slotId, pTable->keyNum, pTable->keyCols, &pTable->valCols[i].srcSlot)) {

×

226

        pTable->valCols[i].keyCol = true;

×

228

        pTable->valCols[i].keyCol = false;

×

229

        pTable->valCols[i].srcSlot = pColNode->slotId;

×

230

        pTable->valColExist = true;

×

231

        colNum++;

×

233

      pTable->valCols[i].dstSlot = pTarget->slotId;

×

234

      pTable->valCols[i].vardata = IS_VAR_DATA_TYPE(pColNode->node.resType.type);

×

235

      if (pTable->valCols[i].vardata && !pTable->valCols[i].keyCol) {

×

236

        if (NULL == pTable->valVarCols) {

×

237

          pTable->valVarCols = taosArrayInit(pTable->valNum, sizeof(int32_t));

×

238

          if (NULL == pTable->valVarCols) {

×

239

            return terrno;

×

242

        if (NULL == taosArrayPush(pTable->valVarCols, &i)) {

×

243

          return terrno;

×

246

      pTable->valCols[i].bytes = pColNode->node.resType.bytes;

×

247

      if (!pTable->valCols[i].keyCol && !pTable->valCols[i].vardata) {

×

248

        pTable->valBufSize += pColNode->node.resType.bytes;

×

250

      i++;

×

254

  pTable->valBitMapSize = BitmapLen(colNum);

×

255

  pTable->valBufSize += pTable->valBitMapSize;

×

257

  return TSDB_CODE_SUCCESS;

×

260

static int32_t hJoinInitPrimKeyInfo(SHJoinTableCtx* pTable, int32_t slotId) {

×

261

  pTable->primCol = taosMemoryMalloc(sizeof(SHJoinColMap));

×

262

  if (NULL == pTable->primCol) {

×

263

    return terrno;

×

266

  pTable->primCol->srcSlot = slotId;

×

268

  return TSDB_CODE_SUCCESS;

×

272

static int32_t hJoinInitPrimExprCtx(SNode* pNode, SHJoinPrimExprCtx* pCtx, SHJoinTableCtx* pTable) {

×

273

  if (NULL == pNode) {

×

274

    pCtx->targetSlotId = pTable->primCol->srcSlot;

×

275

    return TSDB_CODE_SUCCESS;

×

278

  if (QUERY_NODE_TARGET != nodeType(pNode)) {

×

279

    return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;

×

282

  STargetNode* pTarget = (STargetNode*)pNode;

×

283

  if (QUERY_NODE_FUNCTION != nodeType(pTarget->pExpr)) {

×

284

    return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;

×

287

  SFunctionNode* pFunc = (SFunctionNode*)pTarget->pExpr;

×

288

  if (FUNCTION_TYPE_TIMETRUNCATE != pFunc->funcType) {

×

289

    return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;

×

292

  if (4 != pFunc->pParameterList->length && 5 != pFunc->pParameterList->length) {

×

293

    return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;

×

296

  SValueNode* pUnit = (SValueNode*)nodesListGetNode(pFunc->pParameterList, 1);

×

297

  SValueNode* pCurrTz = (5 == pFunc->pParameterList->length) ? (SValueNode*)nodesListGetNode(pFunc->pParameterList, 2) : NULL;

×

298

  SValueNode* pTimeZone = (5 == pFunc->pParameterList->length) ? (SValueNode*)nodesListGetNode(pFunc->pParameterList, 4) : (SValueNode*)nodesListGetNode(pFunc->pParameterList, 3);

×

300

  pCtx->truncateUnit = pUnit->typeData;

×

301

  if ((NULL == pCurrTz || 1 == pCurrTz->typeData) && pCtx->truncateUnit >= (86400 * TSDB_TICK_PER_SECOND(pFunc->node.resType.precision))) {

×

302

    pCtx->timezoneUnit = offsetFromTz(varDataVal(pTimeZone->datum.p), TSDB_TICK_PER_SECOND(pFunc->node.resType.precision));

×

305

  pCtx->targetSlotId = pTarget->slotId;

×

307

  return TSDB_CODE_SUCCESS;

×

311

static int32_t hJoinInitTableInfo(SHJoinOperatorInfo* pJoin, SHashJoinPhysiNode* pJoinNode, SOperatorInfo** pDownstream, int32_t idx, SQueryStat* pStat) {

×

312

  SNodeList* pKeyList = NULL;

×

313

  SHJoinTableCtx* pTable = &pJoin->tbs[idx];

×

314

  pTable->downStream = pDownstream[idx];

×

315

  pTable->blkId = pDownstream[idx]->resultDataBlockId;

×

316

  if (0 == idx) {

×

317

    pKeyList = pJoinNode->pOnLeft;

×

318

    pTable->hasTimeRange = pJoinNode->timeRangeTarget & 0x1;

×

320

    pKeyList = pJoinNode->pOnRight;

×

321

    pTable->hasTimeRange = pJoinNode->timeRangeTarget & 0x2;

×

324

  HJ_ERR_RET(hJoinInitPrimKeyInfo(pTable, (0 == idx) ? pJoinNode->leftPrimSlotId : pJoinNode->rightPrimSlotId));

×

326

  int32_t code = hJoinInitKeyColsInfo(pTable, pKeyList);

×

327

  if (code) {

×

328

    return code;

×

330

  code = hJoinInitValColsInfo(pTable, pJoinNode->pTargets);

×

331

  if (code) {

×

332

    return code;

×

335

  TAOS_MEMCPY(&pTable->inputStat, pStat, sizeof(*pStat));

×

337

  HJ_ERR_RET(hJoinInitPrimExprCtx(pTable->primExpr, &pTable->primCtx, pTable));

×

339

  return TSDB_CODE_SUCCESS;

×

342

static void hJoinSetBuildAndProbeTable(SHJoinOperatorInfo* pInfo, SHashJoinPhysiNode* pJoinNode) {

×

343

  int32_t buildIdx = 0;

×

344

  int32_t probeIdx = 1;

×

346

  pInfo->joinType = pJoinNode->joinType;

×

347

  pInfo->subType = pJoinNode->subType;

×

349

  switch (pInfo->joinType) {

×

350

    case JOIN_TYPE_INNER:

×

352

      if (pInfo->tbs[0].inputStat.inputRowNum <= pInfo->tbs[1].inputStat.inputRowNum) {

×

353

        buildIdx = 0;

×

354

        probeIdx = 1;

×

356

        buildIdx = 1;

×

357

        probeIdx = 0;

×

359

      break;

×

360

    case JOIN_TYPE_LEFT:

×

361

      buildIdx = 1;

×

362

      probeIdx = 0;

×

363

      break;

×

364

    case JOIN_TYPE_RIGHT:

×

365

      buildIdx = 0;

×

366

      probeIdx = 1;

×

367

      break;

×

368

    default:

×

369

      break;

×

372

  pInfo->pBuild = &pInfo->tbs[buildIdx];

×

373

  pInfo->pProbe = &pInfo->tbs[probeIdx];

×

375

  pInfo->pBuild->downStreamIdx = buildIdx;

×

376

  pInfo->pProbe->downStreamIdx = probeIdx;

×

378

  if (0 == buildIdx) {

×

379

    pInfo->pBuild->primExpr = pJoinNode->leftPrimExpr;

×

380

    pInfo->pProbe->primExpr = pJoinNode->rightPrimExpr;

×

382

    pInfo->pBuild->primExpr = pJoinNode->rightPrimExpr;

×

383

    pInfo->pProbe->primExpr = pJoinNode->leftPrimExpr;

×

385

×

387

static int32_t hJoinBuildResColsMap(SHJoinOperatorInfo* pInfo, SHashJoinPhysiNode* pJoinNode) {

×

388

  pInfo->pResColNum = pJoinNode->pTargets->length;

×

389

  pInfo->pResColMap = taosMemoryCalloc(pJoinNode->pTargets->length, sizeof(int8_t));

×

390

  if (NULL == pInfo->pResColMap) {

×

391

    return terrno;

×

394

  SNode* pNode = NULL;

×

395

  int32_t i = 0;

×

396

  FOREACH(pNode, pJoinNode->pTargets) {

×

397

    STargetNode* pTarget = (STargetNode*)pNode;

×

398

    SColumnNode* pCol = (SColumnNode*)pTarget->pExpr;

×

399

    if (pCol->dataBlockId == pInfo->pBuild->blkId) {

×

400

      pInfo->pResColMap[i] = 1;

×

403

    i++;

×

406

  return TSDB_CODE_SUCCESS;

×

412

  page.pageSize = HASH_JOIN_DEFAULT_PAGE_SIZE;

×

413

  page.offset = 0;

×

414

  page.data = taosMemoryMalloc(page.pageSize);

×

415

  if (NULL == page.data) {

×

416

    return terrno;

×

419

  if (NULL == taosArrayPush(pRowBufs, &page)) {

×

420

    return terrno;

×

422

  return TSDB_CODE_SUCCESS;

×

425

static int32_t hJoinInitBufPages(SHJoinOperatorInfo* pInfo) {

×

426

  pInfo->pRowBufs = taosArrayInit(32, sizeof(SBufPageInfo));

×

427

  if (NULL == pInfo->pRowBufs) {

×

428

    return terrno;

×

431

  return hJoinAddPageToBufs(pInfo->pRowBufs);

×

434

static void hJoinFreeTableInfo(SHJoinTableCtx* pTable) {

×

435

  taosMemoryFreeClear(pTable->keyCols);

×

436

  taosMemoryFreeClear(pTable->keyBuf);

×

437

  taosMemoryFreeClear(pTable->valCols);

×

438

  taosArrayDestroy(pTable->valVarCols);

×

439

  taosMemoryFree(pTable->primCol);

×

440

×

442

static void hJoinFreeBufPage(void* param) {

×

443

  SBufPageInfo* pInfo = (SBufPageInfo*)param;

×

444

  taosMemoryFree(pInfo->data);

×

445

×

447

static void hJoinDestroyKeyHash(SSHashObj** ppHash) {

×

448

  if (NULL == ppHash || NULL == (*ppHash)) {

×

449

    return;

×

452

  void*   pIte = NULL;

×

453

  int32_t iter = 0;

×

454

  while ((pIte = tSimpleHashIterate(*ppHash, pIte, &iter)) != NULL) {

×

455

    SGroupData* pGroup = pIte;

×

456

    SBufRowInfo* pRow = pGroup->rows;

×

457

    SBufRowInfo* pNext = NULL;

×

458

    while (pRow) {

×

459

      pNext = pRow->next;

×

460

      taosMemoryFree(pRow);

×

461

      pRow = pNext;

×

465

  tSimpleHashCleanup(*ppHash);

×

466

  *ppHash = NULL;

×

470

  *ppData = NULL;

×

472

  if ((uint16_t)-1 == pRow->pageId) {

×

473

    return TSDB_CODE_SUCCESS;

×

475

  SBufPageInfo *pPage = taosArrayGet(pRowBufs, pRow->pageId);

×

476

  if (NULL == pPage) {

×

477

    qError("fail to get %d page, total:%d", pRow->pageId, (int32_t)taosArrayGetSize(pRowBufs));

×

478

    QRY_ERR_RET(TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);

×

481

  *ppData = pPage->data + pRow->offset;

×

483

  return TSDB_CODE_SUCCESS;

×

486

static int32_t hJoinCopyResRowsToBlock(SHJoinOperatorInfo* pJoin, int32_t rowNum, SBufRowInfo* pStart, SSDataBlock* pRes) {

×

487

  SHJoinTableCtx* pBuild = pJoin->pBuild;

×

488

  SHJoinTableCtx* pProbe = pJoin->pProbe;

×

489

  int32_t buildIdx = 0, buildValIdx = 0;

×

490

  int32_t probeIdx = 0;

×

491

  SBufRowInfo* pRow = pStart;

×

492

  int32_t code = 0;

×

493

  char* pData = NULL;

×

495

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

×

496

    HJ_ERR_RET(hJoinRetrieveColDataFromRowBufs(pJoin->pRowBufs, pRow, &pData));

×

498

    char* pValData = pData + pBuild->valBitMapSize;

×

499

    char* pKeyData = pProbe->keyData;

×

500

    buildIdx = buildValIdx = probeIdx = 0;

×

501

    for (int32_t i = 0; i < pJoin->pResColNum; ++i) {

×

502

      if (pJoin->pResColMap[i]) {

×

503

        SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pBuild->valCols[buildIdx].dstSlot);

×

504

        if (pBuild->valCols[buildIdx].keyCol) {

×

505

          code = colDataSetVal(pDst, pRes->info.rows + r, pKeyData, false);

×

506

          if (code) {

×

507

            return code;

×

509

          pKeyData += pBuild->valCols[buildIdx].vardata ? varDataTLen(pKeyData) : pBuild->valCols[buildIdx].bytes;

×

511

          if (colDataIsNull_f(pData, buildValIdx)) {

×

512

            code = colDataSetVal(pDst, pRes->info.rows + r, NULL, true);

×

513

            if (code) {

×

514

              return code;

×

517

            code = colDataSetVal(pDst, pRes->info.rows + r, pValData, false);

×

518

            if (code) {

×

519

              return code;

×

521

            pValData += pBuild->valCols[buildIdx].vardata ? varDataTLen(pValData) : pBuild->valCols[buildIdx].bytes;

×

523

          buildValIdx++;

×

525

        buildIdx++;

×

526

      } else if (0 == r) {

×

527

        SColumnInfoData* pSrc = taosArrayGet(pJoin->ctx.pProbeData->pDataBlock, pProbe->valCols[probeIdx].srcSlot);

×

528

        SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pProbe->valCols[probeIdx].dstSlot);

×

530

        code = colDataCopyNItems(pDst, pRes->info.rows, colDataGetData(pSrc, pJoin->ctx.probeStartIdx), rowNum, colDataIsNull_s(pSrc, pJoin->ctx.probeStartIdx));

×

531

        if (code) {

×

532

          return code;

×

534

        probeIdx++;

×

537

    pRow = pRow->next;

×

540

  return TSDB_CODE_SUCCESS;

×

543

int32_t hJoinCopyNMatchRowsToBlock(SHJoinOperatorInfo* pJoin, SSDataBlock* pRes, int32_t startIdx, int32_t rows) {

×

544

  SHJoinTableCtx* pBuild = pJoin->pBuild;

×

545

  SHJoinTableCtx* pProbe = pJoin->pProbe;

×

546

  int32_t buildIdx = 0;

×

547

  int32_t probeIdx = 0;

×

548

  int32_t code = 0;

×

550

  for (int32_t i = 0; i < pJoin->pResColNum; ++i) {

×

551

    if (pJoin->pResColMap[i]) {

×

552

      SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pBuild->valCols[buildIdx].dstSlot);

×

553

      colDataSetNItemsNull(pDst, pRes->info.rows, rows);

×

555

      buildIdx++;

×

557

      SColumnInfoData* pSrc = taosArrayGet(pJoin->ctx.pProbeData->pDataBlock, pProbe->valCols[probeIdx].srcSlot);

×

558

      SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pProbe->valCols[probeIdx].dstSlot);

×

560

      QRY_ERR_RET(colDataAssignNRows(pDst, pRes->info.rows, pSrc, startIdx, rows));

×

562

      probeIdx++;

×

566

  pRes->info.rows += rows;

×

568

  return TSDB_CODE_SUCCESS;

×

573

void hJoinAppendResToBlock(struct SOperatorInfo* pOperator, SSDataBlock* pRes, bool* allFetched) {

×

574

  SHJoinOperatorInfo* pJoin = pOperator->info;

×

575

  SHJoinCtx* pCtx = &pJoin->ctx;

×

576

  SBufRowInfo* pStart = pCtx->pBuildRow;

×

577

  int32_t rowNum = 0;

×

578

  int32_t resNum = pRes->info.rows;

×

580

  while (pCtx->pBuildRow && (resNum < pRes->info.capacity)) {

×

581

    rowNum++;

×

582

    resNum++;

×

583

    pCtx->pBuildRow = pCtx->pBuildRow->next;

×

586

  pJoin->execInfo.resRows += rowNum;

×

588

  int32_t code = hJoinCopyResRowsToBlock(pJoin, rowNum, pStart, pRes);

×

589

  if (code) {

×

590

    pOperator->pTaskInfo->code = code;

×

591

    T_LONG_JMP(pOperator->pTaskInfo->env, code);

×

594

  pRes->info.rows = resNum;

×

595

  *allFetched = pCtx->pBuildRow ? false : true;

×

596

×

599

bool hJoinCopyKeyColsDataToBuf(SHJoinTableCtx* pTable, int32_t rowIdx, size_t *pBufLen) {

×

600

  char *pData = NULL;

×

601

  size_t bufLen = 0;

×

603

  if (1 == pTable->keyNum) {

×

604

    if (colDataIsNull_s(pTable->keyCols[0].colData, rowIdx)) {

×

605

      return true;

×

607

    if (pTable->keyCols[0].vardata) {

×

608

      pData = pTable->keyCols[0].data + pTable->keyCols[0].offset[rowIdx];

×

609

      bufLen = varDataTLen(pData);

×

611

      pData = pTable->keyCols[0].data + pTable->keyCols[0].bytes * rowIdx;

×

612

      bufLen = pTable->keyCols[0].bytes;

×

614

    pTable->keyData = pData;

×

616

    for (int32_t i = 0; i < pTable->keyNum; ++i) {

×

617

      if (colDataIsNull_s(pTable->keyCols[i].colData, rowIdx)) {

×

618

        return true;

×

620

      if (pTable->keyCols[i].vardata) {

×

621

        pData = pTable->keyCols[i].data + pTable->keyCols[i].offset[rowIdx];

×

622

        TAOS_MEMCPY(pTable->keyBuf + bufLen, pData, varDataTLen(pData));

×

623

        bufLen += varDataTLen(pData);

×

625

        pData = pTable->keyCols[i].data + pTable->keyCols[i].bytes * rowIdx;

×

626

        TAOS_MEMCPY(pTable->keyBuf + bufLen, pData, pTable->keyCols[i].bytes);

×

627

        bufLen += pTable->keyCols[i].bytes;

×

630

    pTable->keyData = pTable->keyBuf;

×

633

  if (pBufLen) {

×

634

    *pBufLen = bufLen;

×

637

  return false;

×

640

static int32_t hJoinSetKeyColsData(SSDataBlock* pBlock, SHJoinTableCtx* pTable) {

×

641

  for (int32_t i = 0; i < pTable->keyNum; ++i) {

×

642

    SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, pTable->keyCols[i].srcSlot);

×

643

    if (NULL == pCol) {

×

644

      qError("fail to get %d col, total:%d", pTable->keyCols[i].srcSlot, (int32_t)taosArrayGetSize(pBlock->pDataBlock));

×

645

      QRY_ERR_RET(TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);

×

647

    if (pTable->keyCols[i].vardata != IS_VAR_DATA_TYPE(pCol->info.type))  {

×

648

      qError("column type mismatch, idx:%d, slotId:%d, type:%d, vardata:%d", i, pTable->keyCols[i].srcSlot, pCol->info.type, pTable->keyCols[i].vardata);

×

649

      return TSDB_CODE_INVALID_PARA;

×

651

    if (pTable->keyCols[i].bytes != pCol->info.bytes)  {

×

652

      qError("column bytes mismatch, idx:%d, slotId:%d, bytes:%d, %d", i, pTable->keyCols[i].srcSlot, pCol->info.bytes, pTable->keyCols[i].bytes);

×

653

      return TSDB_CODE_INVALID_PARA;

×

655

    pTable->keyCols[i].data = pCol->pData;

×

656

    if (pTable->keyCols[i].vardata) {

×

657

      pTable->keyCols[i].offset = pCol->varmeta.offset;

×

659

    pTable->keyCols[i].colData = pCol;

×

662

  return TSDB_CODE_SUCCESS;

×

665

static int32_t hJoinSetValColsData(SSDataBlock* pBlock, SHJoinTableCtx* pTable) {

×

666

  if (!pTable->valColExist) {

×

667

    return TSDB_CODE_SUCCESS;

×

669

  for (int32_t i = 0; i < pTable->valNum; ++i) {

×

670

    if (pTable->valCols[i].keyCol) {

×

671

      continue;

×

673

    SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, pTable->valCols[i].srcSlot);

×

674

    if (NULL == pCol) {

×

675

      qError("fail to get %d col, total:%d", pTable->valCols[i].srcSlot, (int32_t)taosArrayGetSize(pBlock->pDataBlock));

×

676

      QRY_ERR_RET(TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);

×

678

    if (pTable->valCols[i].vardata != IS_VAR_DATA_TYPE(pCol->info.type))  {

×

679

      qError("column type mismatch, idx:%d, slotId:%d, type:%d, vardata:%d", i, pTable->valCols[i].srcSlot, pCol->info.type, pTable->valCols[i].vardata);

×

680

      return TSDB_CODE_INVALID_PARA;

×

682

    if (pTable->valCols[i].bytes != pCol->info.bytes)  {

×

683

      qError("column bytes mismatch, idx:%d, slotId:%d, bytes:%d, %d", i, pTable->valCols[i].srcSlot, pCol->info.bytes, pTable->valCols[i].bytes);

×

684

      return TSDB_CODE_INVALID_PARA;

×

686

    if (!pTable->valCols[i].vardata) {

×

687

      pTable->valCols[i].bitMap = pCol->nullbitmap;

×

689

    pTable->valCols[i].data = pCol->pData;

×

690

    if (pTable->valCols[i].vardata) {

×

691

      pTable->valCols[i].offset = pCol->varmeta.offset;

×

695

  return TSDB_CODE_SUCCESS;

×

701

  if (!pTable->valColExist) {

×

702

    return;

×

705

  char *pData = NULL;

×

706

  size_t bufLen = pTable->valBitMapSize;

×

707

  TAOS_MEMSET(pTable->valData, 0, pTable->valBitMapSize);

×

708

  for (int32_t i = 0, m = 0; i < pTable->valNum; ++i) {

×

709

    if (pTable->valCols[i].keyCol) {

×

710

      continue;

×

712

    if (pTable->valCols[i].vardata) {

×

713

      if (-1 == pTable->valCols[i].offset[rowIdx]) {

×

714

        colDataSetNull_f(pTable->valData, m);

×

716

        pData = pTable->valCols[i].data + pTable->valCols[i].offset[rowIdx];

×

717

        TAOS_MEMCPY(pTable->valData + bufLen, pData, varDataTLen(pData));

×

718

        bufLen += varDataTLen(pData);

×

721

      if (colDataIsNull_f(pTable->valCols[i].bitMap, rowIdx)) {

×

722

        colDataSetNull_f(pTable->valData, m);

×

724

        pData = pTable->valCols[i].data + pTable->valCols[i].bytes * rowIdx;

×

725

        TAOS_MEMCPY(pTable->valData + bufLen, pData, pTable->valCols[i].bytes);

×

726

        bufLen += pTable->valCols[i].bytes;

×

729

    m++;

×

735

  if (0 == bufSize) {

×

736

    pRow->pageId = -1;

×

737

    return TSDB_CODE_SUCCESS;

×

740

  if (bufSize > HASH_JOIN_DEFAULT_PAGE_SIZE) {

×

741

    qError("invalid join value buf size:%d", bufSize);

×

742

    return TSDB_CODE_INVALID_PARA;

×

745

  do {

×

746

    SBufPageInfo* page = taosArrayGetLast(pPages);

×

747

    if ((page->pageSize - page->offset) >= bufSize) {

×

748

      *pBuf = page->data + page->offset;

×

749

      pRow->pageId = taosArrayGetSize(pPages) - 1;

×

750

      pRow->offset = page->offset;

×

751

      page->offset += bufSize;

×

752

      return TSDB_CODE_SUCCESS;

×

755

    int32_t code = hJoinAddPageToBufs(pPages);

×

756

    if (code) {

×

757

      return code;

×

763

  if (NULL == pTable->valVarCols) {

×

764

    return pTable->valBufSize;

×

767

  int32_t* varColIdx = NULL;

×

768

  int32_t bufLen = pTable->valBufSize;

×

769

  int32_t varColNum = taosArrayGetSize(pTable->valVarCols);

×

770

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

×

771

    varColIdx = taosArrayGet(pTable->valVarCols, i);

×

772

    char* pData = pTable->valCols[*varColIdx].data + pTable->valCols[*varColIdx].offset[rowIdx];

×

773

    bufLen += varDataTLen(pData);

×

776

  return bufLen;

×

780

static int32_t hJoinAddRowToHashImpl(SHJoinOperatorInfo* pJoin, SGroupData* pGroup, SHJoinTableCtx* pTable, size_t keyLen, int32_t rowIdx) {

×

781

  SGroupData group = {0};

×

782

  SBufRowInfo* pRow = NULL;

×

784

  if (NULL == pGroup) {

×

785

    group.rows = taosMemoryMalloc(sizeof(SBufRowInfo));

×

786

    if (NULL == group.rows) {

×

787

      return terrno;

×

789

    pRow = group.rows;

×

791

    pRow = taosMemoryMalloc(sizeof(SBufRowInfo));

×

792

    if (NULL == pRow) {

×

793

      return terrno;

×

797

  int32_t code = hJoinGetValBufFromPages(pJoin->pRowBufs, hJoinGetValBufSize(pTable, rowIdx), &pTable->valData, pRow);

×

798

  if (code) {

×

799

    taosMemoryFree(pRow);

×

800

    return code;

×

803

  if (NULL == pGroup) {

×

804

    pRow->next = NULL;

×

805

    if (tSimpleHashPut(pJoin->pKeyHash, pTable->keyData, keyLen, &group, sizeof(group))) {

×

806

      taosMemoryFree(pRow);

×

807

      return terrno;

×

810

    pRow->next = pGroup->rows;

×

811

    pGroup->rows = pRow;

×

814

  return TSDB_CODE_SUCCESS;

×

817

static int32_t hJoinAddRowToHash(SHJoinOperatorInfo* pJoin, SSDataBlock* pBlock, size_t keyLen, int32_t rowIdx) {

×

818

  SHJoinTableCtx* pBuild = pJoin->pBuild;

×

819

  int32_t code = hJoinSetValColsData(pBlock, pBuild);

×

820

  if (code) {

×

821

    return code;

×

824

  SGroupData* pGroup = tSimpleHashGet(pJoin->pKeyHash, pBuild->keyData, keyLen);

×

825

  code = hJoinAddRowToHashImpl(pJoin, pGroup, pBuild, keyLen, rowIdx);

×

826

  if (code) {

×

827

    return code;

×

832

  return TSDB_CODE_SUCCESS;

×

835

static bool hJoinFilterTimeRange(SSDataBlock* pBlock, STimeWindow* pRange, int32_t primSlot, int32_t* startIdx, int32_t* endIdx) {

×

836

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

×

837

  if (NULL == pCol) {

×

838

    qError("hash join can't get prim col, slot:%d, slotNum:%d", primSlot, (int32_t)taosArrayGetSize(pBlock->pDataBlock));

×

839

    return false;

×

842

  TSKEY skey = *(TSKEY*)colDataGetData(pCol, 0);

×

843

  TSKEY ekey = *(TSKEY*)colDataGetData(pCol, (pBlock->info.rows - 1));

×

845

  if (ekey < pRange->skey || skey > pRange->ekey) {

×

846

    return false;

×

849

  if (skey >= pRange->skey && ekey <= pRange->ekey) {

×

850

    *startIdx = 0;

×

851

    *endIdx = pBlock->info.rows - 1;

×

852

    return true;

×

855

  if (skey < pRange->skey && ekey > pRange->ekey) {

×

856

    TSKEY *pStart = (TSKEY*)taosbsearch(&pRange->skey, pCol->pData, pBlock->info.rows, sizeof(TSKEY), compareInt64Val, TD_GE);

×

857

    TSKEY *pEnd = (TSKEY*)taosbsearch(&pRange->ekey, pCol->pData, pBlock->info.rows, sizeof(TSKEY), compareInt64Val, TD_LE);

×

858

    *startIdx = ((uint64_t)pStart - (uint64_t)pCol->pData) / sizeof(int64_t);

×

859

    *endIdx = ((uint64_t)pEnd - (uint64_t)pCol->pData) / sizeof(int64_t);

×

860

    return true;

×

863

  if (skey >= pRange->skey) {

×

864

    TSKEY *pEnd = (TSKEY*)taosbsearch(&pRange->ekey, pCol->pData, pBlock->info.rows, sizeof(TSKEY), compareInt64Val, TD_LE);

×

865

    *startIdx = 0;

×

866

    *endIdx = ((uint64_t)pEnd - (uint64_t)pCol->pData) / sizeof(int64_t);

×

867

    return true;

×

870

  TSKEY *pStart = (TSKEY*)taosbsearch(&pRange->skey, pCol->pData, pBlock->info.rows, sizeof(TSKEY), compareInt64Val, TD_GE);

×

871

  *startIdx = ((uint64_t)pStart - (uint64_t)pCol->pData) / sizeof(int64_t);

×

872

  *endIdx = pBlock->info.rows - 1;

×

874

  return true;

×

877

static int32_t hJoinAddBlockRowsToHash(SSDataBlock* pBlock, SHJoinOperatorInfo* pJoin) {

×

878

  SHJoinTableCtx* pBuild = pJoin->pBuild;

×

879

  int32_t startIdx = 0, endIdx = pBlock->info.rows - 1;

×

880

  if (pBuild->hasTimeRange && !hJoinFilterTimeRange(pBlock, &pJoin->tblTimeRange, pBuild->primCol->srcSlot, &startIdx, &endIdx)) {

×

881

    return TSDB_CODE_SUCCESS;

×

884

  HJ_ERR_RET(hJoinLaunchPrimExpr(pBlock, pBuild, startIdx, endIdx));

×

886

  int32_t code = hJoinSetKeyColsData(pBlock, pBuild);

×

887

  if (code) {

×

888

    return code;

×

891

  size_t bufLen = 0;

×

892

  for (int32_t i = startIdx; i <= endIdx; ++i) {

×

893

    if (hJoinCopyKeyColsDataToBuf(pBuild, i, &bufLen)) {

×

894

      continue;

×

896

    code = hJoinAddRowToHash(pJoin, pBlock, bufLen, i);

×

897

    if (code) {

×

898

      return code;

×

902

  return code;

×

905

static int32_t hJoinBuildHash(struct SOperatorInfo* pOperator, bool* queryDone) {

×

906

  SHJoinOperatorInfo* pJoin = pOperator->info;

×

907

  SSDataBlock*        pBlock = NULL;

×

908

  int32_t             code = TSDB_CODE_SUCCESS;

×

911

    pBlock = getNextBlockFromDownstream(pOperator, pJoin->pBuild->downStreamIdx);

×

912

    if (NULL == pBlock) {

×

913

      break;

×

916

    pJoin->execInfo.buildBlkNum++;

×

917

    pJoin->execInfo.buildBlkRows += pBlock->info.rows;

×

919

    code = hJoinAddBlockRowsToHash(pBlock, pJoin);

×

920

    if (code) {

×

921

      return code;

×

925

  if (IS_INNER_NONE_JOIN(pJoin->joinType, pJoin->subType) && tSimpleHashGetSize(pJoin->pKeyHash) <= 0) {

×

926

    hJoinSetDone(pOperator);

×

927

    *queryDone = true;

×

932

  return TSDB_CODE_SUCCESS;

×

935

static int32_t hJoinPrepareStart(struct SOperatorInfo* pOperator, SSDataBlock* pBlock) {

×

936

  SHJoinOperatorInfo* pJoin = pOperator->info;

×

937

  SHJoinTableCtx* pProbe = pJoin->pProbe;

×

938

  int32_t startIdx = 0, endIdx = pBlock->info.rows - 1;

×

939

  if (pProbe->hasTimeRange && !hJoinFilterTimeRange(pBlock, &pJoin->tblTimeRange, pProbe->primCol->srcSlot, &startIdx, &endIdx)) {

×

940

    if (!IS_INNER_NONE_JOIN(pJoin->joinType, pJoin->subType)) {

×

941

      pJoin->ctx.probeEndIdx = -1;

×

942

      pJoin->ctx.probePostIdx = 0;

×

943

      pJoin->ctx.pProbeData = pBlock;

×

944

      pJoin->ctx.rowRemains = true;

×

945

      pJoin->ctx.probePhase = E_JOIN_PHASE_POST;

×

947

      HJ_ERR_RET((*pJoin->joinFp)(pOperator));

×

950

    return TSDB_CODE_SUCCESS;

×

953

  HJ_ERR_RET(hJoinLaunchPrimExpr(pBlock, pProbe, startIdx, endIdx));

×

955

  int32_t code = hJoinSetKeyColsData(pBlock, pProbe);

×

956

  if (code) {

×

957

    return code;

×

959

  code = hJoinSetValColsData(pBlock, pProbe);

×

960

  if (code) {

×

961

    return code;

×

964

  pJoin->ctx.probeStartIdx = startIdx;

×

965

  pJoin->ctx.probeEndIdx = endIdx;

×

966

  pJoin->ctx.pBuildRow = NULL;

×

967

  pJoin->ctx.pProbeData = pBlock;

×

968

  pJoin->ctx.rowRemains = true;

×

969

  pJoin->ctx.probePreIdx = 0;

×

970

  pJoin->ctx.probePostIdx = endIdx + 1;

×

972

  if (!IS_INNER_NONE_JOIN(pJoin->joinType, pJoin->subType) && startIdx > 0) {

×

973

    pJoin->ctx.probePhase = E_JOIN_PHASE_PRE;

×

975

    pJoin->ctx.probePhase = E_JOIN_PHASE_CUR;

×

978

  HJ_ERR_RET((*pJoin->joinFp)(pOperator));

×

980

  return TSDB_CODE_SUCCESS;

×

983

void hJoinSetDone(struct SOperatorInfo* pOperator) {

×

984

  setOperatorCompleted(pOperator);

×

986

  SHJoinOperatorInfo* pInfo = pOperator->info;

×

987

  hJoinDestroyKeyHash(&pInfo->pKeyHash);

×

989

  qDebug("hash Join done");

×

990

×

992

static int32_t hJoinMainProcess(struct SOperatorInfo* pOperator, SSDataBlock** pResBlock) {

×

993

  SHJoinOperatorInfo* pJoin = pOperator->info;

×

994

  SExecTaskInfo*      pTaskInfo = pOperator->pTaskInfo;

×

995

  int32_t             code = TSDB_CODE_SUCCESS;

×

996

  int32_t             lino = 0;

×

997

  SSDataBlock*        pRes = pJoin->finBlk;

×

998

  int64_t             st = 0;

×

1000

  QRY_PARAM_CHECK(pResBlock);

×

1001

  if (pOperator->cost.openCost == 0) {

×

1002

    st = taosGetTimestampUs();

×

1005

  if (pOperator->status == OP_EXEC_DONE) {

×

1006

    pRes->info.rows = 0;

×

1007

    goto _end;

×

1010

  if (!pJoin->keyHashBuilt) {

×

1011

    pJoin->keyHashBuilt = true;

×

1013

    bool queryDone = false;

×

1014

    code = hJoinBuildHash(pOperator, &queryDone);

×

1015

    QUERY_CHECK_CODE(code, lino, _end);

×

1017

    if (queryDone) {

×

1018

      goto _end;

×

1022

  blockDataCleanup(pRes);

×

1024

  if (pJoin->ctx.rowRemains) {

×

1025

    code = (*pJoin->joinFp)(pOperator);

×

1026

    QUERY_CHECK_CODE(code, lino, _end);

×

1028

    if (pRes->info.rows > 0 && pJoin->pFinFilter != NULL) {

×

1029

      code = doFilter(pRes, pJoin->pFinFilter, NULL);

×

1030

      QUERY_CHECK_CODE(code, lino, _end);

×

1033

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

×

1034

      *pResBlock = pRes;

×

1035

      return code;

×

1039

  while (true) {

×

1040

    SSDataBlock* pBlock = getNextBlockFromDownstream(pOperator, pJoin->pProbe->downStreamIdx);

×

1041

    if (NULL == pBlock) {

×

1042

      hJoinSetDone(pOperator);

×

1043

      break;

×

1046

    pJoin->execInfo.probeBlkNum++;

×

1047

    pJoin->execInfo.probeBlkRows += pBlock->info.rows;

×

1049

    code = hJoinPrepareStart(pOperator, pBlock);

×

1050

    QUERY_CHECK_CODE(code, lino, _end);

×

1052

    if (!hJoinBlkReachThreshold(pJoin, pRes->info.rows)) {

×

1053

      continue;

×

1056

    if (pRes->info.rows > 0 && pJoin->pFinFilter != NULL) {

×

1057

      code = doFilter(pRes, pJoin->pFinFilter, NULL);

×

1058

      QUERY_CHECK_CODE(code, lino, _end);

×

1061

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

×

1062

      break;

×

1066

_end:

×

1067

  if (pOperator->cost.openCost == 0) {

×

1068

    pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0;

×

1070

  if (code != TSDB_CODE_SUCCESS) {

×

1071

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

×

1072

    pTaskInfo->code = code;

×

1073

    T_LONG_JMP(pTaskInfo->env, code);

×

1075

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

×

1076

    *pResBlock = pRes;

×

1079

  return code;

×

1082

static void destroyHashJoinOperator(void* param) {

×

1083

  SHJoinOperatorInfo* pJoinOperator = (SHJoinOperatorInfo*)param;

×

1084

  qDebug("hashJoin exec info, buildBlk:%" PRId64 ", buildRows:%" PRId64 ", probeBlk:%" PRId64 ", probeRows:%" PRId64 ", resRows:%" PRId64,

×

1088

  hJoinDestroyKeyHash(&pJoinOperator->pKeyHash);

×

1090

  hJoinFreeTableInfo(&pJoinOperator->tbs[0]);

×

1091

  hJoinFreeTableInfo(&pJoinOperator->tbs[1]);

×

1092

  blockDataDestroy(pJoinOperator->finBlk);

×

1093

  pJoinOperator->finBlk = NULL;

×

1094

  taosMemoryFreeClear(pJoinOperator->pResColMap);

×

1095

  taosArrayDestroyEx(pJoinOperator->pRowBufs, hJoinFreeBufPage);

×

1097

  taosMemoryFreeClear(param);

×

1098

×

1100

int32_t hJoinHandleConds(SHJoinOperatorInfo* pJoin, SHashJoinPhysiNode* pJoinNode) {

×

1101

  switch (pJoin->joinType) {

×

1102

    case JOIN_TYPE_INNER: {

×

1103

      SNode* pCond = NULL;

×

1104

      if (pJoinNode->pFullOnCond != NULL) {

×

1105

        if (pJoinNode->node.pConditions != NULL) {

×

1106

          HJ_ERR_RET(mergeJoinConds(&pJoinNode->pFullOnCond, &pJoinNode->node.pConditions));

×

1108

        pCond = pJoinNode->pFullOnCond;

×

1109

      } else if (pJoinNode->node.pConditions != NULL) {

×

1110

        pCond = pJoinNode->node.pConditions;

×

1113

      HJ_ERR_RET(filterInitFromNode(pCond, &pJoin->pFinFilter, 0));

×

1114

      break;

×

1116

    case JOIN_TYPE_LEFT:

×

1119

      if (pJoinNode->pFullOnCond != NULL) {

×

1120

        HJ_ERR_RET(filterInitFromNode(pJoinNode->pFullOnCond, &pJoin->pPreFilter, 0));

×

1122

      if (pJoinNode->node.pConditions != NULL) {

×

1123

        HJ_ERR_RET(filterInitFromNode(pJoinNode->node.pConditions, &pJoin->pFinFilter, 0));

×

1125

      break;

×

1126

    default:

×

1127

      break;

×

1130

  return TSDB_CODE_SUCCESS;

×

1133

static uint32_t hJoinGetFinBlkCapacity(SHJoinOperatorInfo* pJoin, SHashJoinPhysiNode* pJoinNode) {

×

1134

  uint32_t maxRows = TMAX(HJOIN_DEFAULT_BLK_ROWS_NUM, HJOIN_BLK_SIZE_LIMIT/pJoinNode->node.pOutputDataBlockDesc->totalRowSize);

×

1135

  if (INT64_MAX != pJoin->ctx.limit && NULL == pJoin->pFinFilter) {

×

1136

    uint32_t limitMaxRows = pJoin->ctx.limit / HJOIN_BLK_THRESHOLD_RATIO + 1;

×

1137

    return (maxRows > limitMaxRows) ? limitMaxRows : maxRows;

×

1140

  return maxRows;

×

1144

int32_t hJoinInitResBlocks(SHJoinOperatorInfo* pJoin, SHashJoinPhysiNode* pJoinNode) {

×

1145

  pJoin->finBlk = createDataBlockFromDescNode(pJoinNode->node.pOutputDataBlockDesc);

×

1146

  if (NULL == pJoin->finBlk) {

×

1147

    QRY_ERR_RET(terrno);

×

1150

  int32_t code = blockDataEnsureCapacity(pJoin->finBlk, hJoinGetFinBlkCapacity(pJoin, pJoinNode));

×

1151

  if (TSDB_CODE_SUCCESS != code) {

×

1152

    QRY_ERR_RET(code);

×

1155

  if (NULL != pJoin->pPreFilter) {

×

1156

    pJoin->midBlk = NULL;

×

1157

    code = createOneDataBlock(pJoin->finBlk, false, &pJoin->midBlk);

×

1158

    if (code) {

×

1159

      QRY_ERR_RET(code);

×

1162

    code = blockDataEnsureCapacity(pJoin->midBlk, pJoin->finBlk->info.capacity);

×

1163

    if (TSDB_CODE_SUCCESS != code) {

×

1164

      QRY_ERR_RET(code);

×

1168

  pJoin->blkThreshold = pJoin->finBlk->info.capacity * HJOIN_BLK_THRESHOLD_RATIO;

×

1169

  return TSDB_CODE_SUCCESS;

×

1173

int32_t createHashJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream,

×

1175

  QRY_PARAM_CHECK(pOptrInfo);

×

1177

  int32_t             code = TSDB_CODE_SUCCESS;

×

1178

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

×

1179

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

×

1180

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

×

1181

    code = terrno;

×

1182

    goto _return;

×

1185

  pInfo->tblTimeRange.skey = pJoinNode->timeRange.skey;

×

1186

  pInfo->tblTimeRange.ekey = pJoinNode->timeRange.ekey;

×

1188

  pInfo->ctx.limit = (pJoinNode->node.pLimit && ((SLimitNode*)pJoinNode->node.pLimit)->limit) ? ((SLimitNode*)pJoinNode->node.pLimit)->limit->datum.i : INT64_MAX;

×

1190

  setOperatorInfo(pOperator, "HashJoinOperator", QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN, false, OP_NOT_OPENED, pInfo, pTaskInfo);

×

1192

  HJ_ERR_JRET(hJoinInitTableInfo(pInfo, pJoinNode, pDownstream, 0, &pJoinNode->inputStat[0]));

×

1193

  HJ_ERR_JRET(hJoinInitTableInfo(pInfo, pJoinNode, pDownstream, 1, &pJoinNode->inputStat[1]));

×

1195

  hJoinSetBuildAndProbeTable(pInfo, pJoinNode);

×

1197

  HJ_ERR_JRET(hJoinBuildResColsMap(pInfo, pJoinNode));

×

1199

  HJ_ERR_JRET(hJoinInitBufPages(pInfo));

×

1201

  size_t hashCap = pInfo->pBuild->inputStat.inputRowNum > 0 ? (pInfo->pBuild->inputStat.inputRowNum * 1.5) : 1024;

×

1202

  pInfo->pKeyHash = tSimpleHashInit(hashCap, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY));

×

1203

  if (pInfo->pKeyHash == NULL) {

×

1204

    code = terrno;

×

1205

    goto _return;

×

1208

  HJ_ERR_JRET(hJoinHandleConds(pInfo, pJoinNode));

×

1210

  HJ_ERR_JRET(hJoinInitResBlocks(pInfo, pJoinNode));

×

1212

  HJ_ERR_JRET(hJoinSetImplFp(pInfo));

×

1214

  HJ_ERR_JRET(appendDownstream(pOperator, pDownstream, numOfDownstream));

×

1216

  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, hJoinMainProcess, NULL, destroyHashJoinOperator, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);

×

1218

  qDebug("create hash Join operator done");

×

1220

  *pOptrInfo = pOperator;

×

1221

  return TSDB_CODE_SUCCESS;

×

1223

_return:

×

1225

  if (pInfo != NULL) {

×

1226

    destroyHashJoinOperator(pInfo);

×

1228

  destroyOperatorAndDownstreams(pOperator, pDownstream, numOfDownstream);

×

1229

  pTaskInfo->code = code;

×

1230

  return code;

×

taosdata / TDengine / #3814

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

taosdata / TDengine / #3814

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