partdesc.c File Reference

#include "postgres.h"
#include "access/genam.h"
#include "access/htup_details.h"
#include "access/table.h"
#include "catalog/indexing.h"
#include "catalog/partition.h"
#include "catalog/pg_inherits.h"
#include "partitioning/partbounds.h"
#include "partitioning/partdesc.h"
#include "storage/bufmgr.h"
#include "storage/sinval.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
#include "utils/hsearch.h"
#include "utils/inval.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/partcache.h"
#include "utils/rel.h"
#include "utils/syscache.h"

Include dependency graph for partdesc.c:

Go to the source code of this file.

Data Structures
struct	PartitionDirectoryData
struct	PartitionDirectoryEntry

Typedefs
typedef struct PartitionDirectoryData	PartitionDirectoryData
typedef struct PartitionDirectoryEntry	PartitionDirectoryEntry

Functions
static void	RelationBuildPartitionDesc (Relation rel)
PartitionDesc	RelationGetPartitionDesc (Relation rel)
PartitionDirectory	CreatePartitionDirectory (MemoryContext mcxt)
PartitionDesc	PartitionDirectoryLookup (PartitionDirectory pdir, Relation rel)
void	DestroyPartitionDirectory (PartitionDirectory pdir)
Oid	get_default_oid_from_partdesc (PartitionDesc partdesc)

Typedef Documentation

PartitionDirectoryData

typedef struct PartitionDirectoryData PartitionDirectoryData

PartitionDirectoryEntry

typedef struct PartitionDirectoryEntry PartitionDirectoryEntry

Function Documentation

CreatePartitionDirectory()

PartitionDirectory CreatePartitionDirectory

(

MemoryContext

mcxt

)

Definition at line 284 of file partdesc.c.

References HASHCTL::entrysize, HASH_BLOBS, HASH_CONTEXT, hash_create(), HASH_ELEM, HASHCTL::hcxt, HASHCTL::keysize, MemoryContextSwitchTo(), MemSet, palloc(), PartitionDirectoryData::pdir_hash, and PartitionDirectoryData::pdir_mcxt.

Referenced by ExecCreatePartitionPruneState(), ExecInitPartitionDispatchInfo(), and set_relation_partition_info().

{
    MemoryContext oldcontext = MemoryContextSwitchTo(mcxt);
    PartitionDirectory pdir;
    HASHCTL     ctl;

    MemSet(&ctl, 0, sizeof(HASHCTL));
    ctl.keysize = sizeof(Oid);
    ctl.entrysize = sizeof(PartitionDirectoryEntry);
    ctl.hcxt = mcxt;

    pdir = palloc(sizeof(PartitionDirectoryData));
    pdir->pdir_mcxt = mcxt;
    pdir->pdir_hash = hash_create("partition directory", 256, &ctl,
                                  HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);

    MemoryContextSwitchTo(oldcontext);
    return pdir;
}

DestroyPartitionDirectory()

void DestroyPartitionDirectory

(

PartitionDirectory

pdir

)

Definition at line 344 of file partdesc.c.

References hash_seq_init(), hash_seq_search(), PartitionDirectoryData::pdir_hash, PartitionDirectoryEntry::rel, RelationDecrementReferenceCount(), and status().

Referenced by FreeExecutorState(), and standard_planner().

{
    HASH_SEQ_STATUS status;
    PartitionDirectoryEntry *pde;

    hash_seq_init(&status, pdir->pdir_hash);
    while ((pde = hash_seq_search(&status)) != NULL)
        RelationDecrementReferenceCount(pde->rel);
}

get_default_oid_from_partdesc()

Oid get_default_oid_from_partdesc

(

PartitionDesc

partdesc

)

Definition at line 361 of file partdesc.c.

References PartitionDescData::boundinfo, PartitionBoundInfoData::default_index, InvalidOid, PartitionDescData::oids, and partition_bound_has_default.

Referenced by ATExecAttachPartition(), ATExecDetachPartition(), DefineRelation(), and StorePartitionBound().

{
    if (partdesc && partdesc->boundinfo &&
        partition_bound_has_default(partdesc->boundinfo))
        return partdesc->oids[partdesc->boundinfo->default_index];

    return InvalidOid;
}

PartitionDirectoryLookup()

PartitionDesc PartitionDirectoryLookup	(	PartitionDirectory	pdir,
		Relation	rel
	)

Definition at line 316 of file partdesc.c.

References Assert, HASH_ENTER, hash_search(), PartitionDirectoryEntry::pd, PartitionDirectoryData::pdir_hash, PartitionDirectoryEntry::rel, RelationGetPartitionDesc(), RelationGetRelid, and RelationIncrementReferenceCount().

Referenced by ExecCreatePartitionPruneState(), ExecInitPartitionDispatchInfo(), expand_partitioned_rtentry(), and set_relation_partition_info().

