Skip to content

Commit 2762792

Browse files
tglsfdctglsfdc
committed
Convert SetOp to read its inputs as outerPlan and innerPlan.
The original design for set operations involved appending the two input relations into one and adding a flag column that allows distinguishing which side each row came from. Then the SetOp node pries them apart again based on the flag. This is bizarre. The only apparent reason to do it is that when sorting, we'd only need one Sort node not two. But since sorting is at least O(N log N), sorting all the data is actually worse than sorting each side separately --- plus, we have no chance of taking advantage of presorted input. On top of that, adding the flag column frequently requires an additional projection step that adds cycles, and then the Append node isn't free either. Let's get rid of all of that and make the SetOp node have two separate children, using the existing outerPlan/innerPlan infrastructure. This initial patch re-implements nodeSetop.c and does a bare minimum of work on the planner side to generate correctly-shaped plans. In particular, I've tried not to change the cost estimates here, so that the visible changes in the regression test results will only involve removal of useless projection steps and not any changes in whether to use sorted vs hashed mode. For SORTED mode, we combine successive identical tuples from each input into groups, and then merge-join the groups. The tuple comparisons now use SortSupport instead of simple equality, but the group-formation part should involve roughly the same number of tuple comparisons as before. The cross-comparisons between left and right groups probably add to that, but I'm not sure to quantify how many more comparisons we might need. For HASHED mode, nodeSetop's logic is almost the same as before, just refactored into two separate loops instead of one loop that has an assumption that it will see all the left-hand inputs first. In both modes, I added early-exit logic to not bother reading the right-hand relation if the left-hand input is empty, since neither INTERSECT nor EXCEPT modes can produce any output if the left input is empty. This could have been done before in the hashed mode, but not in sorted mode. Sorted mode can also stop as soon as it exhausts the left input; any remaining right-hand tuples cannot have matches. Also, this patch adds some infrastructure for detecting whether child plan nodes all output the same type of tuple table slot. If they do, the hash table logic can use slightly more efficient code based on assuming that that's the input slot type it will see. We'll make use of that infrastructure in other plan node types later. Patch by me; thanks to Richard Guo and David Rowley for review. Discussion: https://postgr.es/m/1850138.1731549611@sss.pgh.pa.us
1 parent 2128ceb commit 2762792

File tree

15 files changed

+696
-524
lines changed

15 files changed

+696
-524
lines changed

‎src/backend/executor/execUtils.c

+43
Original file line numberDiff line numberDiff line change
@@ -526,6 +526,49 @@ ExecGetResultSlotOps(PlanState *planstate, bool *isfixed)
526526
return planstate->ps_ResultTupleSlot->tts_ops;
527527
}
528528

529+
/*
530+
* ExecGetCommonSlotOps - identify common result slot type, if any
531+
*
532+
* If all the given PlanState nodes return the same fixed tuple slot type,
533+
* return the slot ops struct for that slot type. Else, return NULL.
534+
*/
535+
const TupleTableSlotOps *
536+
ExecGetCommonSlotOps(PlanState **planstates, int nplans)
537+
{
538+
const TupleTableSlotOps *result;
539+
bool isfixed;
540+
541+
if (nplans <= 0)
542+
return NULL;
543+
result = ExecGetResultSlotOps(planstates[0], &isfixed);
544+
if (!isfixed)
545+
return NULL;
546+
for (int i = 1; i < nplans; i++)
547+
{
548+
const TupleTableSlotOps *thisops;
549+
550+
thisops = ExecGetResultSlotOps(planstates[i], &isfixed);
551+
if (!isfixed)
552+
return NULL;
553+
if (result != thisops)
554+
return NULL;
555+
}
556+
return result;
557+
}
558+
559+
/*
560+
* ExecGetCommonChildSlotOps - as above, for the PlanState's standard children
561+
*/
562+
const TupleTableSlotOps *
563+
ExecGetCommonChildSlotOps(PlanState *ps)
564+
{
565+
PlanState *planstates[2];
566+
567+
planstates[0] = outerPlanState(ps);
568+
planstates[1] = innerPlanState(ps);
569+
return ExecGetCommonSlotOps(planstates, 2);
570+
}
571+
529572

530573
/* ----------------
531574
* ExecAssignProjectionInfo

0 commit comments

Comments
 (0)