partition.c File Reference

#include "postgres.h"
#include "access/attmap.h"
#include "access/genam.h"
#include "access/htup_details.h"
#include "access/sysattr.h"
#include "access/table.h"
#include "catalog/indexing.h"
#include "catalog/partition.h"
#include "catalog/pg_inherits.h"
#include "catalog/pg_partitioned_table.h"
#include "nodes/makefuncs.h"
#include "optimizer/optimizer.h"
#include "partitioning/partbounds.h"
#include "rewrite/rewriteManip.h"
#include "utils/fmgroids.h"
#include "utils/partcache.h"
#include "utils/rel.h"
#include "utils/syscache.h"

Include dependency graph for partition.c:

Go to the source code of this file.

Functions
static Oid	get_partition_parent_worker (Relation inhRel, Oid relid, bool *detach_pending)
static void	get_partition_ancestors_worker (Relation inhRel, Oid relid, List **ancestors)
Oid	get_partition_parent (Oid relid, bool even_if_detached)
List *	get_partition_ancestors (Oid relid)
Oid	index_get_partition (Relation partition, Oid indexId)
List *	map_partition_varattnos (List *expr, int fromrel_varno, Relation to_rel, Relation from_rel)
bool	has_partition_attrs (Relation rel, Bitmapset *attnums, bool *used_in_expr)
Oid	get_default_partition_oid (Oid parentId)
void	update_default_partition_oid (Oid parentId, Oid defaultPartId)
List *	get_proposed_default_constraint (List *new_part_constraints)

Function Documentation

get_default_partition_oid()

Oid get_default_partition_oid

(

Oid

parentId

)

Definition at line 314 of file partition.c.

{
    HeapTuple   tuple;
    Oid         defaultPartId = InvalidOid;
 
    tuple = SearchSysCache1(PARTRELID, ObjectIdGetDatum(parentId));
 
    if (HeapTupleIsValid(tuple))
    {
        Form_pg_partitioned_table part_table_form;
 
        part_table_form = (Form_pg_partitioned_table) GETSTRUCT(tuple);
        defaultPartId = part_table_form->partdefid;
        ReleaseSysCache(tuple);
    }
 
    return defaultPartId;
}

References GETSTRUCT, HeapTupleIsValid, InvalidOid, ObjectIdGetDatum(), PARTRELID, ReleaseSysCache(), and SearchSysCache1().

Referenced by heap_drop_with_catalog(), and RelationBuildPartitionDesc().

get_partition_ancestors()

List* get_partition_ancestors

(

Oid

relid

)

Definition at line 133 of file partition.c.

{
    List       *result = NIL;
    Relation    inhRel;
 
    inhRel = table_open(InheritsRelationId, AccessShareLock);
 
    get_partition_ancestors_worker(inhRel, relid, &result);
 
    table_close(inhRel, AccessShareLock);
 
    return result;
}

References AccessShareLock, get_partition_ancestors_worker(), NIL, table_close(), and table_open().

Referenced by ExecGetAncestorResultRels(), ExecInitPartitionInfo(), filter_partitions(), get_rel_sync_entry(), has_partition_ancestor_privs(), index_concurrently_swap(), pg_partition_ancestors(), pg_partition_root(), pg_partition_tree(), and RelationBuildPublicationDesc().

get_partition_ancestors_worker()

static void get_partition_ancestors_worker ( Relation  inhRel, Oid  relid, List **  ancestors  )

static

Definition at line 152 of file partition.c.

{
    Oid         parentOid;
    bool        detach_pending;
 
    /*
     * Recursion ends at the topmost level, ie., when there's no parent; also
     * when the partition is being detached.
     */
    parentOid = get_partition_parent_worker(inhRel, relid, &detach_pending);
    if (parentOid == InvalidOid || detach_pending)
        return;
 
    *ancestors = lappend_oid(*ancestors, parentOid);
    get_partition_ancestors_worker(inhRel, parentOid, ancestors);
}

References get_partition_parent_worker(), InvalidOid, and lappend_oid().

Referenced by get_partition_ancestors().

get_partition_parent()

Oid get_partition_parent	(	Oid	relid,
		bool	even_if_detached
	)

Definition at line 54 of file partition.c.

{
    Relation    catalogRelation;
    Oid         result;
    bool        detach_pending;
 
    catalogRelation = table_open(InheritsRelationId, AccessShareLock);
 
    result = get_partition_parent_worker(catalogRelation, relid,
                                         &detach_pending);
 
    if (!OidIsValid(result))
        elog(ERROR, "could not find tuple for parent of relation %u", relid);
 
    if (detach_pending && !even_if_detached)
        elog(ERROR, "relation %u has no parent because it's being detached",
             relid);
 
    table_close(catalogRelation, AccessShareLock);
 
    return result;
}

