execProcnode.c Source File (original) (raw)

121

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

143{

147

148

149

150

151 if (node == NULL)

152 return NULL;

153

154

155

156

157

158

160

162 {

163

164

165

166 case T_Result:

168 estate, eflags);

169 break;

170

171 case T_ProjectSet:

173 estate, eflags);

174 break;

175

176 case T_ModifyTable:

178 estate, eflags);

179 break;

180

181 case T_Append:

183 estate, eflags);

184 break;

185

186 case T_MergeAppend:

188 estate, eflags);

189 break;

190

191 case T_RecursiveUnion:

193 estate, eflags);

194 break;

195

196 case T_BitmapAnd:

198 estate, eflags);

199 break;

200

201 case T_BitmapOr:

203 estate, eflags);

204 break;

205

206

207

208

209 case T_SeqScan:

211 estate, eflags);

212 break;

213

214 case T_SampleScan:

216 estate, eflags);

217 break;

218

219 case T_IndexScan:

221 estate, eflags);

222 break;

223

224 case T_IndexOnlyScan:

226 estate, eflags);

227 break;

228

229 case T_BitmapIndexScan:

231 estate, eflags);

232 break;

233

234 case T_BitmapHeapScan:

236 estate, eflags);

237 break;

238

239 case T_TidScan:

241 estate, eflags);

242 break;

243

244 case T_TidRangeScan:

246 estate, eflags);

247 break;

248

249 case T_SubqueryScan:

251 estate, eflags);

252 break;

253

254 case T_FunctionScan:

256 estate, eflags);

257 break;

258

259 case T_TableFuncScan:

261 estate, eflags);

262 break;

263

264 case T_ValuesScan:

266 estate, eflags);

267 break;

268

269 case T_CteScan:

271 estate, eflags);

272 break;

273

274 case T_NamedTuplestoreScan:

276 estate, eflags);

277 break;

278

279 case T_WorkTableScan:

281 estate, eflags);

282 break;

283

284 case T_ForeignScan:

286 estate, eflags);

287 break;

288

289 case T_CustomScan:

291 estate, eflags);

292 break;

293

294

295

296

297 case T_NestLoop:

299 estate, eflags);

300 break;

301

302 case T_MergeJoin:

304 estate, eflags);

305 break;

306

307 case T_HashJoin:

309 estate, eflags);

310 break;

311

312

313

314

315 case T_Material:

317 estate, eflags);

318 break;

319

320 case T_Sort:

322 estate, eflags);

323 break;

324

325 case T_IncrementalSort:

327 estate, eflags);

328 break;

329

330 case T_Memoize:

332 eflags);

333 break;

334

335 case T_Group:

337 estate, eflags);

338 break;

339

340 case T_Agg:

342 estate, eflags);

343 break;

344

345 case T_WindowAgg:

347 estate, eflags);

348 break;

349

350 case T_Unique:

352 estate, eflags);

353 break;

354

355 case T_Gather:

357 estate, eflags);

358 break;

359

360 case T_GatherMerge:

362 estate, eflags);

363 break;

364

365 case T_Hash:

367 estate, eflags);

368 break;

369

370 case T_SetOp:

372 estate, eflags);

373 break;

374

375 case T_LockRows:

377 estate, eflags);

378 break;

379

380 case T_Limit:

382 estate, eflags);

383 break;

384

385 default:

386 elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));

387 result = NULL;

388 break;

389 }

390

392

393

394

395

396

397

398

399

400

401 subps = NIL;

403 {

406

410 subps = lappend(subps, sstate);

411 }

413

414

418

419 return result;

420}

421

422

423

424

425

426

427

428

429void

431{

432

433

434

435

436

437

440}

441

442

443

444

445

446

449{

450

451

452

453

454

455

456

458

459

460

461

462

463

466 else

468

470}

471

472

473

474

475

476

477

480{

482

484

486

488

489 return result;

490}

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

508{

509 Node *result;

510

512

514

515 if (node->chgParam != NULL)

516 ExecReScan(node);

517

519 {

520

521

522

523

524 case T_HashState:

526 break;

527

528 case T_BitmapIndexScanState:

530 break;

531

532 case T_BitmapAndState:

534 break;

535

536 case T_BitmapOrState:

538 break;

539

540 default:

541 elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));

