partdesc.c File Reference

#include "postgres.h"
#include "access/genam.h"
#include "access/htup_details.h"
#include "access/table.h"
#include "catalog/partition.h"
#include "catalog/pg_inherits.h"
#include "partitioning/partbounds.h"
#include "partitioning/partdesc.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/snapmgr.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 PartitionDesc	RelationBuildPartitionDesc (Relation rel, bool omit_detached)
PartitionDesc	RelationGetPartitionDesc (Relation rel, bool omit_detached)
PartitionDirectory	CreatePartitionDirectory (MemoryContext mcxt, bool omit_detached)
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,
		bool	omit_detached
	)

Definition at line 409 of file partdesc.c.

{
    MemoryContext oldcontext = MemoryContextSwitchTo(mcxt);
    PartitionDirectory pdir;
    HASHCTL     ctl;
 
    pdir = palloc(sizeof(PartitionDirectoryData));
    pdir->pdir_mcxt = mcxt;
 
    ctl.keysize = sizeof(Oid);
    ctl.entrysize = sizeof(PartitionDirectoryEntry);
    ctl.hcxt = mcxt;
 
    pdir->pdir_hash = hash_create("partition directory", 256, &ctl,
                                  HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
    pdir->omit_detached = omit_detached;
 
    MemoryContextSwitchTo(oldcontext);
    return pdir;
}

References ctl, HASH_BLOBS, HASH_CONTEXT, hash_create(), HASH_ELEM, MemoryContextSwitchTo(), PartitionDirectoryData::omit_detached, palloc(), PartitionDirectoryData::pdir_hash, and PartitionDirectoryData::pdir_mcxt.

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

DestroyPartitionDirectory()

void DestroyPartitionDirectory

(

PartitionDirectory

pdir

)

Definition at line 470 of file partdesc.c.

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

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

Referenced by FreeExecutorState(), and standard_planner().

get_default_oid_from_partdesc()

Oid get_default_oid_from_partdesc

(

PartitionDesc

partdesc

)

Definition at line 487 of file partdesc.c.

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

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

Referenced by ATExecAttachPartition(), ATExecDetachPartition(), ATExecMergePartitions(), ATExecSplitPartition(), check_partitions_for_split(), DefineRelation(), StorePartitionBound(), and transformPartitionCmdForMerge().

PartitionDirectoryLookup()

PartitionDesc PartitionDirectoryLookup	(	PartitionDirectory	pdir,
		Relation	rel
	)

Definition at line 442 of file partdesc.c.

{
    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, pdir->omit_detached);
        Assert(pde->pd != NULL);
    }
    return pde->pd;
}

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

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

RelationBuildPartitionDesc()

static PartitionDesc RelationBuildPartitionDesc ( Relation  rel, bool  omit_detached  )

static

Definition at line 134 of file partdesc.c.