References AccessShareLock, elog(), ERROR, get_partition_parent_worker(), OidIsValid, table_close(), and table_open().

Referenced by ATExecAttachPartitionIdx(), ATExecDropNotNull(), DetachPartitionFinalize(), generate_partition_qual(), heap_drop_with_catalog(), index_get_partition(), RangeVarCallbackForDropRelation(), renametrig(), and validatePartitionedIndex().

get_partition_parent_worker()

static Oid get_partition_parent_worker ( Relation  inhRel, Oid  relid, bool *  detach_pending  )

static

Definition at line 86 of file partition.c.

{
    SysScanDesc scan;
    ScanKeyData key[2];
    Oid         result = InvalidOid;
    HeapTuple   tuple;
 
    *detach_pending = false;
 
    ScanKeyInit(&key[0],
                Anum_pg_inherits_inhrelid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(relid));
    ScanKeyInit(&key[1],
                Anum_pg_inherits_inhseqno,
                BTEqualStrategyNumber, F_INT4EQ,
                Int32GetDatum(1));
 
    scan = systable_beginscan(inhRel, InheritsRelidSeqnoIndexId, true,
                              NULL, 2, key);
    tuple = systable_getnext(scan);
    if (HeapTupleIsValid(tuple))
    {
        Form_pg_inherits form = (Form_pg_inherits) GETSTRUCT(tuple);
 
        /* Let caller know of partition being detached */
        if (form->inhdetachpending)
            *detach_pending = true;
        result = form->inhparent;
    }
 
    systable_endscan(scan);
 
    return result;
}

References BTEqualStrategyNumber, GETSTRUCT, HeapTupleIsValid, Int32GetDatum(), InvalidOid, sort-test::key, ObjectIdGetDatum(), ScanKeyInit(), systable_beginscan(), systable_endscan(), and systable_getnext().

Referenced by get_partition_ancestors_worker(), and get_partition_parent().

get_proposed_default_constraint()

List* get_proposed_default_constraint

(

List *

new_part_constraints

)

Definition at line 369 of file partition.c.

{
    Expr       *defPartConstraint;
 
    defPartConstraint = make_ands_explicit(new_part_constraints);
 
    /*
     * Derive the partition constraints of default partition by negating the
     * given partition constraints. The partition constraint never evaluates
     * to NULL, so negating it like this is safe.
     */
    defPartConstraint = makeBoolExpr(NOT_EXPR,
                                     list_make1(defPartConstraint),
                                     -1);
 
    /* Simplify, to put the negated expression into canonical form */
    defPartConstraint =
        (Expr *) eval_const_expressions(NULL,
                                        (Node *) defPartConstraint);
    defPartConstraint = canonicalize_qual(defPartConstraint, true);
 
    return make_ands_implicit(defPartConstraint);
}

References canonicalize_qual(), eval_const_expressions(), list_make1, make_ands_explicit(), make_ands_implicit(), makeBoolExpr(), and NOT_EXPR.

Referenced by ATExecAttachPartition(), and check_default_partition_contents().

has_partition_attrs()

bool has_partition_attrs	(	Relation	rel,
		Bitmapset *	attnums,
		bool *	used_in_expr
	)

Definition at line 254 of file partition.c.

