nodeHashjoin.h File Reference

#include "access/parallel.h"
#include "nodes/execnodes.h"
#include "storage/buffile.h"

Include dependency graph for nodeHashjoin.h:

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

Go to the source code of this file.

Functions
HashJoinState *	ExecInitHashJoin (HashJoin *node, EState *estate, int eflags)
void	ExecEndHashJoin (HashJoinState *node)
void	ExecReScanHashJoin (HashJoinState *node)
void	ExecShutdownHashJoin (HashJoinState *node)
void	ExecHashJoinEstimate (HashJoinState *state, ParallelContext *pcxt)
void	ExecHashJoinInitializeDSM (HashJoinState *state, ParallelContext *pcxt)
void	ExecHashJoinReInitializeDSM (HashJoinState *state, ParallelContext *pcxt)
void	ExecHashJoinInitializeWorker (HashJoinState *state, ParallelWorkerContext *pwcxt)
void	ExecHashJoinSaveTuple (MinimalTuple tuple, uint32 hashvalue, BufFile **fileptr, HashJoinTable hashtable)

Function Documentation

ExecEndHashJoin()

void ExecEndHashJoin

(

HashJoinState *

node

)

Definition at line 868 of file nodeHashjoin.c.

{
    /*
     * Free hash table
     */
    if (node->hj_HashTable)
    {
        ExecHashTableDestroy(node->hj_HashTable);
        node->hj_HashTable = NULL;
    }
 
    /*
     * clean up subtrees
     */
    ExecEndNode(outerPlanState(node));
    ExecEndNode(innerPlanState(node));
}

References ExecEndNode(), ExecHashTableDestroy(), HashJoinState::hj_HashTable, innerPlanState, and outerPlanState.

Referenced by ExecEndNode().

ExecHashJoinEstimate()

void ExecHashJoinEstimate	(	HashJoinState *	state,
		ParallelContext *	pcxt
	)

Definition at line 1553 of file nodeHashjoin.c.

{
    shm_toc_estimate_chunk(&pcxt->estimator, sizeof(ParallelHashJoinState));
    shm_toc_estimate_keys(&pcxt->estimator, 1);
}

References ParallelContext::estimator, shm_toc_estimate_chunk, and shm_toc_estimate_keys.

Referenced by ExecParallelEstimate().

ExecHashJoinInitializeDSM()

void ExecHashJoinInitializeDSM	(	HashJoinState *	state,
		ParallelContext *	pcxt
	)

Definition at line 1560 of file nodeHashjoin.c.

{
    int         plan_node_id = state->js.ps.plan->plan_node_id;
    HashState  *hashNode;
    ParallelHashJoinState *pstate;
 
    /*
     * Disable shared hash table mode if we failed to create a real DSM
     * segment, because that means that we don't have a DSA area to work with.
     */
    if (pcxt->seg == NULL)
        return;
 
    ExecSetExecProcNode(&state->js.ps, ExecParallelHashJoin);
 
    /*
     * Set up the state needed to coordinate access to the shared hash
     * table(s), using the plan node ID as the toc key.
     */
    pstate = shm_toc_allocate(pcxt->toc, sizeof(ParallelHashJoinState));
    shm_toc_insert(pcxt->toc, plan_node_id, pstate);
 
    /*
     * Set up the shared hash join state with no batches initially.
     * ExecHashTableCreate() will prepare at least one later and set nbatch
     * and space_allowed.
     */
    pstate->nbatch = 0;
    pstate->space_allowed = 0;
    pstate->batches = InvalidDsaPointer;
    pstate->old_batches = InvalidDsaPointer;
    pstate->nbuckets = 0;
    pstate->growth = PHJ_GROWTH_OK;
    pstate->chunk_work_queue = InvalidDsaPointer;
    pg_atomic_init_u32(&pstate->distributor, 0);
    pstate->nparticipants = pcxt->nworkers + 1;
    pstate->total_tuples = 0;
    LWLockInitialize(&pstate->lock,
                     LWTRANCHE_PARALLEL_HASH_JOIN);
    BarrierInit(&pstate->build_barrier, 0);
    BarrierInit(&pstate->grow_batches_barrier, 0);
    BarrierInit(&pstate->grow_buckets_barrier, 0);
 
    /* Set up the space we'll use for shared temporary files. */
    SharedFileSetInit(&pstate->fileset, pcxt->seg);
 
    /* Initialize the shared state in the hash node. */
    hashNode = (HashState *) innerPlanState(state);
    hashNode->parallel_state = pstate;
}

