LCOV - code coverage report
Current view: top level - src/backend/utils/cache - partcache.c (source / functions) Hit Total Coverage
Test: PostgreSQL 16beta1 Lines: 125 131 95.4 %
Date: 2023-05-31 00:12:04 Functions: 5 5 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * partcache.c
       4             :  *      Support routines for manipulating partition information cached in
       5             :  *      relcache
       6             :  *
       7             :  * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
       8             :  * Portions Copyright (c) 1994, Regents of the University of California
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *        src/backend/utils/cache/partcache.c
      12             :  *
      13             :  *-------------------------------------------------------------------------
      14             : */
      15             : #include "postgres.h"
      16             : 
      17             : #include "access/hash.h"
      18             : #include "access/htup_details.h"
      19             : #include "access/nbtree.h"
      20             : #include "access/relation.h"
      21             : #include "catalog/partition.h"
      22             : #include "catalog/pg_inherits.h"
      23             : #include "catalog/pg_opclass.h"
      24             : #include "catalog/pg_partitioned_table.h"
      25             : #include "miscadmin.h"
      26             : #include "nodes/makefuncs.h"
      27             : #include "nodes/nodeFuncs.h"
      28             : #include "optimizer/optimizer.h"
      29             : #include "partitioning/partbounds.h"
      30             : #include "rewrite/rewriteHandler.h"
      31             : #include "utils/builtins.h"
      32             : #include "utils/datum.h"
      33             : #include "utils/lsyscache.h"
      34             : #include "utils/memutils.h"
      35             : #include "utils/partcache.h"
      36             : #include "utils/rel.h"
      37             : #include "utils/syscache.h"
      38             : 
      39             : 
      40             : static void RelationBuildPartitionKey(Relation relation);
      41             : static List *generate_partition_qual(Relation rel);
      42             : 
      43             : /*
      44             :  * RelationGetPartitionKey -- get partition key, if relation is partitioned
      45             :  *
      46             :  * Note: partition keys are not allowed to change after the partitioned rel
      47             :  * is created.  RelationClearRelation knows this and preserves rd_partkey
      48             :  * across relcache rebuilds, as long as the relation is open.  Therefore,
      49             :  * even though we hand back a direct pointer into the relcache entry, it's
      50             :  * safe for callers to continue to use that pointer as long as they hold
      51             :  * the relation open.
      52             :  */
      53             : PartitionKey
      54      100442 : RelationGetPartitionKey(Relation rel)
      55             : {
      56      100442 :     if (rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
      57          12 :         return NULL;
      58             : 
      59      100430 :     if (unlikely(rel->rd_partkey == NULL))
      60       16118 :         RelationBuildPartitionKey(rel);
      61             : 
      62      100430 :     return rel->rd_partkey;
      63             : }
      64             : 
      65             : /*
      66             :  * RelationBuildPartitionKey
      67             :  *      Build partition key data of relation, and attach to relcache
      68             :  *
      69             :  * Partitioning key data is a complex structure; to avoid complicated logic to
      70             :  * free individual elements whenever the relcache entry is flushed, we give it
      71             :  * its own memory context, a child of CacheMemoryContext, which can easily be
      72             :  * deleted on its own.  To avoid leaking memory in that context in case of an
      73             :  * error partway through this function, the context is initially created as a
      74             :  * child of CurTransactionContext and only re-parented to CacheMemoryContext
      75             :  * at the end, when no further errors are possible.  Also, we don't make this
      76             :  * context the current context except in very brief code sections, out of fear
      77             :  * that some of our callees allocate memory on their own which would be leaked
      78             :  * permanently.
      79             :  */
      80             : static void
      81       16118 : RelationBuildPartitionKey(Relation relation)
      82             : {
      83             :     Form_pg_partitioned_table form;
      84             :     HeapTuple   tuple;
      85             :     bool        isnull;
      86             :     int         i;
      87             :     PartitionKey key;
      88             :     AttrNumber *attrs;
      89             :     oidvector  *opclass;
      90             :     oidvector  *collation;
      91             :     ListCell   *partexprs_item;
      92             :     Datum       datum;
      93             :     MemoryContext partkeycxt,
      94             :                 oldcxt;
      95             :     int16       procnum;
      96             : 
      97       16118 :     tuple = SearchSysCache1(PARTRELID,
      98             :                             ObjectIdGetDatum(RelationGetRelid(relation)));
      99             : 
     100       16118 :     if (!HeapTupleIsValid(tuple))
     101           0 :         elog(ERROR, "cache lookup failed for partition key of relation %u",
     102             :              RelationGetRelid(relation));
     103             : 
     104       16118 :     partkeycxt = AllocSetContextCreate(CurTransactionContext,
     105             :                                        "partition key",
     106             :                                        ALLOCSET_SMALL_SIZES);
     107       16118 :     MemoryContextCopyAndSetIdentifier(partkeycxt,
     108             :                                       RelationGetRelationName(relation));
     109             : 
     110       16118 :     key = (PartitionKey) MemoryContextAllocZero(partkeycxt,
     111             :                                                 sizeof(PartitionKeyData));
     112             : 
     113             :     /* Fixed-length attributes */
     114       16118 :     form = (Form_pg_partitioned_table) GETSTRUCT(tuple);
     115       16118 :     key->strategy = form->partstrat;
     116       16118 :     key->partnatts = form->partnatts;
     117             : 
     118             :     /* Validate partition strategy code */
     119       16118 :     if (key->strategy != PARTITION_STRATEGY_LIST &&
     120        8450 :         key->strategy != PARTITION_STRATEGY_RANGE &&
     121         842 :         key->strategy != PARTITION_STRATEGY_HASH)
     122           0 :         elog(ERROR, "invalid partition strategy \"%c\"", key->strategy);
     123             : 
     124             :     /*
     125             :      * We can rely on the first variable-length attribute being mapped to the
     126             :      * relevant field of the catalog's C struct, because all previous
     127             :      * attributes are non-nullable and fixed-length.
     128             :      */
     129       16118 :     attrs = form->partattrs.values;
     130             : 
     131             :     /* But use the hard way to retrieve further variable-length attributes */
     132             :     /* Operator class */
     133       16118 :     datum = SysCacheGetAttrNotNull(PARTRELID, tuple,
     134             :                                    Anum_pg_partitioned_table_partclass);
     135       16118 :     opclass = (oidvector *) DatumGetPointer(datum);
     136             : 
     137             :     /* Collation */
     138       16118 :     datum = SysCacheGetAttrNotNull(PARTRELID, tuple,
     139             :                                    Anum_pg_partitioned_table_partcollation);
     140       16118 :     collation = (oidvector *) DatumGetPointer(datum);
     141             : 
     142             :     /* Expressions */
     143       16118 :     datum = SysCacheGetAttr(PARTRELID, tuple,
     144             :                             Anum_pg_partitioned_table_partexprs, &isnull);
     145       16118 :     if (!isnull)
     146             :     {
     147             :         char       *exprString;
     148             :         Node       *expr;
     149             : 
     150         950 :         exprString = TextDatumGetCString(datum);
     151         950 :         expr = stringToNode(exprString);
     152         950 :         pfree(exprString);
     153             : 
     154             :         /*
     155             :          * Run the expressions through const-simplification since the planner
     156             :          * will be comparing them to similarly-processed qual clause operands,
     157             :          * and may fail to detect valid matches without this step; fix
     158             :          * opfuncids while at it.  We don't need to bother with
     159             :          * canonicalize_qual() though, because partition expressions should be
     160             :          * in canonical form already (ie, no need for OR-merging or constant
     161             :          * elimination).
     162             :          */
     163         950 :         expr = eval_const_expressions(NULL, expr);
     164         950 :         fix_opfuncids(expr);
     165             : 
     166         950 :         oldcxt = MemoryContextSwitchTo(partkeycxt);
     167         950 :         key->partexprs = (List *) copyObject(expr);
     168         950 :         MemoryContextSwitchTo(oldcxt);
     169             :     }
     170             : 
     171             :     /* Allocate assorted arrays in the partkeycxt, which we'll fill below */
     172       16118 :     oldcxt = MemoryContextSwitchTo(partkeycxt);
     173       16118 :     key->partattrs = (AttrNumber *) palloc0(key->partnatts * sizeof(AttrNumber));
     174       16118 :     key->partopfamily = (Oid *) palloc0(key->partnatts * sizeof(Oid));
     175       16118 :     key->partopcintype = (Oid *) palloc0(key->partnatts * sizeof(Oid));
     176       16118 :     key->partsupfunc = (FmgrInfo *) palloc0(key->partnatts * sizeof(FmgrInfo));
     177             : 
     178       16118 :     key->partcollation = (Oid *) palloc0(key->partnatts * sizeof(Oid));
     179       16118 :     key->parttypid = (Oid *) palloc0(key->partnatts * sizeof(Oid));
     180       16118 :     key->parttypmod = (int32 *) palloc0(key->partnatts * sizeof(int32));
     181       16118 :     key->parttyplen = (int16 *) palloc0(key->partnatts * sizeof(int16));
     182       16118 :     key->parttypbyval = (bool *) palloc0(key->partnatts * sizeof(bool));
     183       16118 :     key->parttypalign = (char *) palloc0(key->partnatts * sizeof(char));
     184       16118 :     key->parttypcoll = (Oid *) palloc0(key->partnatts * sizeof(Oid));
     185       16118 :     MemoryContextSwitchTo(oldcxt);
     186             : 
     187             :     /* determine support function number to search for */
     188       16118 :     procnum = (key->strategy == PARTITION_STRATEGY_HASH) ?
     189             :         HASHEXTENDED_PROC : BTORDER_PROC;
     190             : 
     191             :     /* Copy partattrs and fill other per-attribute info */
     192       16118 :     memcpy(key->partattrs, attrs, key->partnatts * sizeof(int16));
     193       16118 :     partexprs_item = list_head(key->partexprs);
     194       33900 :     for (i = 0; i < key->partnatts; i++)
     195             :     {
     196       17782 :         AttrNumber  attno = key->partattrs[i];
     197             :         HeapTuple   opclasstup;
     198             :         Form_pg_opclass opclassform;
     199             :         Oid         funcid;
     200             : 
     201             :         /* Collect opfamily information */
     202       17782 :         opclasstup = SearchSysCache1(CLAOID,
     203             :                                      ObjectIdGetDatum(opclass->values[i]));
     204       17782 :         if (!HeapTupleIsValid(opclasstup))
     205           0 :             elog(ERROR, "cache lookup failed for opclass %u", opclass->values[i]);
     206             : 
     207       17782 :         opclassform = (Form_pg_opclass) GETSTRUCT(opclasstup);
     208       17782 :         key->partopfamily[i] = opclassform->opcfamily;
     209       17782 :         key->partopcintype[i] = opclassform->opcintype;
     210             : 
     211             :         /* Get a support function for the specified opfamily and datatypes */
     212       17782 :         funcid = get_opfamily_proc(opclassform->opcfamily,
     213             :                                    opclassform->opcintype,
     214             :                                    opclassform->opcintype,
     215             :                                    procnum);
     216       17782 :         if (!OidIsValid(funcid))
     217           0 :             ereport(ERROR,
     218             :                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     219             :                      errmsg("operator class \"%s\" of access method %s is missing support function %d for type %s",
     220             :                             NameStr(opclassform->opcname),
     221             :                             (key->strategy == PARTITION_STRATEGY_HASH) ?
     222             :                             "hash" : "btree",
     223             :                             procnum,
     224             :                             format_type_be(opclassform->opcintype))));
     225             : 
     226       17782 :         fmgr_info_cxt(funcid, &key->partsupfunc[i], partkeycxt);
     227             : 
     228             :         /* Collation */
     229       17782 :         key->partcollation[i] = collation->values[i];
     230             : 
     231             :         /* Collect type information */
     232       17782 :         if (attno != 0)
     233             :         {
     234       16760 :             Form_pg_attribute att = TupleDescAttr(relation->rd_att, attno - 1);
     235             : 
     236       16760 :             key->parttypid[i] = att->atttypid;
     237       16760 :             key->parttypmod[i] = att->atttypmod;
     238       16760 :             key->parttypcoll[i] = att->attcollation;
     239             :         }
     240             :         else
     241             :         {
     242        1022 :             if (partexprs_item == NULL)
     243           0 :                 elog(ERROR, "wrong number of partition key expressions");
     244             : 
     245        1022 :             key->parttypid[i] = exprType(lfirst(partexprs_item));
     246        1022 :             key->parttypmod[i] = exprTypmod(lfirst(partexprs_item));
     247        1022 :             key->parttypcoll[i] = exprCollation(lfirst(partexprs_item));
     248             : 
     249        1022 :             partexprs_item = lnext(key->partexprs, partexprs_item);
     250             :         }
     251       17782 :         get_typlenbyvalalign(key->parttypid[i],
     252       17782 :                              &key->parttyplen[i],
     253       17782 :                              &key->parttypbyval[i],
     254       17782 :                              &key->parttypalign[i]);
     255             : 
     256       17782 :         ReleaseSysCache(opclasstup);
     257             :     }
     258             : 
     259       16118 :     ReleaseSysCache(tuple);
     260             : 
     261             :     /* Assert that we're not leaking any old data during assignments below */
     262             :     Assert(relation->rd_partkeycxt == NULL);
     263             :     Assert(relation->rd_partkey == NULL);
     264             : 
     265             :     /*
     266             :      * Success --- reparent our context and make the relcache point to the
     267             :      * newly constructed key
     268             :      */
     269       16118 :     MemoryContextSetParent(partkeycxt, CacheMemoryContext);
     270       16118 :     relation->rd_partkeycxt = partkeycxt;
     271       16118 :     relation->rd_partkey = key;
     272       16118 : }
     273             : 
     274             : /*
     275             :  * RelationGetPartitionQual
     276             :  *
     277             :  * Returns a list of partition quals
     278             :  */
     279             : List *
     280       22088 : RelationGetPartitionQual(Relation rel)
     281             : {
     282             :     /* Quick exit */
     283       22088 :     if (!rel->rd_rel->relispartition)
     284       13482 :         return NIL;
     285             : 
     286        8606 :     return generate_partition_qual(rel);
     287             : }
     288             : 
     289             : /*
     290             :  * get_partition_qual_relid
     291             :  *
     292             :  * Returns an expression tree describing the passed-in relation's partition
     293             :  * constraint.
     294             :  *
     295             :  * If the relation is not found, or is not a partition, or there is no
     296             :  * partition constraint, return NULL.  We must guard against the first two
     297             :  * cases because this supports a SQL function that could be passed any OID.
     298             :  * The last case can happen even if relispartition is true, when a default
     299             :  * partition is the only partition.
     300             :  */
     301             : Expr *
     302         242 : get_partition_qual_relid(Oid relid)
     303             : {
     304         242 :     Expr       *result = NULL;
     305             : 
     306             :     /* Do the work only if this relation exists and is a partition. */
     307         242 :     if (get_rel_relispartition(relid))
     308             :     {
     309         242 :         Relation    rel = relation_open(relid, AccessShareLock);
     310             :         List       *and_args;
     311             : 
     312         242 :         and_args = generate_partition_qual(rel);
     313             : 
     314             :         /* Convert implicit-AND list format to boolean expression */
     315         242 :         if (and_args == NIL)
     316          18 :             result = NULL;
     317         224 :         else if (list_length(and_args) > 1)
     318         212 :             result = makeBoolExpr(AND_EXPR, and_args, -1);
     319             :         else
     320          12 :             result = linitial(and_args);
     321             : 
     322             :         /* Keep the lock, to allow safe deparsing against the rel by caller. */
     323         242 :         relation_close(rel, NoLock);
     324             :     }
     325             : 
     326         242 :     return result;
     327             : }
     328             : 
     329             : /*
     330             :  * generate_partition_qual
     331             :  *
     332             :  * Generate partition predicate from rel's partition bound expression. The
     333             :  * function returns a NIL list if there is no predicate.
     334             :  *
     335             :  * We cache a copy of the result in the relcache entry, after constructing
     336             :  * it using the caller's context.  This approach avoids leaking any data
     337             :  * into long-lived cache contexts, especially if we fail partway through.
     338             :  */
     339             : static List *
     340        9414 : generate_partition_qual(Relation rel)
     341             : {
     342             :     HeapTuple   tuple;
     343             :     MemoryContext oldcxt;
     344             :     Datum       boundDatum;
     345             :     bool        isnull;
     346        9414 :     List       *my_qual = NIL,
     347        9414 :                *result = NIL;
     348             :     Oid         parentrelid;
     349             :     Relation    parent;
     350             : 
     351             :     /* Guard against stack overflow due to overly deep partition tree */
     352        9414 :     check_stack_depth();
     353             : 
     354             :     /* If we already cached the result, just return a copy */
     355        9414 :     if (rel->rd_partcheckvalid)
     356        6224 :         return copyObject(rel->rd_partcheck);
     357             : 
     358             :     /*
     359             :      * Grab at least an AccessShareLock on the parent table.  Must do this
     360             :      * even if the partition has been partially detached, because transactions
     361             :      * concurrent with the detach might still be trying to use a partition
     362             :      * descriptor that includes it.
     363             :      */
     364        3190 :     parentrelid = get_partition_parent(RelationGetRelid(rel), true);
     365        3190 :     parent = relation_open(parentrelid, AccessShareLock);
     366             : 
     367             :     /* Get pg_class.relpartbound */
     368        3190 :     tuple = SearchSysCache1(RELOID, RelationGetRelid(rel));
     369        3190 :     if (!HeapTupleIsValid(tuple))
     370           0 :         elog(ERROR, "cache lookup failed for relation %u",
     371             :              RelationGetRelid(rel));
     372             : 
     373        3190 :     boundDatum = SysCacheGetAttr(RELOID, tuple,
     374             :                                  Anum_pg_class_relpartbound,
     375             :                                  &isnull);
     376        3190 :     if (!isnull)
     377             :     {
     378             :         PartitionBoundSpec *bound;
     379             : 
     380        3178 :         bound = castNode(PartitionBoundSpec,
     381             :                          stringToNode(TextDatumGetCString(boundDatum)));
     382             : 
     383        3178 :         my_qual = get_qual_from_partbound(parent, bound);
     384             :     }
     385             : 
     386        3190 :     ReleaseSysCache(tuple);
     387             : 
     388             :     /* Add the parent's quals to the list (if any) */
     389        3190 :     if (parent->rd_rel->relispartition)
     390         566 :         result = list_concat(generate_partition_qual(parent), my_qual);
     391             :     else
     392        2624 :         result = my_qual;
     393             : 
     394             :     /*
     395             :      * Change Vars to have partition's attnos instead of the parent's. We do
     396             :      * this after we concatenate the parent's quals, because we want every Var
     397             :      * in it to bear this relation's attnos. It's safe to assume varno = 1
     398             :      * here.
     399             :      */
     400        3190 :     result = map_partition_varattnos(result, 1, rel, parent);
     401             : 
     402             :     /* Assert that we're not leaking any old data during assignments below */
     403             :     Assert(rel->rd_partcheckcxt == NULL);
     404             :     Assert(rel->rd_partcheck == NIL);
     405             : 
     406             :     /*
     407             :      * Save a copy in the relcache.  The order of these operations is fairly
     408             :      * critical to avoid memory leaks and ensure that we don't leave a corrupt
     409             :      * relcache entry if we fail partway through copyObject.
     410             :      *
     411             :      * If, as is definitely possible, the partcheck list is NIL, then we do
     412             :      * not need to make a context to hold it.
     413             :      */
     414        3190 :     if (result != NIL)
     415             :     {
     416        3132 :         rel->rd_partcheckcxt = AllocSetContextCreate(CacheMemoryContext,
     417             :                                                      "partition constraint",
     418             :                                                      ALLOCSET_SMALL_SIZES);
     419        3132 :         MemoryContextCopyAndSetIdentifier(rel->rd_partcheckcxt,
     420             :                                           RelationGetRelationName(rel));
     421        3132 :         oldcxt = MemoryContextSwitchTo(rel->rd_partcheckcxt);
     422        3132 :         rel->rd_partcheck = copyObject(result);
     423        3132 :         MemoryContextSwitchTo(oldcxt);
     424             :     }
     425             :     else
     426          58 :         rel->rd_partcheck = NIL;
     427        3190 :     rel->rd_partcheckvalid = true;
     428             : 
     429             :     /* Keep the parent locked until commit */
     430        3190 :     relation_close(parent, NoLock);
     431             : 
     432             :     /* Return the working copy to the caller */
     433        3190 :     return result;
     434             : }

Generated by: LCOV version 1.14