{
    PartitionDesc partdesc;
    PartitionBoundInfo boundinfo = NULL;
    List       *inhoids;
    PartitionBoundSpec **boundspecs = NULL;
    Oid        *oids = NULL;
    bool       *is_leaf = NULL;
    bool        detached_exist;
    bool        is_omit;
    TransactionId detached_xmin;
    ListCell   *cell;
    int         i,
                nparts;
    bool        retried = false;
    PartitionKey key = RelationGetPartitionKey(rel);
    MemoryContext new_pdcxt;
    MemoryContext oldcxt;
    int        *mapping;
 
retry:
 
    /*
     * 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
     * or removed concurrently, whatever this function returns will be
     * accurate as of some well-defined point in time.
     */
    detached_exist = false;
    detached_xmin = InvalidTransactionId;
    inhoids = find_inheritance_children_extended(RelationGetRelid(rel),
                                                 omit_detached, NoLock,
                                                 &detached_exist,
                                                 &detached_xmin);
 
    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, ObjectIdGetDatum(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);
        }
 
        /*
         * Two problems are possible here.  First, a concurrent ATTACH
         * PARTITION might be in the process of adding a new partition, but
         * the syscache doesn't have it, or its copy of it does not yet have
         * its relpartbound set.  We cannot just AcceptInvalidationMessages(),
         * because the other process might have already removed itself from
         * the ProcArray but not yet added its invalidation messages to the
         * shared queue.  We solve this problem by reading pg_class directly
         * for the desired tuple.
         *
         * The other problem is that DETACH CONCURRENTLY is in the process of
         * removing a partition, which happens in two steps: first it marks it
         * as "detach pending", commits, then unsets relpartbound.  If
         * find_inheritance_children_extended included that partition but we
         * below we see that DETACH CONCURRENTLY has reset relpartbound for
         * it, we'd see an inconsistent view.  (The inconsistency is seen
         * because table_open below reads invalidation messages.)  We protect
         * against this by retrying find_inheritance_children_extended().
         */
        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);
 
            /*
             * If we still don't get a relpartbound value, then it must be
             * because of DETACH CONCURRENTLY.  Restart from the top, as
             * explained above.  We only do this once, for two reasons: first,
             * only one DETACH CONCURRENTLY session could affect us at a time,
             * since each of them would have to wait for the snapshot under
             * which this is running; and second, to avoid possible infinite
             * loops in case of catalog corruption.
             *
             * Note that the current memory context is short-lived enough, so
             * we needn't worry about memory leaks here.
             */
            if (!boundspec && !retried)
            {
                AcceptInvalidationMessages();
                retried = true;
                goto retry;
            }
        }
 
        /* 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;
    partdesc->detached_exist = detached_exist;
    /* 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);
 
        /* Initialize caching fields for speeding up ExecFindPartition */
        partdesc->last_found_datum_index = -1;
        partdesc->last_found_part_index = -1;
        partdesc->last_found_count = 0;
 
        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);
    }
 
    /*
     * Are we working with the partdesc that omits the detached partition, or
     * the one that includes it?
     *
     * Note that if a partition was found by the catalog's scan to have been
     * detached, but the pg_inherit tuple saying so was not visible to the
     * active snapshot (find_inheritance_children_extended will not have set
     * detached_xmin in that case), we consider there to be no "omittable"
     * detached partitions.
     */
    is_omit = omit_detached && detached_exist && ActiveSnapshotSet() &&
        TransactionIdIsValid(detached_xmin);
 
    /*
     * We have a fully valid partdesc.  Reparent it so that it has the right
     * lifespan.
     */
    MemoryContextSetParent(new_pdcxt, CacheMemoryContext);
 
    /*
     * Store it into relcache.
     *
     * But first, a kluge: if there's an old context for this type of
     * descriptor, 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 one.  Eventually it will
     * get dropped by either RelationClose or RelationClearRelation. (We keep
     * the regular partdesc in rd_pdcxt, and the partdesc-excluding-
     * detached-partitions in rd_pddcxt.)
     */
    if (is_omit)
    {
        if (rel->rd_pddcxt != NULL)
            MemoryContextSetParent(rel->rd_pddcxt, new_pdcxt);
        rel->rd_pddcxt = new_pdcxt;
        rel->rd_partdesc_nodetached = partdesc;
 
        /*
         * For partdescs built excluding detached partitions, which we save
         * separately, we also record the pg_inherits.xmin of the detached
         * partition that was omitted; this informs a future potential user of
         * such a cached partdesc to only use it after cross-checking that the
         * xmin is indeed visible to the snapshot it is going to be working
         * with.
         */
        Assert(TransactionIdIsValid(detached_xmin));
        rel->rd_partdesc_nodetached_xmin = detached_xmin;
    }
    else
    {
        if (rel->rd_pdcxt != NULL)
            MemoryContextSetParent(rel->rd_pdcxt, new_pdcxt);
        rel->rd_pdcxt = new_pdcxt;
        rel->rd_partdesc = partdesc;
    }
 
    return partdesc;
}

