PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
nodeSort.h File Reference
#include "access/parallel.h"
#include "nodes/execnodes.h"
Include dependency graph for nodeSort.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

SortStateExecInitSort (Sort *node, EState *estate, int eflags)
 
void ExecEndSort (SortState *node)
 
void ExecSortMarkPos (SortState *node)
 
void ExecSortRestrPos (SortState *node)
 
void ExecReScanSort (SortState *node)
 
void ExecSortEstimate (SortState *node, ParallelContext *pcxt)
 
void ExecSortInitializeDSM (SortState *node, ParallelContext *pcxt)
 
void ExecSortInitializeWorker (SortState *node, ParallelWorkerContext *pwcxt)
 
void ExecSortRetrieveInstrumentation (SortState *node)
 

Function Documentation

◆ ExecEndSort()

void ExecEndSort ( SortState node)

Definition at line 301 of file nodeSort.c.

302{
303 SO1_printf("ExecEndSort: %s\n",
304 "shutting down sort node");
305
306 /*
307 * Release tuplesort resources
308 */
309 if (node->tuplesortstate != NULL)
311 node->tuplesortstate = NULL;
312
313 /*
314 * shut down the subplan
315 */
317
318 SO1_printf("ExecEndSort: %s\n",
319 "sort node shutdown");
320}
void ExecEndNode(PlanState *node)
Definition: execProcnode.c:562
#define SO1_printf(s, p)
Definition: execdebug.h:93
#define outerPlanState(node)
Definition: execnodes.h:1221
void * tuplesortstate
Definition: execnodes.h:2369
void tuplesort_end(Tuplesortstate *state)
Definition: tuplesort.c:951

References ExecEndNode(), outerPlanState, SO1_printf, tuplesort_end(), and SortState::tuplesortstate.

Referenced by ExecEndNode().

◆ ExecInitSort()

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

Definition at line 221 of file nodeSort.c.

