pgpa_join.h File Reference

#include "nodes/plannodes.h"

Include dependency graph for pgpa_join.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	pgpa_join_member
struct	pgpa_unrolled_join

Macros
#define	NUM_PGPA_JOIN_STRATEGY   ((int) JSTRAT_HASH_JOIN + 1)

Typedefs
typedef struct pgpa_plan_walker_context	pgpa_plan_walker_context
typedef struct pgpa_join_unroller	pgpa_join_unroller
typedef struct pgpa_unrolled_join	pgpa_unrolled_join

Enumerations
enum	pgpa_join_strategy {   JSTRAT_MERGE_JOIN_PLAIN = 0 , JSTRAT_MERGE_JOIN_MATERIALIZE , JSTRAT_NESTED_LOOP_PLAIN , JSTRAT_NESTED_LOOP_MATERIALIZE ,   JSTRAT_NESTED_LOOP_MEMOIZE , JSTRAT_HASH_JOIN }

Functions
static bool	pgpa_is_join (Plan *plan)
pgpa_join_unroller *	pgpa_create_join_unroller (void)
void	pgpa_unroll_join (pgpa_plan_walker_context *walker, Plan *plan, bool beneath_any_gather, pgpa_join_unroller *join_unroller, pgpa_join_unroller **outer_join_unroller, pgpa_join_unroller **inner_join_unroller)
pgpa_unrolled_join *	pgpa_build_unrolled_join (pgpa_plan_walker_context *walker, pgpa_join_unroller *join_unroller)
void	pgpa_destroy_join_unroller (pgpa_join_unroller *join_unroller)

Macro Definition Documentation

NUM_PGPA_JOIN_STRATEGY

#define NUM_PGPA_JOIN_STRATEGY   ((int) JSTRAT_HASH_JOIN + 1)

Definition at line 38 of file pgpa_join.h.

Typedef Documentation

pgpa_join_unroller

typedef struct pgpa_join_unroller pgpa_join_unroller

Definition at line 18 of file pgpa_join.h.

pgpa_plan_walker_context

typedef struct pgpa_plan_walker_context pgpa_plan_walker_context

Definition at line 17 of file pgpa_join.h.

pgpa_unrolled_join

typedef struct pgpa_unrolled_join pgpa_unrolled_join

Definition at line 19 of file pgpa_join.h.

Enumeration Type Documentation

pgpa_join_strategy

enum pgpa_join_strategy

Enumerator
JSTRAT_MERGE_JOIN_PLAIN
JSTRAT_MERGE_JOIN_MATERIALIZE
JSTRAT_NESTED_LOOP_PLAIN
JSTRAT_NESTED_LOOP_MATERIALIZE
JSTRAT_NESTED_LOOP_MEMOIZE
JSTRAT_HASH_JOIN

Definition at line 27 of file pgpa_join.h.

{
    JSTRAT_MERGE_JOIN_PLAIN = 0,
    JSTRAT_MERGE_JOIN_MATERIALIZE,
    JSTRAT_NESTED_LOOP_PLAIN,
    JSTRAT_NESTED_LOOP_MATERIALIZE,
    JSTRAT_NESTED_LOOP_MEMOIZE,
    JSTRAT_HASH_JOIN
    /* update NUM_PGPA_JOIN_STRATEGY if you add anything here */
} pgpa_join_strategy;

Function Documentation

pgpa_build_unrolled_join()

pgpa_unrolled_join * pgpa_build_unrolled_join ( pgpa_plan_walker_context *  walker, pgpa_join_unroller *  join_unroller  )

extern

Definition at line 230 of file pgpa_join.c.