542 result = NULL;

543 break;

544 }

545

546 return result;

547}

548

549

550

551

552

553

554

555

556

557

558

559

560

561void

563{

564

565

566

567 if (node == NULL)

568 return;

569

570

571

572

573

574

576

578 {

581 }

582

584 {

585

586

587

588 case T_ResultState:

590 break;

591

592 case T_ProjectSetState:

594 break;

595

596 case T_ModifyTableState:

598 break;

599

600 case T_AppendState:

602 break;

603

604 case T_MergeAppendState:

606 break;

607

608 case T_RecursiveUnionState:

610 break;

611

612 case T_BitmapAndState:

614 break;

615

616 case T_BitmapOrState:

618 break;

619

620

621

622

623 case T_SeqScanState:

625 break;

626

627 case T_SampleScanState:

629 break;

630

631 case T_GatherState:

633 break;

634

635 case T_GatherMergeState:

637 break;

638

639 case T_IndexScanState:

641 break;

642

643 case T_IndexOnlyScanState:

645 break;

646

647 case T_BitmapIndexScanState:

649 break;

650

651 case T_BitmapHeapScanState:

653 break;

654

655 case T_TidScanState:

657 break;

658

659 case T_TidRangeScanState:

661 break;

662

663 case T_SubqueryScanState:

665 break;

666

667 case T_FunctionScanState:

669 break;

670

671 case T_TableFuncScanState:

673 break;

674

675 case T_CteScanState:

677 break;

678

679 case T_ForeignScanState:

681 break;

682

683 case T_CustomScanState:

685 break;

686

687

688

689

690 case T_NestLoopState:

692 break;

693

694 case T_MergeJoinState:

696 break;

697

698 case T_HashJoinState:

700 break;

701

702

703

704

705 case T_MaterialState:

707 break;

708

709 case T_SortState:

711 break;

712

713 case T_IncrementalSortState:

715 break;

716

717 case T_MemoizeState:

719 break;

720

721 case T_GroupState:

723 break;

724

725 case T_AggState:

727 break;

728

729 case T_WindowAggState:

731 break;

732

733 case T_UniqueState:

735 break;

736

737 case T_HashState:

739 break;

740

741 case T_SetOpState:

743 break;

744

745 case T_LockRowsState:

747 break;

748

749 case T_LimitState:

751 break;

752

753

754 case T_ValuesScanState:

755 case T_NamedTuplestoreScanState:

756 case T_WorkTableScanState:

757 break;

758

759 default:

760 elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));

761 break;

762 }

763}

764

765

766

767

768

769

770

771void

773{

775}

776

777static bool

779{

780 if (node == NULL)

781 return false;

782

784

785

786

787

788

789

790

791

792

793

794

797

799

801 {

802 case T_GatherState:

804 break;

805 case T_ForeignScanState:

807 break;

808 case T_CustomScanState:

810 break;

811 case T_GatherMergeState:

813 break;

814 case T_HashState:

816 break;

817 case T_HashJoinState:

819 break;

820 default:

821 break;

822 }

823

824

827

828 return false;

829}

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847void

849{

850

851

852

853

854

855

857 {

858

859

860

861

862

863

864

865

867

868 if (tuples_needed < 0)

869 {

870

871 sortState->bounded = false;

872 }

873 else

874 {

875 sortState->bounded = true;

876 sortState->bound = tuples_needed;

877 }

878 }

880 {

881

882

883

884

885

886

887

888

889

891

892 if (tuples_needed < 0)

893 {

894

895 sortState->bounded = false;

896 }

897 else

898 {

899 sortState->bounded = true;

900 sortState->bound = tuples_needed;

901 }

902 }

904 {

905

906

907

908

909

911 int i;

912

915 }

917 {

918

919

920

921

922

924 int i;

925

928 }

930 {

931

932

933

934

935

936

937

938

939

942 }

944 {

945

946

947

948

950

951 if (subqueryState->ss.ps.qual == NULL)

953 }

955 {

956

957

958

959

960

961

962

963

965

967

968

970 }

972 {

973

975

977

979 }

980

981

982

983

984

985

986

987}

