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-2025, 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
37static 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 */
77static 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
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))
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 */
276List *
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 */
298Expr *
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 {
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. */
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 */
336static 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",
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:703
#define Assert(condition)
Definition: c.h:815
int16_t int16
Definition: c.h:483
int32_t int32
Definition: c.h:484
#define unlikely(x)
Definition: c.h:333
#define OidIsValid(objectId)
Definition: c.h:732
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
static void * GETSTRUCT(const HeapTupleData *tuple)
Definition: htup_details.h:728
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:2054
void get_typlenbyvalalign(Oid typid, int16 *typlen, bool *typbyval, char *typalign)
Definition: lsyscache.c:2298
Oid get_opfamily_proc(Oid opfamily, Oid lefttype, Oid righttype, int16 procnum)
Definition: lsyscache.c:797
Expr * makeBoolExpr(BoolExprType boolop, List *args, int location)
Definition: makefuncs.c:373
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:1215
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
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:712
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:42
int32 exprTypmod(const Node *expr)
Definition: nodeFuncs.c:301
Oid exprCollation(const Node *expr)
Definition: nodeFuncs.c:821
void fix_opfuncids(Node *node)
Definition: nodeFuncs.c:1841
#define copyObject(obj)
Definition: nodes.h:224
#define castNode(_type_, nodeptr)
Definition: nodes.h:176
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
@ PARTITION_STRATEGY_HASH
Definition: parsenodes.h:885
@ PARTITION_STRATEGY_LIST
Definition: parsenodes.h:883
@ PARTITION_STRATEGY_RANGE
Definition: parsenodes.h:884
List * get_qual_from_partbound(Relation parent, PartitionBoundSpec *spec)
Definition: partbounds.c:249
List * RelationGetPartitionQual(Relation rel)
Definition: partcache.c:277
static List * generate_partition_qual(Relation rel)
Definition: partcache.c:337
static void RelationBuildPartitionKey(Relation relation)
Definition: partcache.c:78
Expr * get_partition_qual_relid(Oid relid)
Definition: partcache.c:299
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:200
#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
#define linitial(l)
Definition: pg_list.h:178
static ListCell * list_head(const List *l)
Definition: pg_list.h:128
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
uintptr_t Datum
Definition: postgres.h:69
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:257
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:317
unsigned int Oid
Definition: postgres_ext.h:32
@ AND_EXPR
Definition: primnodes.h:948
void * stringToNode(const char *str)
Definition: read.c:90
#define RelationGetRelid(relation)
Definition: rel.h:506
#define RelationGetRelationName(relation)
Definition: rel.h:540
void relation_close(Relation relation, LOCKMODE lockmode)
Definition: relation.c:205
Relation relation_open(Oid relationId, LOCKMODE lockmode)
Definition: relation.c:47
void check_stack_depth(void)
Definition: stack_depth.c:95
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:683
Oid values[FLEXIBLE_ARRAY_MEMBER]
Definition: c.h:690
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:600
Datum SysCacheGetAttrNotNull(int cacheId, HeapTuple tup, AttrNumber attributeNumber)
Definition: syscache.c:631
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
Definition: tupdesc.h:153