hashsort.c File Reference

#include "postgres.h"
#include "access/hash.h"
#include "commands/progress.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "port/pg_bitutils.h"
#include "utils/tuplesort.h"

Include dependency graph for hashsort.c:

Go to the source code of this file.

Data Structures
struct	HSpool

Functions
HSpool *	_h_spoolinit (Relation heap, Relation index, uint32 num_buckets)
void	_h_spooldestroy (HSpool *hspool)
void	_h_spool (HSpool *hspool, ItemPointer self, const Datum *values, const bool *isnull)
void	_h_indexbuild (HSpool *hspool, Relation heapRel)

Function Documentation

_h_indexbuild()

void _h_indexbuild	(	HSpool *	hspool,
		Relation	heapRel
	)

Definition at line 120 of file hashsort.c.

{
    IndexTuple  itup;
    int64       tups_done = 0;
#ifdef USE_ASSERT_CHECKING
    uint32      hashkey = 0;
#endif
 
    tuplesort_performsort(hspool->sortstate);
 
    while ((itup = tuplesort_getindextuple(hspool->sortstate, true)) != NULL)
    {
        /*
         * Technically, it isn't critical that hash keys be found in sorted
         * order, since this sorting is only used to increase locality of
         * access as a performance optimization.  It still seems like a good
         * idea to test tuplesort.c's handling of hash index tuple sorts
         * through an assertion, though.
         */
#ifdef USE_ASSERT_CHECKING
        uint32      lasthashkey = hashkey;
 
        hashkey = _hash_hashkey2bucket(_hash_get_indextuple_hashkey(itup),
                                       hspool->max_buckets, hspool->high_mask,
                                       hspool->low_mask);
        Assert(hashkey >= lasthashkey);
#endif
 
        /* the tuples are sorted by hashkey, so pass 'sorted' as true */
        _hash_doinsert(hspool->index, itup, heapRel, true);
 
        /* allow insertion phase to be interrupted, and track progress */
        CHECK_FOR_INTERRUPTS();
 
        pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
                                     ++tups_done);
    }
}

References _hash_doinsert(), _hash_get_indextuple_hashkey(), _hash_hashkey2bucket(), Assert(), CHECK_FOR_INTERRUPTS, HSpool::high_mask, HSpool::index, HSpool::low_mask, HSpool::max_buckets, pgstat_progress_update_param(), PROGRESS_CREATEIDX_TUPLES_DONE, HSpool::sortstate, tuplesort_getindextuple(), and tuplesort_performsort().

Referenced by hashbuild().

_h_spool()

void _h_spool	(	HSpool *	hspool,
		ItemPointer	self,
		const Datum *	values,
		const bool *	isnull
	)

Definition at line 109 of file hashsort.c.

{
    tuplesort_putindextuplevalues(hspool->sortstate, hspool->index,
                                  self, values, isnull);
}

References HSpool::index, HSpool::sortstate, tuplesort_putindextuplevalues(), and values.

Referenced by hashbuildCallback().

_h_spooldestroy()

void _h_spooldestroy

(

HSpool *

hspool

)

Definition at line 99 of file hashsort.c.

{
    tuplesort_end(hspool->sortstate);
    pfree(hspool);
}

References pfree(), HSpool::sortstate, and tuplesort_end().

Referenced by hashbuild().

_h_spoolinit()

HSpool * _h_spoolinit	(	Relation	heap,
		Relation	index,
		uint32	num_buckets
	)

Definition at line 60 of file hashsort.c.

{
    HSpool     *hspool = (HSpool *) palloc0(sizeof(HSpool));
 
    hspool->index = index;
 
    /*
     * Determine the bitmask for hash code values.  Since there are currently
     * num_buckets buckets in the index, the appropriate mask can be computed
     * as follows.
     *
     * NOTE : This hash mask calculation should be in sync with similar
     * calculation in _hash_init_metabuffer.
     */
    hspool->high_mask = pg_nextpower2_32(num_buckets + 1) - 1;
    hspool->low_mask = (hspool->high_mask >> 1);
    hspool->max_buckets = num_buckets - 1;
 
    /*
     * We size the sort area as maintenance_work_mem rather than work_mem to
     * speed index creation.  This should be OK since a single backend can't
     * run multiple index creations in parallel.
     */
    hspool->sortstate = tuplesort_begin_index_hash(heap,
                                                   index,
                                                   hspool->high_mask,
                                                   hspool->low_mask,
                                                   hspool->max_buckets,
                                                   maintenance_work_mem,
                                                   NULL,
                                                   TUPLESORT_NONE);
 
    return hspool;
}

References HSpool::high_mask, HSpool::index, HSpool::low_mask, maintenance_work_mem, HSpool::max_buckets, palloc0(), pg_nextpower2_32(), HSpool::sortstate, tuplesort_begin_index_hash(), and TUPLESORT_NONE.

Referenced by hashbuild().