void bms_free(Bitmapset *a)

void ExecReScan(PlanState *node)

static bool ExecShutdownNode_walker(PlanState *node, void *context)

Node * MultiExecProcNode(PlanState *node)

void ExecSetTupleBound(int64 tuples_needed, PlanState *child_node)

void ExecEndNode(PlanState *node)

PlanState * ExecInitNode(Plan *node, EState *estate, int eflags)

void ExecShutdownNode(PlanState *node)

static TupleTableSlot * ExecProcNodeInstr(PlanState *node)

static TupleTableSlot * ExecProcNodeFirst(PlanState *node)

void ExecSetExecProcNode(PlanState *node, ExecProcNodeMtd function)

TupleTableSlot *(* ExecProcNodeMtd)(struct PlanState *pstate)

#define outerPlanState(node)

Assert(PointerIsAligned(start, uint64))

Instrumentation * InstrAlloc(int n, int instrument_options, bool async_mode)

void InstrStartNode(Instrumentation *instr)

void InstrStopNode(Instrumentation *instr, double nTuples)

List * lappend(List *list, void *datum)

#define CHECK_FOR_INTERRUPTS()

void ExecEndAgg(AggState *node)

AggState * ExecInitAgg(Agg *node, EState *estate, int eflags)

void ExecEndAppend(AppendState *node)

AppendState * ExecInitAppend(Append *node, EState *estate, int eflags)

BitmapAndState * ExecInitBitmapAnd(BitmapAnd *node, EState *estate, int eflags)

Node * MultiExecBitmapAnd(BitmapAndState *node)

void ExecEndBitmapAnd(BitmapAndState *node)

void ExecEndBitmapHeapScan(BitmapHeapScanState *node)

BitmapHeapScanState * ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags)

Node * MultiExecBitmapIndexScan(BitmapIndexScanState *node)

void ExecEndBitmapIndexScan(BitmapIndexScanState *node)

BitmapIndexScanState * ExecInitBitmapIndexScan(BitmapIndexScan *node, EState *estate, int eflags)

void ExecEndBitmapOr(BitmapOrState *node)

Node * MultiExecBitmapOr(BitmapOrState *node)

BitmapOrState * ExecInitBitmapOr(BitmapOr *node, EState *estate, int eflags)

CteScanState * ExecInitCteScan(CteScan *node, EState *estate, int eflags)

void ExecEndCteScan(CteScanState *node)

void ExecShutdownCustomScan(CustomScanState *node)

void ExecEndCustomScan(CustomScanState *node)

CustomScanState * ExecInitCustomScan(CustomScan *cscan, EState *estate, int eflags)

ForeignScanState * ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)

void ExecShutdownForeignScan(ForeignScanState *node)

void ExecEndForeignScan(ForeignScanState *node)

#define planstate_tree_walker(ps, w, c)

FunctionScanState * ExecInitFunctionScan(FunctionScan *node, EState *estate, int eflags)

void ExecEndFunctionScan(FunctionScanState *node)

void ExecShutdownGatherMerge(GatherMergeState *node)

GatherMergeState * ExecInitGatherMerge(GatherMerge *node, EState *estate, int eflags)

void ExecEndGatherMerge(GatherMergeState *node)

void ExecEndGather(GatherState *node)

void ExecShutdownGather(GatherState *node)

GatherState * ExecInitGather(Gather *node, EState *estate, int eflags)

GroupState * ExecInitGroup(Group *node, EState *estate, int eflags)

void ExecEndGroup(GroupState *node)

Node * MultiExecHash(HashState *node)

HashState * ExecInitHash(Hash *node, EState *estate, int eflags)

void ExecEndHash(HashState *node)

void ExecShutdownHash(HashState *node)

void ExecEndHashJoin(HashJoinState *node)

void ExecShutdownHashJoin(HashJoinState *node)

HashJoinState * ExecInitHashJoin(HashJoin *node, EState *estate, int eflags)

void ExecEndIncrementalSort(IncrementalSortState *node)

IncrementalSortState * ExecInitIncrementalSort(IncrementalSort *node, EState *estate, int eflags)