References BarrierInit(), ParallelHashJoinState::batches, ParallelHashJoinState::build_barrier, ParallelHashJoinState::chunk_work_queue, ParallelHashJoinState::distributor, ExecParallelHashJoin(), ExecSetExecProcNode(), ParallelHashJoinState::fileset, ParallelHashJoinState::grow_batches_barrier, ParallelHashJoinState::grow_buckets_barrier, ParallelHashJoinState::growth, innerPlanState, InvalidDsaPointer, ParallelHashJoinState::lock, LWLockInitialize(), LWTRANCHE_PARALLEL_HASH_JOIN, ParallelHashJoinState::nbatch, ParallelHashJoinState::nbuckets, ParallelHashJoinState::nparticipants, ParallelContext::nworkers, ParallelHashJoinState::old_batches, HashState::parallel_state, pg_atomic_init_u32(), PHJ_GROWTH_OK, ParallelContext::seg, SharedFileSetInit(), shm_toc_allocate(), shm_toc_insert(), ParallelHashJoinState::space_allowed, ParallelContext::toc, and ParallelHashJoinState::total_tuples.

Referenced by ExecParallelInitializeDSM().

ExecHashJoinInitializeWorker()

void ExecHashJoinInitializeWorker	(	HashJoinState *	state,
		ParallelWorkerContext *	pwcxt
	)

Definition at line 1651 of file nodeHashjoin.c.

{
    HashState  *hashNode;
    int         plan_node_id = state->js.ps.plan->plan_node_id;
    ParallelHashJoinState *pstate =
        shm_toc_lookup(pwcxt->toc, plan_node_id, false);
 
    /* Attach to the space for shared temporary files. */
    SharedFileSetAttach(&pstate->fileset, pwcxt->seg);
 
    /* Attach to the shared state in the hash node. */
    hashNode = (HashState *) innerPlanState(state);
    hashNode->parallel_state = pstate;
 
    ExecSetExecProcNode(&state->js.ps, ExecParallelHashJoin);
}

References ExecParallelHashJoin(), ExecSetExecProcNode(), ParallelHashJoinState::fileset, innerPlanState, HashState::parallel_state, ParallelWorkerContext::seg, SharedFileSetAttach(), shm_toc_lookup(), and ParallelWorkerContext::toc.

Referenced by ExecParallelInitializeWorker().

ExecHashJoinReInitializeDSM()

void ExecHashJoinReInitializeDSM	(	HashJoinState *	state,
		ParallelContext *	pcxt
	)

Definition at line 1618 of file nodeHashjoin.c.

{
    int         plan_node_id = state->js.ps.plan->plan_node_id;
    ParallelHashJoinState *pstate =
        shm_toc_lookup(pcxt->toc, plan_node_id, false);
 
    /*
     * It would be possible to reuse the shared hash table in single-batch
     * cases by resetting and then fast-forwarding build_barrier to
     * PHJ_BUILD_FREE and batch 0's batch_barrier to PHJ_BATCH_PROBE, but
     * currently shared hash tables are already freed by now (by the last
     * participant to detach from the batch).  We could consider keeping it
     * around for single-batch joins.  We'd also need to adjust
     * finalize_plan() so that it doesn't record a dummy dependency for
     * Parallel Hash nodes, preventing the rescan optimization.  For now we
     * don't try.
     */
 
    /* Detach, freeing any remaining shared memory. */
    if (state->hj_HashTable != NULL)
    {
        ExecHashTableDetachBatch(state->hj_HashTable);
        ExecHashTableDetach(state->hj_HashTable);
    }
 
    /* Clear any shared batch files. */
    SharedFileSetDeleteAll(&pstate->fileset);
 
    /* Reset build_barrier to PHJ_BUILD_ELECT so we can go around again. */
    BarrierInit(&pstate->build_barrier, 0);
}

References BarrierInit(), ParallelHashJoinState::build_barrier, ExecHashTableDetach(), ExecHashTableDetachBatch(), ParallelHashJoinState::fileset, SharedFileSetDeleteAll(), shm_toc_lookup(), and ParallelContext::toc.

Referenced by ExecParallelReInitializeDSM().

ExecHashJoinSaveTuple()

void ExecHashJoinSaveTuple	(	MinimalTuple	tuple,
		uint32	hashvalue,
		BufFile **	fileptr,
		HashJoinTable	hashtable
	)

Definition at line 1324 of file nodeHashjoin.c.

