1996-07-09 08:22:35 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
1999-02-14 00:22:53 +01:00
|
|
|
* nodeSort.c
|
1997-09-07 07:04:48 +02:00
|
|
|
* Routines to handle sorting of relations.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2018-01-03 05:30:12 +01:00
|
|
|
* Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
|
2000-01-26 06:58:53 +01:00
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
2010-09-20 22:08:53 +02:00
|
|
|
* src/backend/executor/nodeSort.c
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
1996-10-31 11:12:26 +01:00
|
|
|
|
1999-07-16 07:00:38 +02:00
|
|
|
#include "postgres.h"
|
1999-10-18 00:15:09 +02:00
|
|
|
|
2017-08-29 19:22:49 +02:00
|
|
|
#include "access/parallel.h"
|
1996-11-08 07:02:30 +01:00
|
|
|
#include "executor/execdebug.h"
|
1996-07-09 08:22:35 +02:00
|
|
|
#include "executor/nodeSort.h"
|
2004-02-03 18:34:04 +01:00
|
|
|
#include "miscadmin.h"
|
1999-10-18 00:15:09 +02:00
|
|
|
#include "utils/tuplesort.h"
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
1997-09-07 07:04:48 +02:00
|
|
|
* ExecSort
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1999-10-18 00:15:09 +02:00
|
|
|
* Sorts tuples from the outer subtree of the node using tuplesort,
|
1997-09-07 07:04:48 +02:00
|
|
|
* which saves the results in a temporary file or memory. After the
|
|
|
|
* initial call, returns a tuple from the file with each call.
|
|
|
|
*
|
|
|
|
* Conditions:
|
|
|
|
* -- none.
|
|
|
|
*
|
|
|
|
* Initial States:
|
|
|
|
* -- the outer child is prepared to return the first tuple.
|
1996-07-09 08:22:35 +02:00
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
2017-07-17 09:33:49 +02:00
|
|
|
static TupleTableSlot *
|
|
|
|
ExecSort(PlanState *pstate)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2017-07-17 09:33:49 +02:00
|
|
|
SortState *node = castNode(SortState, pstate);
|
1997-09-08 04:41:22 +02:00
|
|
|
EState *estate;
|
|
|
|
ScanDirection dir;
|
1999-10-18 00:15:09 +02:00
|
|
|
Tuplesortstate *tuplesortstate;
|
1997-09-07 07:04:48 +02:00
|
|
|
TupleTableSlot *slot;
|
|
|
|
|
2017-07-26 02:37:17 +02:00
|
|
|
CHECK_FOR_INTERRUPTS();
|
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* get state info from node
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
SO1_printf("ExecSort: %s\n",
|
|
|
|
"entering routine");
|
|
|
|
|
2002-12-05 16:50:39 +01:00
|
|
|
estate = node->ss.ps.state;
|
1997-09-07 07:04:48 +02:00
|
|
|
dir = estate->es_direction;
|
2002-12-05 16:50:39 +01:00
|
|
|
tuplesortstate = (Tuplesortstate *) node->tuplesortstate;
|
1997-08-06 05:42:21 +02:00
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* If first time through, read all tuples from outer plan and pass them to
|
|
|
|
* tuplesort.c. Subsequent calls just fetch tuples from tuplesort.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-08-06 05:42:21 +02:00
|
|
|
|
2002-12-05 16:50:39 +01:00
|
|
|
if (!node->sort_Done)
|
1997-08-06 05:42:21 +02:00
|
|
|
{
|
2002-12-05 16:50:39 +01:00
|
|
|
Sort *plannode = (Sort *) node->ss.ps.plan;
|
|
|
|
PlanState *outerNode;
|
1999-10-18 00:15:09 +02:00
|
|
|
TupleDesc tupDesc;
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
SO1_printf("ExecSort: %s\n",
|
1999-10-18 00:15:09 +02:00
|
|
|
"sorting subplan");
|
2001-03-22 07:16:21 +01:00
|
|
|
|
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* Want to scan subplan in the forward direction while creating the
|
|
|
|
* sorted data.
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
|
|
|
estate->es_direction = ForwardScanDirection;
|
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* Initialize tuplesort module.
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
1999-10-18 00:15:09 +02:00
|
|
|
SO1_printf("ExecSort: %s\n",
|
|
|
|
"calling tuplesort_begin");
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2002-12-05 16:50:39 +01:00
|
|
|
outerNode = outerPlanState(node);
|
2003-05-05 19:57:47 +02:00
|
|
|
tupDesc = ExecGetResultType(outerNode);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2003-05-06 02:20:33 +02:00
|
|
|
tuplesortstate = tuplesort_begin_heap(tupDesc,
|
|
|
|
plannode->numCols,
|
|
|
|
plannode->sortColIdx,
|
2007-01-09 03:14:16 +01:00
|
|
|
plannode->sortOperators,
|
2011-02-08 22:04:18 +01:00
|
|
|
plannode->collations,
|
2007-01-09 03:14:16 +01:00
|
|
|
plannode->nullsFirst,
|
2004-02-03 18:34:04 +01:00
|
|
|
work_mem,
|
Support parallel btree index builds.
To make this work, tuplesort.c and logtape.c must also support
parallelism, so this patch adds that infrastructure and then applies
it to the particular case of parallel btree index builds. Testing
to date shows that this can often be 2-3x faster than a serial
index build.
The model for deciding how many workers to use is fairly primitive
at present, but it's better than not having the feature. We can
refine it as we get more experience.
Peter Geoghegan with some help from Rushabh Lathia. While Heikki
Linnakangas is not an author of this patch, he wrote other patches
without which this feature would not have been possible, and
therefore the release notes should possibly credit him as an author
of this feature. Reviewed by Claudio Freire, Heikki Linnakangas,
Thomas Munro, Tels, Amit Kapila, me.
Discussion: http://postgr.es/m/CAM3SWZQKM=Pzc=CAHzRixKjp2eO5Q0Jg1SoFQqeXFQ647JiwqQ@mail.gmail.com
Discussion: http://postgr.es/m/CAH2-Wz=AxWqDoVvGU7dq856S4r6sJAj6DBn7VMtigkB33N5eyg@mail.gmail.com
2018-02-02 19:25:55 +01:00
|
|
|
NULL, node->randomAccess);
|
2007-05-04 03:13:45 +02:00
|
|
|
if (node->bounded)
|
|
|
|
tuplesort_set_bound(tuplesortstate, node->bound);
|
2002-12-05 16:50:39 +01:00
|
|
|
node->tuplesortstate = (void *) tuplesortstate;
|
1999-10-18 00:15:09 +02:00
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* Scan the subplan and feed all the tuples to tuplesort.
|
1999-10-18 00:15:09 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
for (;;)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
2002-12-05 16:50:39 +01:00
|
|
|
slot = ExecProcNode(outerNode);
|
1999-10-18 00:15:09 +02:00
|
|
|
|
|
|
|
if (TupIsNull(slot))
|
|
|
|
break;
|
|
|
|
|
2006-06-27 18:53:02 +02:00
|
|
|
tuplesort_puttupleslot(tuplesortstate, slot);
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* Complete the sort.
|
1999-10-18 00:15:09 +02:00
|
|
|
*/
|
|
|
|
tuplesort_performsort(tuplesortstate);
|
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* restore to user specified direction
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
|
|
|
estate->es_direction = dir;
|
1997-08-06 05:42:21 +02:00
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* finally set the sorted flag to true
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
2002-12-05 16:50:39 +01:00
|
|
|
node->sort_Done = true;
|
2007-05-04 03:13:45 +02:00
|
|
|
node->bounded_Done = node->bounded;
|
|
|
|
node->bound_Done = node->bound;
|
2017-08-29 19:22:49 +02:00
|
|
|
if (node->shared_info && node->am_worker)
|
|
|
|
{
|
|
|
|
TuplesortInstrumentation *si;
|
|
|
|
|
|
|
|
Assert(IsParallelWorker());
|
|
|
|
Assert(ParallelWorkerNumber <= node->shared_info->num_workers);
|
|
|
|
si = &node->shared_info->sinstrument[ParallelWorkerNumber];
|
|
|
|
tuplesort_get_stats(tuplesortstate, si);
|
|
|
|
}
|
2002-11-02 16:54:13 +01:00
|
|
|
SO1_printf("ExecSort: %s\n", "sorting done");
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
SO1_printf("ExecSort: %s\n",
|
1999-10-18 00:15:09 +02:00
|
|
|
"retrieving tuple from tuplesort");
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* Get the first or next tuple from tuplesort. Returns NULL if no more
|
2017-04-06 23:48:59 +02:00
|
|
|
* tuples. Note that we only rely on slot tuple remaining valid until the
|
|
|
|
* next fetch from the tuplesort.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
2002-12-05 16:50:39 +01:00
|
|
|
slot = node->ss.ps.ps_ResultTupleSlot;
|
2006-06-27 18:53:02 +02:00
|
|
|
(void) tuplesort_gettupleslot(tuplesortstate,
|
|
|
|
ScanDirectionIsForward(dir),
|
2017-04-06 23:48:59 +02:00
|
|
|
false, slot, NULL);
|
2006-06-27 18:53:02 +02:00
|
|
|
return slot;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
1997-09-07 07:04:48 +02:00
|
|
|
* ExecInitSort
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* Creates the run-time state information for the sort node
|
2006-02-28 05:10:28 +01:00
|
|
|
* produced by the planner and initializes its outer subtree.
|
1996-07-09 08:22:35 +02:00
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
2002-12-05 16:50:39 +01:00
|
|
|
SortState *
|
2006-02-28 05:10:28 +01:00
|
|
|
ExecInitSort(Sort *node, EState *estate, int eflags)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
SortState *sortstate;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
SO1_printf("ExecInitSort: %s\n",
|
|
|
|
"initializing sort node");
|
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* create state structure
|
|
|
|
*/
|
|
|
|
sortstate = makeNode(SortState);
|
2002-12-05 16:50:39 +01:00
|
|
|
sortstate->ss.ps.plan = (Plan *) node;
|
|
|
|
sortstate->ss.ps.state = estate;
|
2017-07-17 09:33:49 +02:00
|
|
|
sortstate->ss.ps.ExecProcNode = ExecSort;
|
2002-12-05 16:50:39 +01:00
|
|
|
|
2006-02-28 06:48:44 +01:00
|
|
|
/*
|
2006-10-04 02:30:14 +02:00
|
|
|
* We must have random access to the sort output to do backward scan or
|
|
|
|
* mark/restore. We also prefer to materialize the sort output if we
|
|
|
|
* might be called on to rewind and replay it many times.
|
2006-02-28 06:48:44 +01:00
|
|
|
*/
|
|
|
|
sortstate->randomAccess = (eflags & (EXEC_FLAG_REWIND |
|
|
|
|
EXEC_FLAG_BACKWARD |
|
|
|
|
EXEC_FLAG_MARK)) != 0;
|
|
|
|
|
2007-05-04 03:13:45 +02:00
|
|
|
sortstate->bounded = false;
|
1999-10-18 00:15:09 +02:00
|
|
|
sortstate->sort_Done = false;
|
|
|
|
sortstate->tuplesortstate = NULL;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* Miscellaneous initialization
|
1997-09-07 07:04:48 +02:00
|
|
|
*
|
2001-03-22 07:16:21 +01:00
|
|
|
* Sort nodes don't initialize their ExprContexts because they never call
|
|
|
|
* ExecQual or ExecProject.
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
2006-02-28 05:10:28 +01:00
|
|
|
* initialize child nodes
|
|
|
|
*
|
2006-10-04 02:30:14 +02:00
|
|
|
* We shield the child node from the need to support REWIND, BACKWARD, or
|
|
|
|
* MARK/RESTORE.
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
2006-02-28 05:10:28 +01:00
|
|
|
eflags &= ~(EXEC_FLAG_REWIND | EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK);
|
|
|
|
|
|
|
|
outerPlanState(sortstate) = ExecInitNode(outerPlan(node), estate, eflags);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
2018-02-17 06:17:38 +01:00
|
|
|
* Initialize scan slot and type.
|
|
|
|
*/
|
|
|
|
ExecCreateScanSlotFromOuterPlan(estate, &sortstate->ss);
|
|
|
|
|
|
|
|
/*
|
2018-04-26 20:47:16 +02:00
|
|
|
* Initialize return slot and type. No need to initialize projection info
|
|
|
|
* because this node doesn't do projections.
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
2018-02-17 06:17:38 +01:00
|
|
|
ExecInitResultTupleSlotTL(estate, &sortstate->ss.ps);
|
2002-12-05 16:50:39 +01:00
|
|
|
sortstate->ss.ps.ps_ProjInfo = NULL;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
SO1_printf("ExecInitSort: %s\n",
|
|
|
|
"sort node initialized");
|
|
|
|
|
2002-12-05 16:50:39 +01:00
|
|
|
return sortstate;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
1997-09-07 07:04:48 +02:00
|
|
|
* ExecEndSort(node)
|
1996-07-09 08:22:35 +02:00
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
void
|
2002-12-05 16:50:39 +01:00
|
|
|
ExecEndSort(SortState *node)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
SO1_printf("ExecEndSort: %s\n",
|
|
|
|
"shutting down sort node");
|
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
2002-12-05 16:50:39 +01:00
|
|
|
* clean out the tuple table
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
2002-12-05 16:50:39 +01:00
|
|
|
ExecClearTuple(node->ss.ss_ScanTupleSlot);
|
2006-02-26 23:58:12 +01:00
|
|
|
/* must drop pointer to sort result tuple */
|
|
|
|
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* Release tuplesort resources
|
1999-10-18 00:15:09 +02:00
|
|
|
*/
|
2002-12-05 16:50:39 +01:00
|
|
|
if (node->tuplesortstate != NULL)
|
|
|
|
tuplesort_end((Tuplesortstate *) node->tuplesortstate);
|
|
|
|
node->tuplesortstate = NULL;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2002-12-15 17:17:59 +01:00
|
|
|
/*
|
|
|
|
* shut down the subplan
|
|
|
|
*/
|
|
|
|
ExecEndNode(outerPlanState(node));
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
SO1_printf("ExecEndSort: %s\n",
|
|
|
|
"sort node shutdown");
|
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
1997-09-07 07:04:48 +02:00
|
|
|
* ExecSortMarkPos
|
1997-08-06 05:42:21 +02:00
|
|
|
*
|
1999-10-18 00:15:09 +02:00
|
|
|
* Calls tuplesort to save the current position in the sorted file.
|
1996-07-09 08:22:35 +02:00
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
void
|
2002-12-05 16:50:39 +01:00
|
|
|
ExecSortMarkPos(SortState *node)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* if we haven't sorted yet, just return
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
2002-12-05 16:50:39 +01:00
|
|
|
if (!node->sort_Done)
|
1997-09-07 07:04:48 +02:00
|
|
|
return;
|
|
|
|
|
2002-12-05 16:50:39 +01:00
|
|
|
tuplesort_markpos((Tuplesortstate *) node->tuplesortstate);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
1997-09-07 07:04:48 +02:00
|
|
|
* ExecSortRestrPos
|
1997-08-06 05:42:21 +02:00
|
|
|
*
|
1999-10-18 00:15:09 +02:00
|
|
|
* Calls tuplesort to restore the last saved sort file position.
|
1996-07-09 08:22:35 +02:00
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
void
|
2002-12-05 16:50:39 +01:00
|
|
|
ExecSortRestrPos(SortState *node)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* if we haven't sorted yet, just return.
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
2002-12-05 16:50:39 +01:00
|
|
|
if (!node->sort_Done)
|
1997-09-07 07:04:48 +02:00
|
|
|
return;
|
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* restore the scan to the previously marked position
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
2002-12-05 16:50:39 +01:00
|
|
|
tuplesort_restorepos((Tuplesortstate *) node->tuplesortstate);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1998-02-23 07:28:16 +01:00
|
|
|
|
|
|
|
void
|
2010-07-12 19:01:06 +02:00
|
|
|
ExecReScanSort(SortState *node)
|
1998-02-23 07:28:16 +01:00
|
|
|
{
|
2015-05-24 03:35:49 +02:00
|
|
|
PlanState *outerPlan = outerPlanState(node);
|
2015-05-04 22:13:07 +02:00
|
|
|
|
1998-02-23 07:28:16 +01:00
|
|
|
/*
|
2010-07-12 19:01:06 +02:00
|
|
|
* If we haven't sorted yet, just return. If outerplan's chgParam is not
|
|
|
|
* NULL then it will be re-scanned by ExecProcNode, else no reason to
|
2005-10-15 04:49:52 +02:00
|
|
|
* re-scan it at all.
|
1998-02-23 07:28:16 +01:00
|
|
|
*/
|
2002-12-05 16:50:39 +01:00
|
|
|
if (!node->sort_Done)
|
1998-02-23 07:28:16 +01:00
|
|
|
return;
|
1998-02-26 05:46:47 +01:00
|
|
|
|
2006-02-26 23:58:12 +01:00
|
|
|
/* must drop pointer to sort result tuple */
|
2002-12-05 16:50:39 +01:00
|
|
|
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
|
1998-02-26 05:46:47 +01:00
|
|
|
|
1998-02-23 07:28:16 +01:00
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* If subnode is to be rescanned then we forget previous sort results; we
|
2007-05-04 03:13:45 +02:00
|
|
|
* have to re-read the subplan and re-sort. Also must re-sort if the
|
|
|
|
* bounded-sort parameters changed or we didn't select randomAccess.
|
1999-10-18 00:15:09 +02:00
|
|
|
*
|
|
|
|
* Otherwise we can just rewind and rescan the sorted output.
|
1998-02-23 07:28:16 +01:00
|
|
|
*/
|
2015-05-04 22:13:07 +02:00
|
|
|
if (outerPlan->chgParam != NULL ||
|
2007-05-04 03:13:45 +02:00
|
|
|
node->bounded != node->bounded_Done ||
|
|
|
|
node->bound != node->bound_Done ||
|
2006-02-28 06:48:44 +01:00
|
|
|
!node->randomAccess)
|
1999-10-18 00:15:09 +02:00
|
|
|
{
|
2002-12-05 16:50:39 +01:00
|
|
|
node->sort_Done = false;
|
|
|
|
tuplesort_end((Tuplesortstate *) node->tuplesortstate);
|
|
|
|
node->tuplesortstate = NULL;
|
2006-10-04 02:30:14 +02:00
|
|
|
|
2006-02-28 06:48:44 +01:00
|
|
|
/*
|
|
|
|
* if chgParam of subnode is not null then plan will be re-scanned by
|
|
|
|
* first ExecProcNode.
|
|
|
|
*/
|
2015-05-04 22:13:07 +02:00
|
|
|
if (outerPlan->chgParam == NULL)
|
|
|
|
ExecReScan(outerPlan);
|
1999-10-18 00:15:09 +02:00
|
|
|
}
|
|
|
|
else
|
2002-12-05 16:50:39 +01:00
|
|
|
tuplesort_rescan((Tuplesortstate *) node->tuplesortstate);
|
1998-02-23 07:28:16 +01:00
|
|
|
}
|
2017-08-29 19:22:49 +02:00
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
|
|
|
* Parallel Query Support
|
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
|
|
|
* ExecSortEstimate
|
|
|
|
*
|
|
|
|
* Estimate space required to propagate sort statistics.
|
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ExecSortEstimate(SortState *node, ParallelContext *pcxt)
|
|
|
|
{
|
|
|
|
Size size;
|
|
|
|
|
|
|
|
/* don't need this if not instrumenting or no workers */
|
|
|
|
if (!node->ss.ps.instrument || pcxt->nworkers == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
size = mul_size(pcxt->nworkers, sizeof(TuplesortInstrumentation));
|
|
|
|
size = add_size(size, offsetof(SharedSortInfo, sinstrument));
|
|
|
|
shm_toc_estimate_chunk(&pcxt->estimator, size);
|
|
|
|
shm_toc_estimate_keys(&pcxt->estimator, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
|
|
|
* ExecSortInitializeDSM
|
|
|
|
*
|
|
|
|
* Initialize DSM space for sort statistics.
|
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ExecSortInitializeDSM(SortState *node, ParallelContext *pcxt)
|
|
|
|
{
|
|
|
|
Size size;
|
|
|
|
|
|
|
|
/* don't need this if not instrumenting or no workers */
|
|
|
|
if (!node->ss.ps.instrument || pcxt->nworkers == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
size = offsetof(SharedSortInfo, sinstrument)
|
|
|
|
+ pcxt->nworkers * sizeof(TuplesortInstrumentation);
|
|
|
|
node->shared_info = shm_toc_allocate(pcxt->toc, size);
|
|
|
|
/* ensure any unfilled slots will contain zeroes */
|
|
|
|
memset(node->shared_info, 0, size);
|
|
|
|
node->shared_info->num_workers = pcxt->nworkers;
|
|
|
|
shm_toc_insert(pcxt->toc, node->ss.ps.plan->plan_node_id,
|
|
|
|
node->shared_info);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
|
|
|
* ExecSortInitializeWorker
|
|
|
|
*
|
|
|
|
* Attach worker to DSM space for sort statistics.
|
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
void
|
2017-11-17 02:28:11 +01:00
|
|
|
ExecSortInitializeWorker(SortState *node, ParallelWorkerContext *pwcxt)
|
2017-08-29 19:22:49 +02:00
|
|
|
{
|
|
|
|
node->shared_info =
|
2017-11-17 02:28:11 +01:00
|
|
|
shm_toc_lookup(pwcxt->toc, node->ss.ps.plan->plan_node_id, true);
|
2017-08-29 19:22:49 +02:00
|
|
|
node->am_worker = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
|
|
|
* ExecSortRetrieveInstrumentation
|
|
|
|
*
|
|
|
|
* Transfer sort statistics from DSM to private memory.
|
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ExecSortRetrieveInstrumentation(SortState *node)
|
|
|
|
{
|
|
|
|
Size size;
|
|
|
|
SharedSortInfo *si;
|
|
|
|
|
|
|
|
if (node->shared_info == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
size = offsetof(SharedSortInfo, sinstrument)
|
|
|
|
+ node->shared_info->num_workers * sizeof(TuplesortInstrumentation);
|
|
|
|
si = palloc(size);
|
|
|
|
memcpy(si, node->shared_info, size);
|
|
|
|
node->shared_info = si;
|
|
|
|
}
|