{
    pgpa_unrolled_join *ujoin;
    int         i;
 
    /*
     * We shouldn't have gone even so far as to create a join unroller unless
     * we found at least one unrollable join.
     */
    Assert(join_unroller->nused > 0);
 
    /* Allocate result structures. */
    ujoin = palloc0_object(pgpa_unrolled_join);
    ujoin->ninner = join_unroller->nused;
    ujoin->strategy = palloc0_array(pgpa_join_strategy, join_unroller->nused);
    ujoin->inner = palloc0_array(pgpa_join_member, join_unroller->nused);
 
    /* Handle the outermost join. */
    ujoin->outer.plan = join_unroller->outer_subplan;
    ujoin->outer.elided_node = join_unroller->outer_elided_node;
    ujoin->outer.scan =
        pgpa_build_scan(walker, ujoin->outer.plan,
                        ujoin->outer.elided_node,
                        join_unroller->outer_beneath_any_gather,
                        true);
 
    /*
     * We want the joins from the deepest part of the plan tree to appear
     * first in the result object, but the join unroller adds them in exactly
     * the reverse of that order, so we need to flip the order of the arrays
     * when constructing the final result.
     */
    for (i = 0; i < join_unroller->nused; ++i)
    {
        int         k = join_unroller->nused - i - 1;
 
        /* Copy strategy, Plan, and ElidedNode. */
        ujoin->strategy[i] = join_unroller->strategy[k];
        ujoin->inner[i].plan = join_unroller->inner_subplans[k];
        ujoin->inner[i].elided_node = join_unroller->inner_elided_nodes[k];
 
        /*
         * Fill in remaining details, using either the nested join unroller,
         * or by deriving them from the plan and elided nodes.
         */
        if (join_unroller->inner_unrollers[k] != NULL)
            ujoin->inner[i].unrolled_join =
                pgpa_build_unrolled_join(walker,
                                         join_unroller->inner_unrollers[k]);
        else
            ujoin->inner[i].scan =
                pgpa_build_scan(walker, ujoin->inner[i].plan,
                                ujoin->inner[i].elided_node,
                                join_unroller->inner_beneath_any_gather[k],
                                true);
    }
 
    return ujoin;
}

References Assert, fb(), i, palloc0_array, palloc0_object, pgpa_build_scan(), and pgpa_build_unrolled_join().

Referenced by pgpa_build_unrolled_join(), and pgpa_walk_recursively().

pgpa_create_join_unroller()

pgpa_join_unroller * pgpa_create_join_unroller ( void  )

extern

Definition at line 64 of file pgpa_join.c.

{
    pgpa_join_unroller *join_unroller;
 
    join_unroller = palloc0_object(pgpa_join_unroller);
    join_unroller->nallocated = 4;
    join_unroller->strategy =
        palloc_array(pgpa_join_strategy, join_unroller->nallocated);
    join_unroller->inner_subplans =
        palloc_array(Plan *, join_unroller->nallocated);
    join_unroller->inner_elided_nodes =
        palloc_array(ElidedNode *, join_unroller->nallocated);
    join_unroller->inner_unrollers =
        palloc_array(pgpa_join_unroller *, join_unroller->nallocated);
    join_unroller->inner_beneath_any_gather =
        palloc_array(bool, join_unroller->nallocated);
 
    return join_unroller;
}

References fb(), pgpa_join_unroller::nallocated, palloc0_object, and palloc_array.

Referenced by pgpa_unroll_join(), and pgpa_walk_recursively().

pgpa_destroy_join_unroller()

void pgpa_destroy_join_unroller ( pgpa_join_unroller *  join_unroller )

extern

Definition at line 295 of file pgpa_join.c.

{
    pfree(join_unroller->strategy);
    pfree(join_unroller->inner_subplans);
    pfree(join_unroller->inner_elided_nodes);
    pfree(join_unroller->inner_unrollers);
    pfree(join_unroller->inner_beneath_any_gather);
    pfree(join_unroller);
}

References fb(), and pfree().

Referenced by pgpa_walk_recursively().

pgpa_is_join()

static bool pgpa_is_join ( Plan *  plan )

inlinestatic

Definition at line 90 of file pgpa_join.h.

{
    return IsA(plan, NestLoop) || IsA(plan, MergeJoin) || IsA(plan, HashJoin);
}

References IsA, and plan.

Referenced by pgpa_unroll_join(), and pgpa_walk_recursively().

pgpa_unroll_join()

void pgpa_unroll_join ( pgpa_plan_walker_context *  walker, Plan *  plan, bool  beneath_any_gather, pgpa_join_unroller *  join_unroller, pgpa_join_unroller **  outer_join_unroller, pgpa_join_unroller **  inner_join_unroller  )

extern

Definition at line 105 of file pgpa_join.c.

