mirror of
https://git.postgresql.org/git/postgresql.git
synced 2024-09-08 21:59:26 +02:00
This replaces the old, recursive tree-walk based evaluation, with non-recursive, opcode dispatch based, expression evaluation. Projection is now implemented as part of expression evaluation. This both leads to significant performance improvements, and makes future just-in-time compilation of expressions easier. The speed gains primarily come from: - non-recursive implementation reduces stack usage / overhead - simple sub-expressions are implemented with a single jump, without function calls - sharing some state between different sub-expressions - reduced amount of indirect/hard to predict memory accesses by laying out operation metadata sequentially; including the avoidance of nearly all of the previously used linked lists - more code has been moved to expression initialization, avoiding constant re-checks at evaluation time Future just-in-time compilation (JIT) has become easier, as demonstrated by released patches intended to be merged in a later release, for primarily two reasons: Firstly, due to a stricter split between expression initialization and evaluation, less code has to be handled by the JIT. Secondly, due to the non-recursive nature of the generated "instructions", less performance-critical code-paths can easily be shared between interpreted and compiled evaluation. The new framework allows for significant future optimizations. E.g.: - basic infrastructure for to later reduce the per executor-startup overhead of expression evaluation, by caching state in prepared statements. That'd be helpful in OLTPish scenarios where initialization overhead is measurable. - optimizing the generated "code". A number of proposals for potential work has already been made. - optimizing the interpreter. Similarly a number of proposals have been made here too. The move of logic into the expression initialization step leads to some backward-incompatible changes: - Function permission checks are now done during expression initialization, whereas previously they were done during execution. In edge cases this can lead to errors being raised that previously wouldn't have been, e.g. a NULL array being coerced to a different array type previously didn't perform checks. - The set of domain constraints to be checked, is now evaluated once during expression initialization, previously it was re-built every time a domain check was evaluated. For normal queries this doesn't change much, but e.g. for plpgsql functions, which caches ExprStates, the old set could stick around longer. The behavior around might still change. Author: Andres Freund, with significant changes by Tom Lane, changes by Heikki Linnakangas Reviewed-By: Tom Lane, Heikki Linnakangas Discussion: https://postgr.es/m/20161206034955.bh33paeralxbtluv@alap3.anarazel.de
255 lines
5.9 KiB
C
255 lines
5.9 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* nodeGroup.c
|
|
* Routines to handle group nodes (used for queries with GROUP BY clause).
|
|
*
|
|
* Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
*
|
|
*
|
|
* DESCRIPTION
|
|
* The Group node is designed for handling queries with a GROUP BY clause.
|
|
* Its outer plan must deliver tuples that are sorted in the order
|
|
* specified by the grouping columns (ie. tuples from the same group are
|
|
* consecutive). That way, we just have to compare adjacent tuples to
|
|
* locate group boundaries.
|
|
*
|
|
* IDENTIFICATION
|
|
* src/backend/executor/nodeGroup.c
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "postgres.h"
|
|
|
|
#include "executor/executor.h"
|
|
#include "executor/nodeGroup.h"
|
|
|
|
|
|
/*
|
|
* ExecGroup -
|
|
*
|
|
* Return one tuple for each group of matching input tuples.
|
|
*/
|
|
TupleTableSlot *
|
|
ExecGroup(GroupState *node)
|
|
{
|
|
ExprContext *econtext;
|
|
int numCols;
|
|
AttrNumber *grpColIdx;
|
|
TupleTableSlot *firsttupleslot;
|
|
TupleTableSlot *outerslot;
|
|
|
|
/*
|
|
* get state info from node
|
|
*/
|
|
if (node->grp_done)
|
|
return NULL;
|
|
econtext = node->ss.ps.ps_ExprContext;
|
|
numCols = ((Group *) node->ss.ps.plan)->numCols;
|
|
grpColIdx = ((Group *) node->ss.ps.plan)->grpColIdx;
|
|
|
|
/*
|
|
* The ScanTupleSlot holds the (copied) first tuple of each group.
|
|
*/
|
|
firsttupleslot = node->ss.ss_ScanTupleSlot;
|
|
|
|
/*
|
|
* We need not call ResetExprContext here because execTuplesMatch will
|
|
* reset the per-tuple memory context once per input tuple.
|
|
*/
|
|
|
|
/*
|
|
* If first time through, acquire first input tuple and determine whether
|
|
* to return it or not.
|
|
*/
|
|
if (TupIsNull(firsttupleslot))
|
|
{
|
|
outerslot = ExecProcNode(outerPlanState(node));
|
|
if (TupIsNull(outerslot))
|
|
{
|
|
/* empty input, so return nothing */
|
|
node->grp_done = TRUE;
|
|
return NULL;
|
|
}
|
|
/* Copy tuple into firsttupleslot */
|
|
ExecCopySlot(firsttupleslot, outerslot);
|
|
|
|
/*
|
|
* Set it up as input for qual test and projection. The expressions
|
|
* will access the input tuple as varno OUTER.
|
|
*/
|
|
econtext->ecxt_outertuple = firsttupleslot;
|
|
|
|
/*
|
|
* Check the qual (HAVING clause); if the group does not match, ignore
|
|
* it and fall into scan loop.
|
|
*/
|
|
if (ExecQual(node->ss.ps.qual, econtext))
|
|
{
|
|
/*
|
|
* Form and return a projection tuple using the first input tuple.
|
|
*/
|
|
return ExecProject(node->ss.ps.ps_ProjInfo);
|
|
}
|
|
else
|
|
InstrCountFiltered1(node, 1);
|
|
}
|
|
|
|
/*
|
|
* This loop iterates once per input tuple group. At the head of the
|
|
* loop, we have finished processing the first tuple of the group and now
|
|
* need to scan over all the other group members.
|
|
*/
|
|
for (;;)
|
|
{
|
|
/*
|
|
* Scan over all remaining tuples that belong to this group
|
|
*/
|
|
for (;;)
|
|
{
|
|
outerslot = ExecProcNode(outerPlanState(node));
|
|
if (TupIsNull(outerslot))
|
|
{
|
|
/* no more groups, so we're done */
|
|
node->grp_done = TRUE;
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Compare with first tuple and see if this tuple is of the same
|
|
* group. If so, ignore it and keep scanning.
|
|
*/
|
|
if (!execTuplesMatch(firsttupleslot, outerslot,
|
|
numCols, grpColIdx,
|
|
node->eqfunctions,
|
|
econtext->ecxt_per_tuple_memory))
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* We have the first tuple of the next input group. See if we want to
|
|
* return it.
|
|
*/
|
|
/* Copy tuple, set up as input for qual test and projection */
|
|
ExecCopySlot(firsttupleslot, outerslot);
|
|
econtext->ecxt_outertuple = firsttupleslot;
|
|
|
|
/*
|
|
* Check the qual (HAVING clause); if the group does not match, ignore
|
|
* it and loop back to scan the rest of the group.
|
|
*/
|
|
if (ExecQual(node->ss.ps.qual, econtext))
|
|
{
|
|
/*
|
|
* Form and return a projection tuple using the first input tuple.
|
|
*/
|
|
return ExecProject(node->ss.ps.ps_ProjInfo);
|
|
}
|
|
else
|
|
InstrCountFiltered1(node, 1);
|
|
}
|
|
}
|
|
|
|
/* -----------------
|
|
* ExecInitGroup
|
|
*
|
|
* Creates the run-time information for the group node produced by the
|
|
* planner and initializes its outer subtree
|
|
* -----------------
|
|
*/
|
|
GroupState *
|
|
ExecInitGroup(Group *node, EState *estate, int eflags)
|
|
{
|
|
GroupState *grpstate;
|
|
|
|
/* check for unsupported flags */
|
|
Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
|
|
|
|
/*
|
|
* create state structure
|
|
*/
|
|
grpstate = makeNode(GroupState);
|
|
grpstate->ss.ps.plan = (Plan *) node;
|
|
grpstate->ss.ps.state = estate;
|
|
grpstate->grp_done = FALSE;
|
|
|
|
/*
|
|
* create expression context
|
|
*/
|
|
ExecAssignExprContext(estate, &grpstate->ss.ps);
|
|
|
|
/*
|
|
* tuple table initialization
|
|
*/
|
|
ExecInitScanTupleSlot(estate, &grpstate->ss);
|
|
ExecInitResultTupleSlot(estate, &grpstate->ss.ps);
|
|
|
|
/*
|
|
* initialize child expressions
|
|
*/
|
|
grpstate->ss.ps.qual =
|
|
ExecInitQual(node->plan.qual, (PlanState *) grpstate);
|
|
|
|
/*
|
|
* initialize child nodes
|
|
*/
|
|
outerPlanState(grpstate) = ExecInitNode(outerPlan(node), estate, eflags);
|
|
|
|
/*
|
|
* initialize tuple type.
|
|
*/
|
|
ExecAssignScanTypeFromOuterPlan(&grpstate->ss);
|
|
|
|
/*
|
|
* Initialize result tuple type and projection info.
|
|
*/
|
|
ExecAssignResultTypeFromTL(&grpstate->ss.ps);
|
|
ExecAssignProjectionInfo(&grpstate->ss.ps, NULL);
|
|
|
|
/*
|
|
* Precompute fmgr lookup data for inner loop
|
|
*/
|
|
grpstate->eqfunctions =
|
|
execTuplesMatchPrepare(node->numCols,
|
|
node->grpOperators);
|
|
|
|
return grpstate;
|
|
}
|
|
|
|
/* ------------------------
|
|
* ExecEndGroup(node)
|
|
*
|
|
* -----------------------
|
|
*/
|
|
void
|
|
ExecEndGroup(GroupState *node)
|
|
{
|
|
PlanState *outerPlan;
|
|
|
|
ExecFreeExprContext(&node->ss.ps);
|
|
|
|
/* clean up tuple table */
|
|
ExecClearTuple(node->ss.ss_ScanTupleSlot);
|
|
|
|
outerPlan = outerPlanState(node);
|
|
ExecEndNode(outerPlan);
|
|
}
|
|
|
|
void
|
|
ExecReScanGroup(GroupState *node)
|
|
{
|
|
PlanState *outerPlan = outerPlanState(node);
|
|
|
|
node->grp_done = FALSE;
|
|
/* must clear first tuple */
|
|
ExecClearTuple(node->ss.ss_ScanTupleSlot);
|
|
|
|
/*
|
|
* if chgParam of subnode is not null then plan will be re-scanned by
|
|
* first ExecProcNode.
|
|
*/
|
|
if (outerPlan->chgParam == NULL)
|
|
ExecReScan(outerPlan);
|
|
}
|