222{
223 SortState *sortstate;
224 TupleDesc outerTupDesc;
225
226 SO1_printf("ExecInitSort: %s\n",
227 "initializing sort node");
228
229 /*
230 * create state structure
231 */
232 sortstate = makeNode(SortState);
233 sortstate->ss.ps.plan = (Plan *) node;
234 sortstate->ss.ps.state = estate;
235 sortstate->ss.ps.ExecProcNode = ExecSort;
236
237 /*
238 * We must have random access to the sort output to do backward scan or
239 * mark/restore. We also prefer to materialize the sort output if we
240 * might be called on to rewind and replay it many times.
241 */
242 sortstate->randomAccess = (eflags & (EXEC_FLAG_REWIND |
244 EXEC_FLAG_MARK)) != 0;
245
246 sortstate->bounded = false;
247 sortstate->sort_Done = false;
248 sortstate->tuplesortstate = NULL;
249
250 /*
251 * Miscellaneous initialization
252 *
253 * Sort nodes don't initialize their ExprContexts because they never call
254 * ExecQual or ExecProject.
255 */
256
257 /*
258 * initialize child nodes
259 *
260 * We shield the child node from the need to support REWIND, BACKWARD, or
261 * MARK/RESTORE.
262 */
264
265 outerPlanState(sortstate) = ExecInitNode(outerPlan(node), estate, eflags);
266
267 /*
268 * Initialize scan slot and type.
269 */
270 ExecCreateScanSlotFromOuterPlan(estate, &sortstate->ss, &TTSOpsVirtual);
271
272 /*
273 * Initialize return slot and type. No need to initialize projection info
274 * because this node doesn't do projections.
275 */
277 sortstate->ss.ps.ps_ProjInfo = NULL;
278
279 outerTupDesc = ExecGetResultType(outerPlanState(sortstate));
280
281 /*
282 * We perform a Datum sort when we're sorting just a single column,
283 * otherwise we perform a tuple sort.
284 */
285 if (outerTupDesc->natts == 1)
286 sortstate->datumSort = true;
287 else
288 sortstate->datumSort = false;
289
290 SO1_printf("ExecInitSort: %s\n",
291 "sort node initialized");
292
293 return sortstate;
294}
PlanState * ExecInitNode(Plan *node, EState *estate, int eflags)
Definition: execProcnode.c:142
const TupleTableSlotOps TTSOpsVirtual
Definition: execTuples.c:84
void ExecInitResultTupleSlotTL(PlanState *planstate, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1986
const TupleTableSlotOps TTSOpsMinimalTuple
Definition: execTuples.c:86
TupleDesc ExecGetResultType(PlanState *planstate)
Definition: execUtils.c:495
void ExecCreateScanSlotFromOuterPlan(EState *estate, ScanState *scanstate, const TupleTableSlotOps *tts_ops)
Definition: execUtils.c:704
#define EXEC_FLAG_BACKWARD
Definition: executor.h:68
#define EXEC_FLAG_REWIND
Definition: executor.h:67
#define EXEC_FLAG_MARK
Definition: executor.h:69
static TupleTableSlot * ExecSort(PlanState *pstate)
Definition: nodeSort.c:50
#define makeNode(_type_)
Definition: nodes.h:155
#define outerPlan(node)
Definition: plannodes.h:183
Plan * plan
Definition: execnodes.h:1125
EState * state
Definition: execnodes.h:1127
ProjectionInfo * ps_ProjInfo
Definition: execnodes.h:1165
ExecProcNodeMtd ExecProcNode
Definition: execnodes.h:1131
PlanState ps
Definition: execnodes.h:1572
bool sort_Done
Definition: execnodes.h:2366
bool randomAccess
Definition: execnodes.h:2363
bool datumSort
Definition: execnodes.h:2371
ScanState ss
Definition: execnodes.h:2362
bool bounded
Definition: execnodes.h:2364

References SortState::bounded, SortState::datumSort, EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, EXEC_FLAG_REWIND, ExecCreateScanSlotFromOuterPlan(), ExecGetResultType(), ExecInitNode(), ExecInitResultTupleSlotTL(), PlanState::ExecProcNode, ExecSort(), makeNode, TupleDescData::natts, outerPlan, outerPlanState, PlanState::plan, ScanState::ps, PlanState::ps_ProjInfo, SortState::randomAccess, SO1_printf, SortState::sort_Done, SortState::ss, PlanState::state, TTSOpsMinimalTuple, TTSOpsVirtual, and SortState::tuplesortstate.

Referenced by ExecInitNode().

◆ ExecReScanSort()

void ExecReScanSort ( SortState node)

Definition at line 362 of file nodeSort.c.

363{
365
366 /*
367 * If we haven't sorted yet, just return. If outerplan's chgParam is not
368 * NULL then it will be re-scanned by ExecProcNode, else no reason to
369 * re-scan it at all.
370 */
371 if (!node->sort_Done)
372 return;
373
374 /* must drop pointer to sort result tuple */
376
377 /*
378 * If subnode is to be rescanned then we forget previous sort results; we
379 * have to re-read the subplan and re-sort. Also must re-sort if the
380 * bounded-sort parameters changed or we didn't select randomAccess.
381 *
382 * Otherwise we can just rewind and rescan the sorted output.
383 */
384 if (outerPlan->chgParam != NULL ||
385 node->bounded != node->bounded_Done ||
386 node->bound != node->bound_Done ||
387 !node->randomAccess)
388 {
389 node->sort_Done = false;
391 node->tuplesortstate = NULL;
392
393 /*
394 * if chgParam of subnode is not null then plan will be re-scanned by
395 * first ExecProcNode.
396 */
397 if (outerPlan->chgParam == NULL)
399 }
400 else
402}
void ExecReScan(PlanState *node)
Definition: execAmi.c:76
TupleTableSlot * ps_ResultTupleSlot
Definition: execnodes.h:1163
int64 bound_Done
Definition: execnodes.h:2368
bool bounded_Done
Definition: execnodes.h:2367
int64 bound
Definition: execnodes.h:2365
void tuplesort_rescan(Tuplesortstate *state)
Definition: tuplesort.c:2402
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:454

References SortState::bound, SortState::bound_Done, SortState::bounded, SortState::bounded_Done, ExecClearTuple(), ExecReScan(), outerPlan, outerPlanState, ScanState::ps, PlanState::ps_ResultTupleSlot, SortState::randomAccess, SortState::sort_Done, SortState::ss, tuplesort_end(), tuplesort_rescan(), and SortState::tuplesortstate.

Referenced by ExecReScan().

◆ ExecSortEstimate()

void ExecSortEstimate ( SortState node,
ParallelContext pcxt 
)

Definition at line 416 of file nodeSort.c.

417{
418 Size size;
419
420 /* don't need this if not instrumenting or no workers */
421 if (!node->ss.ps.instrument || pcxt->nworkers == 0)
422 return;
423
425 size = add_size(size, offsetof(SharedSortInfo, sinstrument));
428}
size_t Size
Definition: c.h:559
#define shm_toc_estimate_chunk(e, sz)
Definition: shm_toc.h:51
#define shm_toc_estimate_keys(e, cnt)
Definition: shm_toc.h:53
Size add_size(Size s1, Size s2)
Definition: shmem.c:488
Size mul_size(Size s1, Size s2)
Definition: shmem.c:505
static pg_noinline void Size size
Definition: slab.c:607
shm_toc_estimator estimator
Definition: parallel.h:41
Instrumentation * instrument
Definition: execnodes.h:1135

References add_size(), ParallelContext::estimator, PlanState::instrument, mul_size(), ParallelContext::nworkers, ScanState::ps, shm_toc_estimate_chunk, shm_toc_estimate_keys, size, and SortState::ss.

Referenced by ExecParallelEstimate().

◆ ExecSortInitializeDSM()

void ExecSortInitializeDSM ( SortState node,
ParallelContext pcxt 
)

Definition at line 437 of file nodeSort.c.

438{
439 Size size;
440
441 /* don't need this if not instrumenting or no workers */
442 if (!node->ss.ps.instrument || pcxt->nworkers == 0)
443 return;
444
445 size = offsetof(SharedSortInfo, sinstrument)
446 + pcxt->nworkers * sizeof(TuplesortInstrumentation);
447 node->shared_info = shm_toc_allocate(pcxt->toc, size);
448 /* ensure any unfilled slots will contain zeroes */
449 memset(node->shared_info, 0, size);
450 node->shared_info->num_workers = pcxt->nworkers;
451 shm_toc_insert(pcxt->toc, node->ss.ps.plan->plan_node_id,
452 node->shared_info);
453}
void * shm_toc_allocate(shm_toc *toc, Size nbytes)
Definition: shm_toc.c:88
void shm_toc_insert(shm_toc *toc, uint64 key, void *address)
Definition: shm_toc.c:171
shm_toc * toc
Definition: parallel.h:44
int plan_node_id
Definition: plannodes.h:152
SharedSortInfo * shared_info
Definition: execnodes.h:2372
struct TuplesortInstrumentation TuplesortInstrumentation

References PlanState::instrument, SharedSortInfo::num_workers, ParallelContext::nworkers, PlanState::plan, Plan::plan_node_id, ScanState::ps, SortState::shared_info, shm_toc_allocate(), shm_toc_insert(), size, SortState::ss, and ParallelContext::toc.

Referenced by ExecParallelInitializeDSM().

◆ ExecSortInitializeWorker()

void ExecSortInitializeWorker ( SortState node,
ParallelWorkerContext pwcxt 
)

Definition at line 462 of file nodeSort.c.

463{
464 node->shared_info =
465 shm_toc_lookup(pwcxt->toc, node->ss.ps.plan->plan_node_id, true);
466 node->am_worker = true;
467}
void * shm_toc_lookup(shm_toc *toc, uint64 key, bool noError)
Definition: shm_toc.c:232
bool am_worker
Definition: execnodes.h:2370

References SortState::am_worker, PlanState::plan, Plan::plan_node_id, ScanState::ps, SortState::shared_info, shm_toc_lookup(), SortState::ss, and ParallelWorkerContext::toc.

Referenced by ExecParallelInitializeWorker().

◆ ExecSortMarkPos()

void ExecSortMarkPos ( SortState node)

Definition at line 329 of file nodeSort.c.

330{
331 /*
332 * if we haven't sorted yet, just return
333 */
334 if (!node->sort_Done)
335 return;
336
338}
void tuplesort_markpos(Tuplesortstate *state)
Definition: tuplesort.c:2435

References SortState::sort_Done, tuplesort_markpos(), and SortState::tuplesortstate.

Referenced by ExecMarkPos().

◆ ExecSortRestrPos()

void ExecSortRestrPos ( SortState node)

Definition at line 347 of file nodeSort.c.

348{
349 /*
350 * if we haven't sorted yet, just return.
351 */
352 if (!node->sort_Done)
353 return;
354
355 /*
356 * restore the scan to the previously marked position
357 */
359}
void tuplesort_restorepos(Tuplesortstate *state)
Definition: tuplesort.c:2466

References SortState::sort_Done, tuplesort_restorepos(), and SortState::tuplesortstate.

Referenced by ExecRestrPos().

◆ ExecSortRetrieveInstrumentation()

void ExecSortRetrieveInstrumentation ( SortState node)

Definition at line 476 of file nodeSort.c.

477{
478 Size size;
479 SharedSortInfo *si;
480
481 if (node->shared_info == NULL)
482 return;
483
484 size = offsetof(SharedSortInfo, sinstrument)
486 si = palloc(size);
487 memcpy(si, node->shared_info, size);
488 node->shared_info = si;
489}
void * palloc(Size size)
Definition: mcxt.c:1317

References SharedSortInfo::num_workers, palloc(), SortState::shared_info, and size.

Referenced by ExecParallelRetrieveInstrumentation().