PostgreSQL Source Code: src/backend/executor/execProcnode.c File Reference (original) (raw)

Go to the source code of this file.

◆ ExecEndNode()

Definition at line 562 of file execProcnode.c.

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}

void bms_free(Bitmapset *a)

void ExecEndAgg(AggState *node)

void ExecEndAppend(AppendState *node)

void ExecEndBitmapAnd(BitmapAndState *node)

void ExecEndBitmapHeapScan(BitmapHeapScanState *node)

void ExecEndBitmapIndexScan(BitmapIndexScanState *node)

void ExecEndBitmapOr(BitmapOrState *node)

void ExecEndCteScan(CteScanState *node)

void ExecEndCustomScan(CustomScanState *node)

void ExecEndForeignScan(ForeignScanState *node)

void ExecEndFunctionScan(FunctionScanState *node)

void ExecEndGatherMerge(GatherMergeState *node)

void ExecEndGather(GatherState *node)

void ExecEndGroup(GroupState *node)

void ExecEndHash(HashState *node)

void ExecEndHashJoin(HashJoinState *node)

void ExecEndIncrementalSort(IncrementalSortState *node)

void ExecEndIndexOnlyScan(IndexOnlyScanState *node)

void ExecEndIndexScan(IndexScanState *node)

void ExecEndLimit(LimitState *node)

void ExecEndLockRows(LockRowsState *node)

void ExecEndMaterial(MaterialState *node)

void ExecEndMemoize(MemoizeState *node)

void ExecEndMergeAppend(MergeAppendState *node)

void ExecEndMergeJoin(MergeJoinState *node)

void ExecEndModifyTable(ModifyTableState *node)

void ExecEndNestLoop(NestLoopState *node)

void ExecEndProjectSet(ProjectSetState *node)

void ExecEndRecursiveUnion(RecursiveUnionState *node)

void ExecEndResult(ResultState *node)

void ExecEndSampleScan(SampleScanState *node)

void ExecEndSeqScan(SeqScanState *node)

void ExecEndSetOp(SetOpState *node)

void ExecEndSort(SortState *node)

void ExecEndSubqueryScan(SubqueryScanState *node)

void ExecEndTableFuncScan(TableFuncScanState *node)

void ExecEndTidRangeScan(TidRangeScanState *node)

void ExecEndTidScan(TidScanState *node)

void ExecEndUnique(UniqueState *node)

void ExecEndWindowAgg(WindowAggState *node)

void check_stack_depth(void)

References bms_free(), check_stack_depth(), PlanState::chgParam, elog, ERROR, ExecEndAgg(), ExecEndAppend(), ExecEndBitmapAnd(), ExecEndBitmapHeapScan(), ExecEndBitmapIndexScan(), ExecEndBitmapOr(), ExecEndCteScan(), ExecEndCustomScan(), ExecEndForeignScan(), ExecEndFunctionScan(), ExecEndGather(), ExecEndGatherMerge(), ExecEndGroup(), ExecEndHash(), ExecEndHashJoin(), ExecEndIncrementalSort(), ExecEndIndexOnlyScan(), ExecEndIndexScan(), ExecEndLimit(), ExecEndLockRows(), ExecEndMaterial(), ExecEndMemoize(), ExecEndMergeAppend(), ExecEndMergeJoin(), ExecEndModifyTable(), ExecEndNestLoop(), ExecEndProjectSet(), ExecEndRecursiveUnion(), ExecEndResult(), ExecEndSampleScan(), ExecEndSeqScan(), ExecEndSetOp(), ExecEndSort(), ExecEndSubqueryScan(), ExecEndTableFuncScan(), ExecEndTidRangeScan(), ExecEndTidScan(), ExecEndUnique(), ExecEndWindowAgg(), and nodeTag.

Referenced by EvalPlanQualEnd(), ExecEndAgg(), ExecEndAppend(), ExecEndBitmapAnd(), ExecEndBitmapHeapScan(), ExecEndBitmapOr(), ExecEndForeignScan(), ExecEndGather(), ExecEndGatherMerge(), ExecEndGroup(), ExecEndHash(), ExecEndHashJoin(), ExecEndIncrementalSort(), ExecEndLimit(), ExecEndLockRows(), ExecEndMaterial(), ExecEndMemoize(), ExecEndMergeAppend(), ExecEndMergeJoin(), ExecEndModifyTable(), ExecEndNestLoop(), ExecEndPlan(), ExecEndProjectSet(), ExecEndRecursiveUnion(), ExecEndResult(), ExecEndSetOp(), ExecEndSort(), ExecEndSubqueryScan(), ExecEndUnique(), and ExecEndWindowAgg().

◆ ExecInitNode()

Definition at line 142 of file execProcnode.c.

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

415 if (estate->es_instrument)

418

419 return result;

420}

void ExecSetExecProcNode(PlanState *node, ExecProcNodeMtd function)

Assert(PointerIsAligned(start, uint64))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#define IsA(nodeptr, _type_)

Instrumentation * instrument

ExecProcNodeMtd ExecProcNode