{
    PartitionDirectoryEntry *pde;
    Oid         relid = RelationGetRelid(rel);
    bool        found;

    pde = hash_search(pdir->pdir_hash, &relid, HASH_ENTER, &found);
    if (!found)
    {
        /*
         * We must keep a reference count on the relation so that the
         * PartitionDesc to which we are pointing can't get destroyed.
         */
        RelationIncrementReferenceCount(rel);
        pde->rel = rel;
        pde->pd = RelationGetPartitionDesc(rel);
        Assert(pde->pd != NULL);
    }
    return pde->pd;
}

RelationBuildPartitionDesc()

static void RelationBuildPartitionDesc ( Relation  rel )

static

Definition at line 92 of file partdesc.c.

References AccessShareLock, ALLOCSET_SMALL_SIZES, AllocSetContextCreate, PartitionDescData::boundinfo, BTEqualStrategyNumber, CacheMemoryContext, ClassOidIndexId, CurTransactionContext, elog, ERROR, find_inheritance_children(), get_default_partition_oid(), get_rel_relkind(), heap_getattr, HeapTupleIsValid, i, PartitionBoundSpec::is_default, PartitionDescData::is_leaf, IsA, sort-test::key, lfirst_oid, list_length(), MemoryContextAllocZero(), MemoryContextCopyAndSetIdentifier, MemoryContextSetParent(), MemoryContextSwitchTo(), NoLock, PartitionDescData::nparts, ObjectIdGetDatum, PartitionDescData::oids, palloc(), partition_bounds_copy(), partition_bounds_create(), RelationData::rd_partdesc, RelationData::rd_pdcxt, RelationGetDescr, RelationGetPartitionKey(), RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), RELOID, ScanKeyInit(), SearchSysCache1(), stringToNode(), SysCacheGetAttr(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), and TextDatumGetCString.

Referenced by RelationGetPartitionDesc().