{
    pgpa_join_strategy strategy;
    Plan       *realinner,
               *realouter;
    ElidedNode *elidedinner,
               *elidedouter;
    int         n;
    bool        found_any_outer_gather = false;
    bool        found_any_inner_gather = false;
 
    Assert(join_unroller != NULL);
 
    /*
     * We need to pass the join_unroller object down through certain types of
     * plan nodes -- anything that's considered part of the join strategy, and
     * any other nodes that can occur in a join tree despite not being scans
     * or joins.
     *
     * This includes:
     *
     * (1) Materialize, Memoize, and Hash nodes, which are part of the join
     * strategy,
     *
     * (2) Gather and Gather Merge nodes, which can occur at any point in the
     * join tree where the planner decided to initiate parallelism,
     *
     * (3) Sort and IncrementalSort nodes, which can occur beneath MergeJoin
     * or GatherMerge,
     *
     * (4) Agg and Unique nodes, which can occur when we decide to make the
     * nullable side of a semijoin unique and then join the result, and
     *
     * (5) Result nodes with children, which can be added either to project to
     * enforce a one-time filter (but Result nodes without children are
     * degenerate scans or joins).
     */
    if (IsA(plan, Material) || IsA(plan, Memoize) || IsA(plan, Hash)
        || IsA(plan, Gather) || IsA(plan, GatherMerge)
        || is_sorting_plan(plan) || IsA(plan, Agg) || IsA(plan, Unique)
        || is_result_node_with_child(plan))
    {
        *outer_join_unroller = join_unroller;
        return;
    }
 
    /*
     * Since we've already handled nodes that require pass-through treatment,
     * this should be an unrollable join.
     */
    strategy = pgpa_decompose_join(walker, plan,
                                   &realouter, &realinner,
                                   &elidedouter, &elidedinner,
                                   &found_any_outer_gather,
                                   &found_any_inner_gather);
 
    /* If our workspace is full, expand it. */
    if (join_unroller->nused >= join_unroller->nallocated)
    {
        join_unroller->nallocated *= 2;
        join_unroller->strategy =
            repalloc_array(join_unroller->strategy,
                           pgpa_join_strategy,
                           join_unroller->nallocated);
        join_unroller->inner_subplans =
            repalloc_array(join_unroller->inner_subplans,
                           Plan *,
                           join_unroller->nallocated);
        join_unroller->inner_elided_nodes =
            repalloc_array(join_unroller->inner_elided_nodes,
                           ElidedNode *,
                           join_unroller->nallocated);
        join_unroller->inner_beneath_any_gather =
            repalloc_array(join_unroller->inner_beneath_any_gather,
                           bool,
                           join_unroller->nallocated);
        join_unroller->inner_unrollers =
            repalloc_array(join_unroller->inner_unrollers,
                           pgpa_join_unroller *,
                           join_unroller->nallocated);
    }
 
    /*
     * Since we're flattening outer-deep join trees, it follows that if the
     * outer side is still an unrollable join, it should be unrolled into this
     * same object. Otherwise, we've reached the limit of what we can unroll
     * into this object and must remember the outer side as the final outer
     * subplan.
     */
    if (elidedouter == NULL && pgpa_is_join(realouter))
        *outer_join_unroller = join_unroller;
    else
    {
        join_unroller->outer_subplan = realouter;
        join_unroller->outer_elided_node = elidedouter;
        join_unroller->outer_beneath_any_gather =
            beneath_any_gather || found_any_outer_gather;
    }
 
    /*
     * Store the inner subplan. If it's an unrollable join, it needs to be
     * flattened in turn, but into a new unroller object, not this one.
     */
    n = join_unroller->nused++;
    join_unroller->strategy[n] = strategy;
    join_unroller->inner_subplans[n] = realinner;
    join_unroller->inner_elided_nodes[n] = elidedinner;
    join_unroller->inner_beneath_any_gather[n] =
        beneath_any_gather || found_any_inner_gather;
    if (elidedinner == NULL && pgpa_is_join(realinner))
        *inner_join_unroller = pgpa_create_join_unroller();
    else
        *inner_join_unroller = NULL;
    join_unroller->inner_unrollers[n] = *inner_join_unroller;
}

References Assert, fb(), is_result_node_with_child(), is_sorting_plan(), IsA, pgpa_join_unroller::nallocated, pgpa_create_join_unroller(), pgpa_decompose_join(), pgpa_is_join(), plan, and repalloc_array.

Referenced by pgpa_walk_recursively().