#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 1062 of file nodeHashjoin.c.

{
    HashState  *hashNode = castNode(HashState, innerPlanState(node));
 
    /*
     * Free tuple stores if we made them (must do this before
     * ExecHashTableDestroy deletes hashCxt)
     */
    if (node->hj_NullOuterTupleStore)
    {
        tuplestore_end(node->hj_NullOuterTupleStore);
        node->hj_NullOuterTupleStore = NULL;
    }
    if (hashNode->null_tuple_store)
    {
        tuplestore_end(hashNode->null_tuple_store);
        hashNode->null_tuple_store = NULL;
    }
 
    /*
     * 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 castNode, ExecEndNode(), ExecHashTableDestroy(), fb(), HashJoinState::hj_HashTable, HashJoinState::hj_NullOuterTupleStore, innerPlanState, outerPlanState, and tuplestore_end().

Referenced by ExecEndNode().

◆ ExecHashJoinEstimate()

void ExecHashJoinEstimate	(	HashJoinState *	state,
		ParallelContext *	pcxt
	)

extern

Definition at line 1843 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 1850 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 1961 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 1908 of file nodeHashjoin.c.

{
    int         plan_node_id = state->js.ps.plan->plan_node_id;
    ParallelHashJoinState *pstate;
    HashState  *hashNode;
 
    /* 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);
 
    /* We'd better clear our local null-key tuplestores, too. */
    if (state->hj_NullOuterTupleStore)
    {
        tuplestore_end(state->hj_NullOuterTupleStore);
        state->hj_NullOuterTupleStore = NULL;
    }
    hashNode = (HashState *) innerPlanState(state);
    if (hashNode->null_tuple_store)
    {
        tuplestore_end(hashNode->null_tuple_store);
        hashNode->null_tuple_store = NULL;
    }
 
 
    /* 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, innerPlanState, ParallelContext::seg, SharedFileSetDeleteAll(), shm_toc_lookup(), ParallelContext::toc, and tuplestore_end().

Referenced by ExecParallelReInitializeDSM().

◆ ExecHashJoinSaveTuple()

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

extern

Definition at line 1571 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 834 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.
         * Note: 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
         * join operator, and detect whether the join operator is strict.
         */
        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 side of the join.
         */
        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);
 
        /* 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);
 
        /* Remember whether we need to save tuples with null join keys */
        hjstate->hj_KeepNullTuples = HJ_FILL_OUTER(hjstate);
        hashstate->keep_null_tuples = 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_NullOuterTupleStore = 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 1651 of file nodeHashjoin.c.

{
    PlanState  *outerPlan = outerPlanState(node);
    PlanState  *innerPlan = innerPlanState(node);
 
    /*
     * We're always going to rescan the outer rel, so drop the associated
     * null-keys tuplestore; we'll rebuild it during the rescan.  (Must do
     * this before ExecHashTableDestroy deletes hashCxt.)
     */
    if (node->hj_NullOuterTupleStore)
    {
        tuplestore_end(node->hj_NullOuterTupleStore);
        node->hj_NullOuterTupleStore = NULL;
    }
 
    /*
     * 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)
    {
        HashState  *hashNode = castNode(HashState, innerPlan);
 
        Assert(hashNode->hashtable == node->hj_HashTable);
 
        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;
 
            /*
             * Also, rewind inner null-key tuplestore so that we can return
             * those tuples again.
             */
            if (hashNode->null_tuple_store)
                tuplestore_rescan(hashNode->null_tuple_store);
 
            /* ExecHashJoin can skip the BUILD_HASHTABLE step */
            node->hj_JoinState = HJ_NEED_NEW_OUTER;
        }
        else
        {
            /* must destroy and rebuild hash table */
 
            /* 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);
 
            /* free inner null-key tuplestore before ExecHashTableDestroy */
            if (hashNode->null_tuple_store)
            {
                tuplestore_end(hashNode->null_tuple_store);
                hashNode->null_tuple_store = NULL;
            }
 
            /* 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 1767 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()