{
    BufFile    *file = *fileptr;
 
    /*
     * The batch file is lazily created. If this is the first tuple written to
     * this batch, the batch file is created and its buffer is allocated in
     * the spillCxt context, NOT in the batchCxt.
     *
     * During the build phase, buffered files are created for inner batches.
     * Each batch's buffered file is closed (and its buffer freed) after the
     * batch is loaded into memory during the outer side scan. Therefore, it
     * is necessary to allocate the batch file buffer in a memory context
     * which outlives the batch itself.
     *
     * Also, we use spillCxt instead of hashCxt for a better accounting of the
     * spilling memory consumption.
     */
    if (file == NULL)
    {
        MemoryContext oldctx = MemoryContextSwitchTo(hashtable->spillCxt);
 
        file = BufFileCreateTemp(false);
        *fileptr = file;
 
        MemoryContextSwitchTo(oldctx);
    }
 
    BufFileWrite(file, &hashvalue, sizeof(uint32));
    BufFileWrite(file, tuple, tuple->t_len);
}

References BufFileCreateTemp(), BufFileWrite(), MemoryContextSwitchTo(), HashJoinTableData::spillCxt, and MinimalTupleData::t_len.

Referenced by ExecHashIncreaseNumBatches(), ExecHashJoinImpl(), ExecHashRemoveNextSkewBucket(), and ExecHashTableInsert().

ExecInitHashJoin()