References AcceptInvalidationMessages(), AccessShareLock, ActiveSnapshotSet(), ALLOCSET_SMALL_SIZES, AllocSetContextCreate, Assert, PartitionDescData::boundinfo, BTEqualStrategyNumber, CacheMemoryContext, CurTransactionContext, PartitionDescData::detached_exist, elog, ERROR, find_inheritance_children_extended(), get_default_partition_oid(), get_rel_relkind(), heap_getattr(), HeapTupleIsValid, i, InvalidTransactionId, PartitionBoundSpec::is_default, PartitionDescData::is_leaf, IsA, sort-test::key, PartitionDescData::last_found_count, PartitionDescData::last_found_datum_index, PartitionDescData::last_found_part_index, 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_partdesc_nodetached, RelationData::rd_partdesc_nodetached_xmin, RelationData::rd_pdcxt, RelationData::rd_pddcxt, RelationGetDescr, RelationGetPartitionKey(), RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), ScanKeyInit(), SearchSysCache1(), stringToNode(), SysCacheGetAttr(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TextDatumGetCString, and TransactionIdIsValid.

Referenced by RelationGetPartitionDesc().

RelationGetPartitionDesc()

PartitionDesc RelationGetPartitionDesc	(	Relation	rel,
		bool	omit_detached
	)

Definition at line 71 of file partdesc.c.

{
    Assert(rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
    /*
     * If relcache has a partition descriptor, use that.  However, we can only
     * do so when we are asked to include all partitions including detached;
     * and also when we know that there are no detached partitions.
     *
     * If there is no active snapshot, detached partitions aren't omitted
     * either, so we can use the cached descriptor too in that case.
     */
    if (likely(rel->rd_partdesc &&
               (!rel->rd_partdesc->detached_exist || !omit_detached ||
                !ActiveSnapshotSet())))
        return rel->rd_partdesc;
 
    /*
     * If we're asked to omit detached partitions, we may be able to use a
     * cached descriptor too.  We determine that based on the pg_inherits.xmin
     * that was saved alongside that descriptor: if the xmin that was not in
     * progress for that active snapshot is also not in progress for the
     * current active snapshot, then we can use it.  Otherwise build one from
     * scratch.
     */
    if (omit_detached &&
        rel->rd_partdesc_nodetached &&
        ActiveSnapshotSet())
    {
        Snapshot    activesnap;
 
        Assert(TransactionIdIsValid(rel->rd_partdesc_nodetached_xmin));
        activesnap = GetActiveSnapshot();
 
        if (!XidInMVCCSnapshot(rel->rd_partdesc_nodetached_xmin, activesnap))
            return rel->rd_partdesc_nodetached;
    }
 
    return RelationBuildPartitionDesc(rel, omit_detached);
}

References ActiveSnapshotSet(), Assert, PartitionDescData::detached_exist, GetActiveSnapshot(), likely, RelationData::rd_partdesc, RelationData::rd_partdesc_nodetached, RelationData::rd_partdesc_nodetached_xmin, RelationData::rd_rel, RelationBuildPartitionDesc(), TransactionIdIsValid, and XidInMVCCSnapshot().

Referenced by addFkRecurseReferenced(), addFkRecurseReferencing(), ATExecAttachPartition(), ATExecAttachPartitionIdx(), ATExecDetachPartition(), ATExecMergePartitions(), ATExecSplitPartition(), ATPrepDropNotNull(), check_new_partition_bound(), check_parent_values_in_new_partitions(), check_partition_bounds_for_split_list(), check_partitions_for_split(), CreateTriggerFiringOn(), DefineIndex(), DefineRelation(), EnableDisableTrigger(), get_qual_for_list(), get_qual_for_range(), PartitionDirectoryLookup(), QueuePartitionConstraintValidation(), renametrig(), renametrig_partition(), StorePartitionBound(), transformPartitionCmdForMerge(), and validatePartitionedIndex().