Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commit5b93123

Browse files
committed
Load relcache entries' partitioning data on-demand, not immediately.
Formerly the rd_partkey and rd_partdesc data structures were alwayspopulated immediately when a relcache entry was built or rebuilt.This patch changes things so that they are populated only when theyare first requested. (Hence, callers *must* now always useRelationGetPartitionKey or RelationGetPartitionDesc; just fetchingthe pointer directly is no longer acceptable.)This seems to have some performance benefits, but the main reason to doit is that it eliminates a recursive-reload failure that occurs if thepartkey or partdesc expressions contain any references to the relation'srowtype (as discovered by Amit Langote). In retrospect, since loadingthese data structures might result in execution of nearly-arbitrary codevia eval_const_expressions, it was a dumb idea to require that to happenduring relcache entry rebuild.Also, fix things so that old copies of a relcache partition descriptorwill be dropped when the cache entry's refcount goes to zero. In theprevious coding it was possible for such copies to survive for thelifetime of the session, as I'd complained of in a previous discussion.(This management technique still isn't perfect, but it's better thanbefore.) Improve the commentary explaining how that works and whyit's safe to hand out direct pointers to these relcache substructures.In passing, improve RelationBuildPartitionDesc by using the samememory-context-parent-swap approach used by RelationBuildPartitionKey,thereby making it less dependent on strong assumptions about whatpartition_bounds_copy does. Avoid doing get_rel_relkind in thecritical section, too.Patch by Amit Langote and Tom Lane; Robert Haas deserves some creditfor prior work in the area, too. Although this is a pre-existingproblem, no back-patch: the patch seems too invasive to be safe toback-patch, and the bug it fixes is a corner case that seemsrelatively unlikely to cause problems in the field.Discussion:https://postgr.es/m/CA+HiwqFUzjfj9HEsJtYWcr1SgQ_=iCAvQ=O2Sx6aQxoDu4OiHw@mail.gmail.comDiscussion:https://postgr.es/m/CA+TgmoY3bRmGB6-DUnoVy5fJoreiBJ43rwMrQRCdPXuKt4Ykaw@mail.gmail.com
1 parent8ce3aa9 commit5b93123

File tree

12 files changed

+186
-121
lines changed

12 files changed

+186
-121
lines changed

‎src/backend/catalog/heap.c

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -83,7 +83,6 @@
8383
#include"utils/inval.h"
8484
#include"utils/lsyscache.h"
8585
#include"utils/partcache.h"
86-
#include"utils/rel.h"
8786
#include"utils/ruleutils.h"
8887
#include"utils/snapmgr.h"
8988
#include"utils/syscache.h"