{
    PartitionDesc partdesc;
    PartitionBoundInfo boundinfo = NULL;
    List       *inhoids;
    PartitionBoundSpec **boundspecs = NULL;
    Oid        *oids = NULL;
    bool       *is_leaf = NULL;
    ListCell   *cell;
    int         i,
                nparts;
    PartitionKey key = RelationGetPartitionKey(rel);
    MemoryContext new_pdcxt;
    MemoryContext oldcxt;
    int        *mapping;

    /*
     * Get partition oids from pg_inherits.  This uses a single snapshot to
     * fetch the list of children, so while more children may be getting added
     * concurrently, whatever this function returns will be accurate as of
     * some well-defined point in time.
     */
    inhoids = find_inheritance_children(RelationGetRelid(rel), NoLock);
    nparts = list_length(inhoids);

    /* Allocate working arrays for OIDs, leaf flags, and boundspecs. */
    if (nparts > 0)
    {
        oids = (Oid *) palloc(nparts * sizeof(Oid));
        is_leaf = (bool *) palloc(nparts * sizeof(bool));
        boundspecs = palloc(nparts * sizeof(PartitionBoundSpec *));
    }

    /* Collect bound spec nodes for each partition. */
    i = 0;
    foreach(cell, inhoids)
    {
        Oid         inhrelid = lfirst_oid(cell);
        HeapTuple   tuple;
        PartitionBoundSpec *boundspec = NULL;

        /* Try fetching the tuple from the catcache, for speed. */
        tuple = SearchSysCache1(RELOID, inhrelid);
        if (HeapTupleIsValid(tuple))
        {
            Datum       datum;
            bool        isnull;

            datum = SysCacheGetAttr(RELOID, tuple,
                                    Anum_pg_class_relpartbound,
                                    &isnull);
            if (!isnull)
                boundspec = stringToNode(TextDatumGetCString(datum));
            ReleaseSysCache(tuple);
        }

        /*
         * The system cache may be out of date; if so, we may find no pg_class
         * tuple or an old one where relpartbound is NULL.  In that case, try
         * the table directly.  We can't just AcceptInvalidationMessages() and
         * retry the system cache lookup because it's possible that a
         * concurrent ATTACH PARTITION operation has removed itself from the
         * ProcArray but not yet added invalidation messages to the shared
         * queue; InvalidateSystemCaches() would work, but seems excessive.
         *
         * Note that this algorithm assumes that PartitionBoundSpec we manage
         * to fetch is the right one -- so this is only good enough for
         * concurrent ATTACH PARTITION, not concurrent DETACH PARTITION or
         * some hypothetical operation that changes the partition bounds.
         */
        if (boundspec == NULL)
        {
            Relation    pg_class;
            SysScanDesc scan;
            ScanKeyData key[1];
            Datum       datum;
            bool        isnull;

            pg_class = table_open(RelationRelationId, AccessShareLock);
            ScanKeyInit(&key[0],
                        Anum_pg_class_oid,
                        BTEqualStrategyNumber, F_OIDEQ,
                        ObjectIdGetDatum(inhrelid));
            scan = systable_beginscan(pg_class, ClassOidIndexId, true,
                                      NULL, 1, key);
            tuple = systable_getnext(scan);
            datum = heap_getattr(tuple, Anum_pg_class_relpartbound,
                                 RelationGetDescr(pg_class), &isnull);
            if (!isnull)
                boundspec = stringToNode(TextDatumGetCString(datum));
            systable_endscan(scan);
            table_close(pg_class, AccessShareLock);
        }

        /* Sanity checks. */
        if (!boundspec)
            elog(ERROR, "missing relpartbound for relation %u", inhrelid);
        if (!IsA(boundspec, PartitionBoundSpec))
            elog(ERROR, "invalid relpartbound for relation %u", inhrelid);

        /*
         * If the PartitionBoundSpec says this is the default partition, its
         * OID should match pg_partitioned_table.partdefid; if not, the
         * catalog is corrupt.
         */
        if (boundspec->is_default)
        {
            Oid         partdefid;

            partdefid = get_default_partition_oid(RelationGetRelid(rel));
            if (partdefid != inhrelid)
                elog(ERROR, "expected partdefid %u, but got %u",
                     inhrelid, partdefid);
        }

        /* Save results. */
        oids[i] = inhrelid;
        is_leaf[i] = (get_rel_relkind(inhrelid) != RELKIND_PARTITIONED_TABLE);
        boundspecs[i] = boundspec;
        ++i;
    }

    /*
     * Create PartitionBoundInfo and mapping, working in the caller's context.
     * This could fail, but we haven't done any damage if so.
     */
    if (nparts > 0)
        boundinfo = partition_bounds_create(boundspecs, nparts, key, &mapping);

    /*
     * Now build the actual relcache partition descriptor, copying all the
     * data into a new, small context.  As per above comment, we don't make
     * this a long-lived context until it's finished.
     */
    new_pdcxt = AllocSetContextCreate(CurTransactionContext,
                                      "partition descriptor",
                                      ALLOCSET_SMALL_SIZES);
    MemoryContextCopyAndSetIdentifier(new_pdcxt,
                                      RelationGetRelationName(rel));

    partdesc = (PartitionDescData *)
        MemoryContextAllocZero(new_pdcxt, sizeof(PartitionDescData));
    partdesc->nparts = nparts;
    /* If there are no partitions, the rest of the partdesc can stay zero */
    if (nparts > 0)
    {
        oldcxt = MemoryContextSwitchTo(new_pdcxt);
        partdesc->boundinfo = partition_bounds_copy(boundinfo, key);
        partdesc->oids = (Oid *) palloc(nparts * sizeof(Oid));
        partdesc->is_leaf = (bool *) palloc(nparts * sizeof(bool));

        /*
         * Assign OIDs from the original array into mapped indexes of the
         * result array.  The order of OIDs in the former is defined by the
         * catalog scan that retrieved them, whereas that in the latter is
         * defined by canonicalized representation of the partition bounds.
         * Also save leaf-ness of each partition.
         */
        for (i = 0; i < nparts; i++)
        {
            int         index = mapping[i];

            partdesc->oids[index] = oids[i];
            partdesc->is_leaf[index] = is_leaf[i];
        }
        MemoryContextSwitchTo(oldcxt);
    }

    /*
     * We have a fully valid partdesc ready to store into the relcache.
     * Reparent it so it has the right lifespan.
     */
    MemoryContextSetParent(new_pdcxt, CacheMemoryContext);

    /*
     * But first, a kluge: if there's an old rd_pdcxt, it contains an old
     * partition descriptor that may still be referenced somewhere.  Preserve
     * it, while not leaking it, by reattaching it as a child context of the
     * new rd_pdcxt.  Eventually it will get dropped by either RelationClose
     * or RelationClearRelation.
     */
    if (rel->rd_pdcxt != NULL)
        MemoryContextSetParent(rel->rd_pdcxt, new_pdcxt);
    rel->rd_pdcxt = new_pdcxt;
    rel->rd_partdesc = partdesc;
}

RelationGetPartitionDesc()

PartitionDesc RelationGetPartitionDesc

(

Relation

rel

)

Definition at line 65 of file partdesc.c.

References RelationData::rd_partdesc, RelationData::rd_rel, RelationBuildPartitionDesc(), and unlikely.

Referenced by addFkRecurseReferenced(), addFkRecurseReferencing(), ATExecAttachPartition(), ATExecAttachPartitionIdx(), ATExecDetachPartition(), ATPrepDropNotNull(), check_new_partition_bound(), CreateTrigger(), DefineIndex(), DefineRelation(), EnableDisableTrigger(), get_qual_for_list(), get_qual_for_range(), PartitionDirectoryLookup(), QueuePartitionConstraintValidation(), StorePartitionBound(), and validatePartitionedIndex().

{
    if (rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
        return NULL;

    if (unlikely(rel->rd_partdesc == NULL))
        RelationBuildPartitionDesc(rel);

    return rel->rd_partdesc;
}