References SubPlan::args, Assert(), PlanState::async_capable, check_stack_depth(), elog, ERROR, EState::es_instrument, ExecInitAgg(), ExecInitAppend(), ExecInitBitmapAnd(), ExecInitBitmapHeapScan(), ExecInitBitmapIndexScan(), ExecInitBitmapOr(), ExecInitCteScan(), ExecInitCustomScan(), ExecInitForeignScan(), ExecInitFunctionScan(), ExecInitGather(), ExecInitGatherMerge(), ExecInitGroup(), ExecInitHash(), ExecInitHashJoin(), ExecInitIncrementalSort(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecInitLimit(), ExecInitLockRows(), ExecInitMaterial(), ExecInitMemoize(), ExecInitMergeAppend(), ExecInitMergeJoin(), ExecInitModifyTable(), ExecInitNamedTuplestoreScan(), ExecInitNestLoop(), ExecInitProjectSet(), ExecInitRecursiveUnion(), ExecInitResult(), ExecInitSampleScan(), ExecInitSeqScan(), ExecInitSetOp(), ExecInitSort(), ExecInitSubPlan(), ExecInitSubqueryScan(), ExecInitTableFuncScan(), ExecInitTidRangeScan(), ExecInitTidScan(), ExecInitUnique(), ExecInitValuesScan(), ExecInitWindowAgg(), ExecInitWorkTableScan(), PlanState::ExecProcNode, ExecSetExecProcNode(), PlanState::initPlan, Plan::initPlan, InstrAlloc(), PlanState::instrument, IsA, lappend(), lfirst, NIL, and nodeTag.

Referenced by EvalPlanQualStart(), ExecInitAgg(), ExecInitAppend(), ExecInitBitmapAnd(), ExecInitBitmapHeapScan(), ExecInitBitmapOr(), ExecInitForeignScan(), ExecInitGather(), ExecInitGatherMerge(), ExecInitGroup(), ExecInitHash(), ExecInitHashJoin(), ExecInitIncrementalSort(), ExecInitLimit(), ExecInitLockRows(), ExecInitMaterial(), ExecInitMemoize(), ExecInitMergeAppend(), ExecInitMergeJoin(), ExecInitModifyTable(), ExecInitNestLoop(), ExecInitProjectSet(), ExecInitRecursiveUnion(), ExecInitResult(), ExecInitSetOp(), ExecInitSort(), ExecInitSubqueryScan(), ExecInitUnique(), ExecInitWindowAgg(), and InitPlan().

◆ ExecProcNodeFirst()

◆ ExecProcNodeInstr()

◆ ExecSetExecProcNode()

◆ ExecSetTupleBound()

Definition at line 848 of file execProcnode.c.

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 ExecSetTupleBound(int64 tuples_needed, PlanState *child_node)

#define outerPlanState(node)

References AppendState::appendplans, AppendState::as_nplans, SortState::bound, IncrementalSortState::bound, SortState::bounded, IncrementalSortState::bounded, ExecSetTupleBound(), i, IsA, MergeAppendState::mergeplans, MergeAppendState::ms_nplans, outerPlanState, ScanState::ps, PlanState::qual, SubqueryScanState::ss, SubqueryScanState::subplan, GatherState::tuples_needed, and GatherMergeState::tuples_needed.

Referenced by ExecSetTupleBound(), ParallelQueryMain(), and recompute_limits().

◆ ExecShutdownNode()

◆ ExecShutdownNode_walker()

Definition at line 778 of file execProcnode.c.

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}

void ExecShutdownCustomScan(CustomScanState *node)

void ExecShutdownForeignScan(ForeignScanState *node)

#define planstate_tree_walker(ps, w, c)

void ExecShutdownGatherMerge(GatherMergeState *node)

void ExecShutdownGather(GatherState *node)

void ExecShutdownHash(HashState *node)

void ExecShutdownHashJoin(HashJoinState *node)

References check_stack_depth(), ExecShutdownCustomScan(), ExecShutdownForeignScan(), ExecShutdownGather(), ExecShutdownGatherMerge(), ExecShutdownHash(), ExecShutdownHashJoin(), ExecShutdownNode_walker(), InstrStartNode(), InstrStopNode(), PlanState::instrument, nodeTag, planstate_tree_walker, and Instrumentation::running.

Referenced by ExecShutdownNode(), and ExecShutdownNode_walker().

◆ MultiExecProcNode()

Definition at line 507 of file execProcnode.c.

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}

void ExecReScan(PlanState *node)

#define CHECK_FOR_INTERRUPTS()

Node * MultiExecBitmapAnd(BitmapAndState *node)

Node * MultiExecBitmapIndexScan(BitmapIndexScanState *node)

Node * MultiExecBitmapOr(BitmapOrState *node)

Node * MultiExecHash(HashState *node)

References CHECK_FOR_INTERRUPTS, check_stack_depth(), PlanState::chgParam, elog, ERROR, ExecReScan(), MultiExecBitmapAnd(), MultiExecBitmapIndexScan(), MultiExecBitmapOr(), MultiExecHash(), and nodeTag.

Referenced by BitmapTableScanSetup(), ExecHashJoinImpl(), MultiExecBitmapAnd(), and MultiExecBitmapOr().