‎src/backend/commands/indexcmds.c

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -812,7 +812,7 @@ DefineIndex(Oid relationId,
812812
*/
813813
if (partitioned&& (stmt->unique||stmt->primary))
814814
{
815-
PartitionKeykey=rel->rd_partkey;
815+
PartitionKeykey=RelationGetPartitionKey(rel);
816816
inti;
817817

818818
/*

‎src/backend/executor/execPartition.c

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,6 @@
3030
#include"rewrite/rewriteManip.h"
3131
#include"utils/lsyscache.h"
3232
#include"utils/partcache.h"
33-
#include"utils/rel.h"
3433
#include"utils/rls.h"
3534
#include"utils/ruleutils.h"
3635

‎src/backend/partitioning/partbounds.c

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,6 @@
3535
#include"utils/hashutils.h"
3636
#include"utils/lsyscache.h"
3737
#include"utils/partcache.h"
38-
#include"utils/rel.h"
3938
#include"utils/ruleutils.h"
4039
#include"utils/snapmgr.h"
4140
#include"utils/syscache.h"
@@ -775,6 +774,11 @@ partition_bounds_equal(int partnatts, int16 *parttyplen, bool *parttypbyval,
775774
/*
776775
* Return a copy of given PartitionBoundInfo structure. The data types of bounds
777776
* are described by given partition key specification.
777+
*
778+
* Note: it's important that this function and its callees not do any catalog
779+
* access, nor anything else that would result in allocating memory other than
780+
* the returned data structure. Since this is called in a long-lived context,
781+
* that would result in unwanted memory leaks.
778782
*/
779783
PartitionBoundInfo
780784
partition_bounds_copy(PartitionBoundInfosrc,

‎src/backend/partitioning/partdesc.c

Lines changed: 77 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -47,28 +47,61 @@ typedef struct PartitionDirectoryEntry
4747
PartitionDescpd;
4848
}PartitionDirectoryEntry;
4949

50+
staticvoidRelationBuildPartitionDesc(Relationrel);
51+
52+
53+
/*
54+
* RelationGetPartitionDesc -- get partition descriptor, if relation is partitioned
55+
*
56+
* Note: we arrange for partition descriptors to not get freed until the
57+
* relcache entry's refcount goes to zero (see hacks in RelationClose,
58+
* RelationClearRelation, and RelationBuildPartitionDesc). Therefore, even
59+
* though we hand back a direct pointer into the relcache entry, it's safe
60+
* for callers to continue to use that pointer as long as (a) they hold the
61+
* relation open, and (b) they hold a relation lock strong enough to ensure
62+
* that the data doesn't become stale.
63+
*/
64+
PartitionDesc
65+
RelationGetPartitionDesc(Relationrel)
66+
{
67+
if (rel->rd_rel->relkind!=RELKIND_PARTITIONED_TABLE)
68+
returnNULL;
69+
70+
if (unlikely(rel->rd_partdesc==NULL))
71+
RelationBuildPartitionDesc(rel);
72+
73+
returnrel->rd_partdesc;
74+
}
75+
5076
/*
5177
* RelationBuildPartitionDesc
5278
*Form rel's partition descriptor, and store in relcache entry
5379
*
54-
* Note: the descriptor won't be flushed from the cache by
55-
* RelationClearRelation() unless it's changed because of
56-
* addition or removal of a partition. Hence, code holding a lock
57-
* that's sufficient to prevent that can assume that rd_partdesc
58-
* won't change underneath it.
80+
* Partition descriptor is a complex structure; to avoid complicated logic to
81+
* free individual elements whenever the relcache entry is flushed, we give it
82+
* its own memory context, a child of CacheMemoryContext, which can easily be
83+
* deleted on its own. To avoid leaking memory in that context in case of an
84+
* error partway through this function, the context is initially created as a
85+
* child of CurTransactionContext and only re-parented to CacheMemoryContext
86+
* at the end, when no further errors are possible. Also, we don't make this
87+
* context the current context except in very brief code sections, out of fear
88+
* that some of our callees allocate memory on their own which would be leaked
89+
* permanently.
5990
*/
60-
void
91+
staticvoid
6192
RelationBuildPartitionDesc(Relationrel)
6293
{
6394
PartitionDescpartdesc;
6495
PartitionBoundInfoboundinfo=NULL;
6596
List*inhoids;
6697
PartitionBoundSpec**boundspecs=NULL;
6798
Oid*oids=NULL;
99+
bool*is_leaf=NULL;
68100
ListCell*cell;
69101
inti,
70102
nparts;
71103
PartitionKeykey=RelationGetPartitionKey(rel);
104+
MemoryContextnew_pdcxt;
72105
MemoryContextoldcxt;
73106
int*mapping;
74107

@@ -81,10 +114,11 @@ RelationBuildPartitionDesc(Relation rel)
81114
inhoids=find_inheritance_children(RelationGetRelid(rel),NoLock);
82115
nparts=list_length(inhoids);
83116

84-
/* Allocate arrays for OIDs and boundspecs. */
117+
/* Allocateworkingarrays for OIDs, leaf flags, and boundspecs. */
85118
if (nparts>0)
86119
{
87-
oids=palloc(nparts*sizeof(Oid));
120+
oids= (Oid*)palloc(nparts*sizeof(Oid));
121+
is_leaf= (bool*)palloc(nparts*sizeof(bool));
88122
boundspecs=palloc(nparts*sizeof(PartitionBoundSpec*));
89123
}
90124

@@ -172,65 +206,73 @@ RelationBuildPartitionDesc(Relation rel)
172206

173207
/* Save results. */
174208
oids[i]=inhrelid;
209+
is_leaf[i]= (get_rel_relkind(inhrelid)!=RELKIND_PARTITIONED_TABLE);
175210
boundspecs[i]=boundspec;
176211
++i;
177212
}
178213

179-
/* Assert we aren't about to leak any old data structure */
180-
Assert(rel->rd_pdcxt==NULL);
181-
Assert(rel->rd_partdesc==NULL);
214+
/*
215+
* Create PartitionBoundInfo and mapping, working in the caller's context.
216+
* This could fail, but we haven't done any damage if so.
217+
*/
218+
if (nparts>0)
219+
boundinfo=partition_bounds_create(boundspecs,nparts,key,&mapping);
182220

183221
/*
184-
* Now build the actual relcache partition descriptor. Note that the
185-
* order of operations here is fairly critical. If we fail partway
186-
* through this code, we won't have leaked memory because the rd_pdcxt is
187-
* attached to the relcache entry immediately, so it'll be freed whenever
188-
* the entry is rebuilt or destroyed. However, we don't assign to
189-
* rd_partdesc until the cached data structure is fully complete and
190-
* valid, so that no other code might try to use it.
222+
* Now build the actual relcache partition descriptor, copying all the
223+
* data into a new, small context. As per above comment, we don't make
224+
* this a long-lived context until it's finished.
191225
*/
192-
rel->rd_pdcxt=AllocSetContextCreate(CacheMemoryContext,
193-
"partition descriptor",
194-
ALLOCSET_SMALL_SIZES);
195-
MemoryContextCopyAndSetIdentifier(rel->rd_pdcxt,
226+
new_pdcxt=AllocSetContextCreate(CurTransactionContext,
227+
"partition descriptor",
228+
ALLOCSET_SMALL_SIZES);
229+
MemoryContextCopyAndSetIdentifier(new_pdcxt,
196230
RelationGetRelationName(rel));
197231

198232
partdesc= (PartitionDescData*)
199-
MemoryContextAllocZero(rel->rd_pdcxt,sizeof(PartitionDescData));
233+
MemoryContextAllocZero(new_pdcxt,sizeof(PartitionDescData));
200234
partdesc->nparts=nparts;
201235
/* If there are no partitions, the rest of the partdesc can stay zero */
202236
if (nparts>0)
203237
{
204-
/* Create PartitionBoundInfo, using the caller's context. */
205-
boundinfo=partition_bounds_create(boundspecs,nparts,key,&mapping);
206-
207-
/* Now copy all info into relcache's partdesc. */
208-
oldcxt=MemoryContextSwitchTo(rel->rd_pdcxt);
238+
oldcxt=MemoryContextSwitchTo(new_pdcxt);
209239
partdesc->boundinfo=partition_bounds_copy(boundinfo,key);
210240
partdesc->oids= (Oid*)palloc(nparts*sizeof(Oid));
211241
partdesc->is_leaf= (bool*)palloc(nparts*sizeof(bool));
212-
MemoryContextSwitchTo(oldcxt);
213242

214243
/*
215244
* Assign OIDs from the original array into mapped indexes of the
216245
* result array. The order of OIDs in the former is defined by the
217246
* catalog scan that retrieved them, whereas that in the latter is
218247
* defined by canonicalized representation of the partition bounds.
219-
*
220-
* Also record leaf-ness of each partition. For this we use
221-
* get_rel_relkind() which may leak memory, so be sure to run it in
222-
* the caller's context.
248+
* Also save leaf-ness of each partition.
223249
*/
224250
for (i=0;i<nparts;i++)
225251
{
226252
intindex=mapping[i];
227253

228254
partdesc->oids[index]=oids[i];
229-
partdesc->is_leaf[index]=
230-
(get_rel_relkind(oids[i])!=RELKIND_PARTITIONED_TABLE);
255+
partdesc->is_leaf[index]=is_leaf[i];
231256
}
257+
MemoryContextSwitchTo(oldcxt);
232258
}
233259

260+
/*
261+
* We have a fully valid partdesc ready to store into the relcache.
262+
* Reparent it so it has the right lifespan.
263+
*/
264+
MemoryContextSetParent(new_pdcxt,CacheMemoryContext);
265+
266+
/*
267+
* But first, a kluge: if there's an old rd_pdcxt, it contains an old
268+
* partition descriptor that may still be referenced somewhere. Preserve
269+
* it, while not leaking it, by reattaching it as a child context of the
270+
* new rd_pdcxt. Eventually it will get dropped by either RelationClose
271+
* or RelationClearRelation.
272+
*/
273+
if (rel->rd_pdcxt!=NULL)
274+
MemoryContextSetParent(rel->rd_pdcxt,new_pdcxt);
275+
rel->rd_pdcxt=new_pdcxt;
234276
rel->rd_partdesc=partdesc;
235277
}
236278

‎src/backend/utils/cache/partcache.c

Lines changed: 26 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -37,8 +37,31 @@
3737
#include"utils/syscache.h"
3838

3939

40+
staticvoidRelationBuildPartitionKey(Relationrelation);
4041
staticList*generate_partition_qual(Relationrel);
4142

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+
RelationGetPartitionKey(Relationrel)
55+
{
56+
if (rel->rd_rel->relkind!=RELKIND_PARTITIONED_TABLE)
57+
returnNULL;
58+
59+
if (unlikely(rel->rd_partkey==NULL))
60+
RelationBuildPartitionKey(rel);
61+
62+
returnrel->rd_partkey;
63+
}
64+
4265
/*
4366
* RelationBuildPartitionKey
4467
*Build partition key data of relation, and attach to relcache
@@ -54,7 +77,7 @@ static List *generate_partition_qual(Relation rel);
5477
* that some of our callees allocate memory on their own which would be leaked
5578
* permanently.
5679
*/
57-
void
80+
staticvoid
5881
RelationBuildPartitionKey(Relationrelation)
5982
{
6083
Form_pg_partitioned_tableform;
@@ -74,12 +97,9 @@ RelationBuildPartitionKey(Relation relation)
7497
tuple=SearchSysCache1(PARTRELID,
7598
ObjectIdGetDatum(RelationGetRelid(relation)));
7699

77-
/*
78-
* The following happens when we have created our pg_class entry but not
79-
* the pg_partitioned_table entry yet.
80-
*/
81100
if (!HeapTupleIsValid(tuple))
82-
return;
101+
elog(ERROR,"cache lookup failed for partition key of relation %u",
102+
RelationGetRelid(relation));
83103

84104
partkeycxt=AllocSetContextCreate(CurTransactionContext,
85105
"partition key",

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp