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