{
    PartitionKey key;
    int         partnatts;
    List       *partexprs;
    ListCell   *partexprs_item;
    int         i;
 
    if (attnums == NULL || rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
        return false;
 
    key = RelationGetPartitionKey(rel);
    partnatts = get_partition_natts(key);
    partexprs = get_partition_exprs(key);
 
    partexprs_item = list_head(partexprs);
    for (i = 0; i < partnatts; i++)
    {
        AttrNumber  partattno = get_partition_col_attnum(key, i);
 
        if (partattno != 0)
        {
            if (bms_is_member(partattno - FirstLowInvalidHeapAttributeNumber,
                              attnums))
            {
                if (used_in_expr)
                    *used_in_expr = false;
                return true;
            }
        }
        else
        {
            /* Arbitrary expression */
            Node       *expr = (Node *) lfirst(partexprs_item);
            Bitmapset  *expr_attrs = NULL;
 
            /* Find all attributes referenced */
            pull_varattnos(expr, 1, &expr_attrs);
            partexprs_item = lnext(partexprs, partexprs_item);
 
            if (bms_overlap(attnums, expr_attrs))
            {
                if (used_in_expr)
                    *used_in_expr = true;
                return true;
            }
        }
    }
 
    return false;
}

References bms_is_member(), bms_overlap(), FirstLowInvalidHeapAttributeNumber, get_partition_col_attnum(), get_partition_exprs(), get_partition_natts(), i, sort-test::key, lfirst, list_head(), lnext(), pull_varattnos(), RelationData::rd_rel, and RelationGetPartitionKey().

Referenced by ATExecDropColumn(), ATPrepAlterColumnType(), and expand_partitioned_rtentry().

index_get_partition()

Oid index_get_partition	(	Relation	partition,
		Oid	indexId
	)

Definition at line 175 of file partition.c.

{
    List       *idxlist = RelationGetIndexList(partition);
    ListCell   *l;
 
    foreach(l, idxlist)
    {
        Oid         partIdx = lfirst_oid(l);
        HeapTuple   tup;
        Form_pg_class classForm;
        bool        ispartition;
 
        tup = SearchSysCache1(RELOID, ObjectIdGetDatum(partIdx));
        if (!HeapTupleIsValid(tup))
            elog(ERROR, "cache lookup failed for relation %u", partIdx);
        classForm = (Form_pg_class) GETSTRUCT(tup);
        ispartition = classForm->relispartition;
        ReleaseSysCache(tup);
        if (!ispartition)
            continue;
        if (get_partition_parent(partIdx, false) == indexId)
        {
            list_free(idxlist);
            return partIdx;
        }
    }
 
    list_free(idxlist);
    return InvalidOid;
}

References elog(), ERROR, get_partition_parent(), GETSTRUCT, HeapTupleIsValid, InvalidOid, lfirst_oid, list_free(), ObjectIdGetDatum(), RelationGetIndexList(), ReleaseSysCache(), RELOID, and SearchSysCache1().

Referenced by addFkRecurseReferenced(), CloneFkReferenced(), and refuseDupeIndexAttach().

map_partition_varattnos()

List* map_partition_varattnos	(	List *	expr,
		int	fromrel_varno,
		Relation	to_rel,
		Relation	from_rel
	)

Definition at line 221 of file partition.c.

{
    if (expr != NIL)
    {
        AttrMap    *part_attmap;
        bool        found_whole_row;
 
        part_attmap = build_attrmap_by_name(RelationGetDescr(to_rel),
                                            RelationGetDescr(from_rel),
                                            false);
        expr = (List *) map_variable_attnos((Node *) expr,
                                            fromrel_varno, 0,
                                            part_attmap,
                                            RelationGetForm(to_rel)->reltype,
                                            &found_whole_row);
        /* Since we provided a to_rowtype, we may ignore found_whole_row. */
    }
 
    return expr;
}

References build_attrmap_by_name(), map_variable_attnos(), NIL, RelationGetDescr, and RelationGetForm.

Referenced by ATExecAttachPartition(), check_default_partition_contents(), CloneRowTriggersToPartition(), CreateTriggerFiringOn(), generate_partition_qual(), and QueuePartitionConstraintValidation().

update_default_partition_oid()

void update_default_partition_oid	(	Oid	parentId,
		Oid	defaultPartId
	)

Definition at line 339 of file partition.c.

{
    HeapTuple   tuple;
    Relation    pg_partitioned_table;
    Form_pg_partitioned_table part_table_form;
 
    pg_partitioned_table = table_open(PartitionedRelationId, RowExclusiveLock);
 
    tuple = SearchSysCacheCopy1(PARTRELID, ObjectIdGetDatum(parentId));
 
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for partition key of relation %u",
             parentId);
 
    part_table_form = (Form_pg_partitioned_table) GETSTRUCT(tuple);
    part_table_form->partdefid = defaultPartId;
    CatalogTupleUpdate(pg_partitioned_table, &tuple->t_self, tuple);
 
    heap_freetuple(tuple);
    table_close(pg_partitioned_table, RowExclusiveLock);
}

References CatalogTupleUpdate(), elog(), ERROR, GETSTRUCT, heap_freetuple(), HeapTupleIsValid, ObjectIdGetDatum(), PARTRELID, RowExclusiveLock, SearchSysCacheCopy1, HeapTupleData::t_self, table_close(), and table_open().

Referenced by DetachPartitionFinalize(), heap_drop_with_catalog(), and StorePartitionBound().