void ExecEndIndexOnlyScan(IndexOnlyScanState *node)

IndexOnlyScanState * ExecInitIndexOnlyScan(IndexOnlyScan *node, EState *estate, int eflags)

IndexScanState * ExecInitIndexScan(IndexScan *node, EState *estate, int eflags)

void ExecEndIndexScan(IndexScanState *node)

LimitState * ExecInitLimit(Limit *node, EState *estate, int eflags)

void ExecEndLimit(LimitState *node)

LockRowsState * ExecInitLockRows(LockRows *node, EState *estate, int eflags)

void ExecEndLockRows(LockRowsState *node)

MaterialState * ExecInitMaterial(Material *node, EState *estate, int eflags)

void ExecEndMaterial(MaterialState *node)

MemoizeState * ExecInitMemoize(Memoize *node, EState *estate, int eflags)

void ExecEndMemoize(MemoizeState *node)

MergeAppendState * ExecInitMergeAppend(MergeAppend *node, EState *estate, int eflags)

void ExecEndMergeAppend(MergeAppendState *node)

MergeJoinState * ExecInitMergeJoin(MergeJoin *node, EState *estate, int eflags)

void ExecEndMergeJoin(MergeJoinState *node)

ModifyTableState * ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)

void ExecEndModifyTable(ModifyTableState *node)

NamedTuplestoreScanState * ExecInitNamedTuplestoreScan(NamedTuplestoreScan *node, EState *estate, int eflags)

void ExecEndNestLoop(NestLoopState *node)

NestLoopState * ExecInitNestLoop(NestLoop *node, EState *estate, int eflags)

ProjectSetState * ExecInitProjectSet(ProjectSet *node, EState *estate, int eflags)

void ExecEndProjectSet(ProjectSetState *node)

void ExecEndRecursiveUnion(RecursiveUnionState *node)

RecursiveUnionState * ExecInitRecursiveUnion(RecursiveUnion *node, EState *estate, int eflags)

ResultState * ExecInitResult(Result *node, EState *estate, int eflags)

void ExecEndResult(ResultState *node)

SampleScanState * ExecInitSampleScan(SampleScan *node, EState *estate, int eflags)

void ExecEndSampleScan(SampleScanState *node)

void ExecEndSeqScan(SeqScanState *node)

SeqScanState * ExecInitSeqScan(SeqScan *node, EState *estate, int eflags)

void ExecEndSetOp(SetOpState *node)

SetOpState * ExecInitSetOp(SetOp *node, EState *estate, int eflags)

SortState * ExecInitSort(Sort *node, EState *estate, int eflags)

void ExecEndSort(SortState *node)

SubPlanState * ExecInitSubPlan(SubPlan *subplan, PlanState *parent)

void ExecEndSubqueryScan(SubqueryScanState *node)

SubqueryScanState * ExecInitSubqueryScan(SubqueryScan *node, EState *estate, int eflags)

void ExecEndTableFuncScan(TableFuncScanState *node)

TableFuncScanState * ExecInitTableFuncScan(TableFuncScan *node, EState *estate, int eflags)

void ExecEndTidRangeScan(TidRangeScanState *node)

TidRangeScanState * ExecInitTidRangeScan(TidRangeScan *node, EState *estate, int eflags)

TidScanState * ExecInitTidScan(TidScan *node, EState *estate, int eflags)

void ExecEndTidScan(TidScanState *node)

void ExecEndUnique(UniqueState *node)

UniqueState * ExecInitUnique(Unique *node, EState *estate, int eflags)

ValuesScanState * ExecInitValuesScan(ValuesScan *node, EState *estate, int eflags)

void ExecEndWindowAgg(WindowAggState *node)

WindowAggState * ExecInitWindowAgg(WindowAgg *node, EState *estate, int eflags)

WorkTableScanState * ExecInitWorkTableScan(WorkTableScan *node, EState *estate, int eflags)

#define IsA(nodeptr, _type_)

on_exit_nicely_callback function

void check_stack_depth(void)

Instrumentation * instrument

ExecProcNodeMtd ExecProcNodeReal

ExecProcNodeMtd ExecProcNode