HashJoinState* ExecInitHashJoin	(	HashJoin *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 718 of file nodeHashjoin.c.

{
    HashJoinState *hjstate;
    Plan       *outerNode;
    Hash       *hashNode;
    TupleDesc   outerDesc,
                innerDesc;
    const TupleTableSlotOps *ops;
 
    /* check for unsupported flags */
    Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
 
    /*
     * create state structure
     */
    hjstate = makeNode(HashJoinState);
    hjstate->js.ps.plan = (Plan *) node;
    hjstate->js.ps.state = estate;
 
    /*
     * See ExecHashJoinInitializeDSM() and ExecHashJoinInitializeWorker()
     * where this function may be replaced with a parallel version, if we
     * managed to launch a parallel query.
     */
    hjstate->js.ps.ExecProcNode = ExecHashJoin;
    hjstate->js.jointype = node->join.jointype;
 
    /*
     * Miscellaneous initialization
     *
     * create expression context for node
     */
    ExecAssignExprContext(estate, &hjstate->js.ps);
 
    /*
     * initialize child nodes
     *
     * Note: we could suppress the REWIND flag for the inner input, which
     * would amount to betting that the hash will be a single batch.  Not
     * clear if this would be a win or not.
     */
    outerNode = outerPlan(node);
    hashNode = (Hash *) innerPlan(node);
 
    outerPlanState(hjstate) = ExecInitNode(outerNode, estate, eflags);
    outerDesc = ExecGetResultType(outerPlanState(hjstate));
    innerPlanState(hjstate) = ExecInitNode((Plan *) hashNode, estate, eflags);
    innerDesc = ExecGetResultType(innerPlanState(hjstate));
 
    /*
     * Initialize result slot, type and projection.
     */
    ExecInitResultTupleSlotTL(&hjstate->js.ps, &TTSOpsVirtual);
    ExecAssignProjectionInfo(&hjstate->js.ps, NULL);
 
    /*
     * tuple table initialization
     */
    ops = ExecGetResultSlotOps(outerPlanState(hjstate), NULL);
    hjstate->hj_OuterTupleSlot = ExecInitExtraTupleSlot(estate, outerDesc,
                                                        ops);
 
    /*
     * detect whether we need only consider the first matching inner tuple
     */
    hjstate->js.single_match = (node->join.inner_unique ||
                                node->join.jointype == JOIN_SEMI);
 
    /* set up null tuples for outer joins, if needed */
    switch (node->join.jointype)
    {
        case JOIN_INNER:
        case JOIN_SEMI:
        case JOIN_RIGHT_SEMI:
            break;
        case JOIN_LEFT:
        case JOIN_ANTI:
            hjstate->hj_NullInnerTupleSlot =
                ExecInitNullTupleSlot(estate, innerDesc, &TTSOpsVirtual);
            break;
        case JOIN_RIGHT:
        case JOIN_RIGHT_ANTI:
            hjstate->hj_NullOuterTupleSlot =
                ExecInitNullTupleSlot(estate, outerDesc, &TTSOpsVirtual);
            break;
        case JOIN_FULL:
            hjstate->hj_NullOuterTupleSlot =
                ExecInitNullTupleSlot(estate, outerDesc, &TTSOpsVirtual);
            hjstate->hj_NullInnerTupleSlot =
                ExecInitNullTupleSlot(estate, innerDesc, &TTSOpsVirtual);
            break;
        default:
            elog(ERROR, "unrecognized join type: %d",
                 (int) node->join.jointype);
    }
 
    /*
     * now for some voodoo.  our temporary tuple slot is actually the result
     * tuple slot of the Hash node (which is our inner plan).  we can do this
     * because Hash nodes don't return tuples via ExecProcNode() -- instead
     * the hash join node uses ExecScanHashBucket() to get at the contents of
     * the hash table.  -cim 6/9/91
     */
    {
        HashState  *hashstate = (HashState *) innerPlanState(hjstate);
        TupleTableSlot *slot = hashstate->ps.ps_ResultTupleSlot;
 
        hjstate->hj_HashTupleSlot = slot;
    }
 
    /*
     * initialize child expressions
     */
    hjstate->js.ps.qual =
        ExecInitQual(node->join.plan.qual, (PlanState *) hjstate);
    hjstate->js.joinqual =
        ExecInitQual(node->join.joinqual, (PlanState *) hjstate);
    hjstate->hashclauses =
        ExecInitQual(node->hashclauses, (PlanState *) hjstate);
 
    /*
     * initialize hash-specific info
     */
    hjstate->hj_HashTable = NULL;
    hjstate->hj_FirstOuterTupleSlot = NULL;
 
    hjstate->hj_CurHashValue = 0;
    hjstate->hj_CurBucketNo = 0;
    hjstate->hj_CurSkewBucketNo = INVALID_SKEW_BUCKET_NO;
    hjstate->hj_CurTuple = NULL;
 
    hjstate->hj_OuterHashKeys = ExecInitExprList(node->hashkeys,
                                                 (PlanState *) hjstate);
    hjstate->hj_HashOperators = node->hashoperators;
    hjstate->hj_Collations = node->hashcollations;
 
    hjstate->hj_JoinState = HJ_BUILD_HASHTABLE;
    hjstate->hj_MatchedOuter = false;
    hjstate->hj_OuterNotEmpty = false;
 
    return hjstate;
}

References Assert, elog, ERROR, EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, ExecAssignExprContext(), ExecAssignProjectionInfo(), ExecGetResultSlotOps(), ExecGetResultType(), ExecHashJoin(), ExecInitExprList(), ExecInitExtraTupleSlot(), ExecInitNode(), ExecInitNullTupleSlot(), ExecInitQual(), ExecInitResultTupleSlotTL(), PlanState::ExecProcNode, HashJoinState::hashclauses, HashJoin::hashclauses, HashJoin::hashcollations, HashJoin::hashkeys, HashJoin::hashoperators, HJ_BUILD_HASHTABLE, HashJoinState::hj_Collations, HashJoinState::hj_CurBucketNo, HashJoinState::hj_CurHashValue, HashJoinState::hj_CurSkewBucketNo, HashJoinState::hj_CurTuple, HashJoinState::hj_FirstOuterTupleSlot, HashJoinState::hj_HashOperators, HashJoinState::hj_HashTable, HashJoinState::hj_HashTupleSlot, HashJoinState::hj_JoinState, HashJoinState::hj_MatchedOuter, HashJoinState::hj_NullInnerTupleSlot, HashJoinState::hj_NullOuterTupleSlot, HashJoinState::hj_OuterHashKeys, HashJoinState::hj_OuterNotEmpty, HashJoinState::hj_OuterTupleSlot, Join::inner_unique, innerPlan, innerPlanState, INVALID_SKEW_BUCKET_NO, HashJoin::join, JOIN_ANTI, JOIN_FULL, JOIN_INNER, JOIN_LEFT, JOIN_RIGHT, JOIN_RIGHT_ANTI, JOIN_RIGHT_SEMI, JOIN_SEMI, JoinState::joinqual, Join::joinqual, JoinState::jointype, Join::jointype, HashJoinState::js, makeNode, outerPlan, outerPlanState, PlanState::plan, JoinState::ps, HashState::ps, PlanState::ps_ResultTupleSlot, PlanState::qual, JoinState::single_match, PlanState::state, and TTSOpsVirtual.

Referenced by ExecInitNode().

ExecReScanHashJoin()

void ExecReScanHashJoin

(

HashJoinState *

node

)

Definition at line 1404 of file nodeHashjoin.c.

{
    PlanState  *outerPlan = outerPlanState(node);
    PlanState  *innerPlan = innerPlanState(node);
 
    /*
     * In a multi-batch join, we currently have to do rescans the hard way,
     * primarily because batch temp files may have already been released. But
     * if it's a single-batch join, and there is no parameter change for the
     * inner subnode, then we can just re-use the existing hash table without
     * rebuilding it.
     */
    if (node->hj_HashTable != NULL)
    {
        if (node->hj_HashTable->nbatch == 1 &&
            innerPlan->chgParam == NULL)
        {
            /*
             * Okay to reuse the hash table; needn't rescan inner, either.
             *
             * However, if it's a right/right-anti/full join, we'd better
             * reset the inner-tuple match flags contained in the table.
             */
            if (HJ_FILL_INNER(node))
                ExecHashTableResetMatchFlags(node->hj_HashTable);
 
            /*
             * Also, we need to reset our state about the emptiness of the
             * outer relation, so that the new scan of the outer will update
             * it correctly if it turns out to be empty this time. (There's no
             * harm in clearing it now because ExecHashJoin won't need the
             * info.  In the other cases, where the hash table doesn't exist
             * or we are destroying it, we leave this state alone because
             * ExecHashJoin will need it the first time through.)
             */
            node->hj_OuterNotEmpty = false;
 
            /* ExecHashJoin can skip the BUILD_HASHTABLE step */
            node->hj_JoinState = HJ_NEED_NEW_OUTER;
        }
        else
        {
            /* must destroy and rebuild hash table */
            HashState  *hashNode = castNode(HashState, innerPlan);
 
            Assert(hashNode->hashtable == node->hj_HashTable);
            /* accumulate stats from old hash table, if wanted */
            /* (this should match ExecShutdownHash) */
            if (hashNode->ps.instrument && !hashNode->hinstrument)
                hashNode->hinstrument = (HashInstrumentation *)
                    palloc0(sizeof(HashInstrumentation));
            if (hashNode->hinstrument)
                ExecHashAccumInstrumentation(hashNode->hinstrument,
                                             hashNode->hashtable);
            /* for safety, be sure to clear child plan node's pointer too */
            hashNode->hashtable = NULL;
 
            ExecHashTableDestroy(node->hj_HashTable);
            node->hj_HashTable = NULL;
            node->hj_JoinState = HJ_BUILD_HASHTABLE;
 
            /*
             * if chgParam of subnode is not null then plan will be re-scanned
             * by first ExecProcNode.
             */
            if (innerPlan->chgParam == NULL)
                ExecReScan(innerPlan);
        }
    }
 
    /* Always reset intra-tuple state */
    node->hj_CurHashValue = 0;
    node->hj_CurBucketNo = 0;
    node->hj_CurSkewBucketNo = INVALID_SKEW_BUCKET_NO;
    node->hj_CurTuple = NULL;
 
    node->hj_MatchedOuter = false;
    node->hj_FirstOuterTupleSlot = NULL;
 
    /*
     * if chgParam of subnode is not null then plan will be re-scanned by
     * first ExecProcNode.
     */
    if (outerPlan->chgParam == NULL)
        ExecReScan(outerPlan);
}

References Assert, castNode, ExecHashAccumInstrumentation(), ExecHashTableDestroy(), ExecHashTableResetMatchFlags(), ExecReScan(), HashState::hashtable, HashState::hinstrument, HJ_BUILD_HASHTABLE, HashJoinState::hj_CurBucketNo, HashJoinState::hj_CurHashValue, HashJoinState::hj_CurSkewBucketNo, HashJoinState::hj_CurTuple, HJ_FILL_INNER, HashJoinState::hj_FirstOuterTupleSlot, HashJoinState::hj_HashTable, HashJoinState::hj_JoinState, HashJoinState::hj_MatchedOuter, HJ_NEED_NEW_OUTER, HashJoinState::hj_OuterNotEmpty, innerPlan, innerPlanState, PlanState::instrument, INVALID_SKEW_BUCKET_NO, HashJoinTableData::nbatch, outerPlan, outerPlanState, palloc0(), and HashState::ps.

Referenced by ExecReScan().

ExecShutdownHashJoin()

void ExecShutdownHashJoin

(

HashJoinState *

node

)

Definition at line 1492 of file nodeHashjoin.c.

{
    if (node->hj_HashTable)
    {
        /*
         * Detach from shared state before DSM memory goes away.  This makes
         * sure that we don't have any pointers into DSM memory by the time
         * ExecEndHashJoin runs.
         */
        ExecHashTableDetachBatch(node->hj_HashTable);
        ExecHashTableDetach(node->hj_HashTable);
    }
}

References ExecHashTableDetach(), ExecHashTableDetachBatch(), and HashJoinState::hj_HashTable.

Referenced by ExecShutdownNode_walker().