#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:

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 )

extern

Definition at line 948 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(), fb(), HashJoinState::hj_HashTable, innerPlanState, and outerPlanState.

Referenced by ExecEndNode().

◆ ExecHashJoinEstimate()

void ExecHashJoinEstimate	(	HashJoinState *	state,
		ParallelContext *	pcxt
	)

extern

Definition at line 1648 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
	)

extern

Definition at line 1655 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;
}

Referenced by ExecParallelInitializeDSM().

◆ ExecHashJoinInitializeWorker()

void ExecHashJoinInitializeWorker	(	HashJoinState *	state,
		ParallelWorkerContext *	pwcxt
	)

extern

Definition at line 1751 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(), fb(), ParallelHashJoinState::fileset, innerPlanState, SharedFileSetAttach(), and shm_toc_lookup().

Referenced by ExecParallelInitializeWorker().

◆ ExecHashJoinReInitializeDSM()

void ExecHashJoinReInitializeDSM	(	HashJoinState *	state,
		ParallelContext *	pcxt
	)

extern

Definition at line 1713 of file nodeHashjoin.c.

{
    int         plan_node_id = state->js.ps.plan->plan_node_id;
    ParallelHashJoinState *pstate;
 
    /* Nothing to do if we failed to create a DSM segment. */
    if (pcxt->seg == NULL)
        return;
 
    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(), fb(), ParallelHashJoinState::fileset, ParallelContext::seg, SharedFileSetDeleteAll(), shm_toc_lookup(), and ParallelContext::toc.

Referenced by ExecParallelReInitializeDSM().

◆ ExecHashJoinSaveTuple()

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

extern

Definition at line 1414 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(), fb(), MemoryContextSwitchTo(), HashJoinTableData::spillCxt, and MinimalTupleData::t_len.

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

◆ ExecInitHashJoin()

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

extern

Definition at line 716 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);
        Hash       *hash = (Hash *) hashstate->ps.plan;
        TupleTableSlot *slot = hashstate->ps.ps_ResultTupleSlot;
        Oid        *outer_hashfuncid;
        Oid        *inner_hashfuncid;
        bool       *hash_strict;
        ListCell   *lc;
        int         nkeys;
 
 
        hjstate->hj_HashTupleSlot = slot;
 
        /*
         * Build ExprStates to obtain hash values for either side of the join.
         * This must be done here as ExecBuildHash32Expr needs to know how to
         * handle NULL inputs and the required handling of that depends on the
         * jointype.  We don't know the join type in ExecInitHash() and we
         * must build the ExprStates before ExecHashTableCreate() so we
         * properly attribute any SubPlans that exist in the hash expressions
         * to the correct PlanState.
         */
        nkeys = list_length(node->hashoperators);
 
        outer_hashfuncid = palloc_array(Oid, nkeys);
        inner_hashfuncid = palloc_array(Oid, nkeys);
        hash_strict = palloc_array(bool, nkeys);
 
        /*
         * Determine the hash function for each side of the join for the given
         * hash operator.
         */
        foreach(lc, node->hashoperators)
        {
            Oid         hashop = lfirst_oid(lc);
            int         i = foreach_current_index(lc);
 
            if (!get_op_hash_functions(hashop,
                                       &outer_hashfuncid[i],
                                       &inner_hashfuncid[i]))
                elog(ERROR,
                     "could not find hash function for hash operator %u",
                     hashop);
            hash_strict[i] = op_strict(hashop);
        }
 
        /*
         * Build an ExprState to generate the hash value for the expressions
         * on the outer of the join.  This ExprState must finish generating
         * the hash value when HJ_FILL_OUTER() is true.  Otherwise,
         * ExecBuildHash32Expr will set up the ExprState to abort early if it
         * finds a NULL.  In these cases, we don't need to store these tuples
         * in the hash table as the jointype does not require it.
         */
        hjstate->hj_OuterHash =
            ExecBuildHash32Expr(hjstate->js.ps.ps_ResultTupleDesc,
                                hjstate->js.ps.resultops,
                                outer_hashfuncid,
                                node->hashcollations,
                                node->hashkeys,
                                hash_strict,
                                &hjstate->js.ps,
                                0,
                                HJ_FILL_OUTER(hjstate));
 
        /* As above, but for the inner side of the join */
        hashstate->hash_expr =
            ExecBuildHash32Expr(hashstate->ps.ps_ResultTupleDesc,
                                hashstate->ps.resultops,
                                inner_hashfuncid,
                                node->hashcollations,
                                hash->hashkeys,
                                hash_strict,
                                &hashstate->ps,
                                0,
                                HJ_FILL_INNER(hjstate));
 
        /*
         * Set up the skew table hash function while we have a record of the
         * first key's hash function Oid.
         */
        if (OidIsValid(hash->skewTable))
        {
            hashstate->skew_hashfunction = palloc0_object(FmgrInfo);
            hashstate->skew_collation = linitial_oid(node->hashcollations);
            fmgr_info(outer_hashfuncid[0], hashstate->skew_hashfunction);
        }
 
        /* no need to keep these */
        pfree(outer_hashfuncid);
        pfree(inner_hashfuncid);
        pfree(hash_strict);
    }
 
    /*
     * 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_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(), ExecBuildHash32Expr(), ExecGetResultSlotOps(), ExecGetResultType(), ExecHashJoin(), ExecInitExtraTupleSlot(), ExecInitNode(), ExecInitNullTupleSlot(), ExecInitQual(), ExecInitResultTupleSlotTL(), fb(), fmgr_info(), foreach_current_index, get_op_hash_functions(), hash(), HashJoin::hashclauses, HashJoin::hashcollations, HashJoin::hashkeys, HashJoin::hashoperators, HJ_BUILD_HASHTABLE, HJ_FILL_INNER, HJ_FILL_OUTER, i, 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, Join::joinqual, Join::jointype, lfirst_oid, linitial_oid, list_length(), makeNode, OidIsValid, op_strict(), outerPlan, outerPlanState, palloc0_object, palloc_array, pfree(), Hash::plan, and TTSOpsVirtual.

Referenced by ExecInitNode().

◆ ExecReScanHashJoin()

void ExecReScanHashJoin ( HashJoinState * node )

extern

Definition at line 1494 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/right-semi/full join, we'd
             * better reset the inner-tuple match flags contained in the
             * table.
             */
            if (HJ_FILL_INNER(node) || node->js.jointype == JOIN_RIGHT_SEMI)
                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 = palloc0_object(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);
}

Referenced by ExecReScan().

◆ ExecShutdownHashJoin()

void ExecShutdownHashJoin ( HashJoinState * node )

extern

Definition at line 1582 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().

Functions

Function Documentation

◆ ExecEndHashJoin()

◆ ExecHashJoinEstimate()

◆ ExecHashJoinInitializeDSM()

◆ ExecHashJoinInitializeWorker()

◆ ExecHashJoinReInitializeDSM()

◆ ExecHashJoinSaveTuple()

◆ ExecInitHashJoin()

◆ ExecReScanHashJoin()

◆ ExecShutdownHashJoin()