Branch data Line data Source code
1 : : /*--------------------------------------------------------------------------
2 : : *
3 : : * test_resowner_basic.c
4 : : * Test basic ResourceOwner functionality
5 : : *
6 : : * Copyright (c) 2022-2026, PostgreSQL Global Development Group
7 : : *
8 : : * IDENTIFICATION
9 : : * src/test/modules/test_resowner/test_resowner_basic.c
10 : : *
11 : : * -------------------------------------------------------------------------
12 : : */
13 : : #include "postgres.h"
14 : :
15 : : #include "fmgr.h"
16 : : #include "utils/resowner.h"
17 : :
18 : 1 : PG_MODULE_MAGIC;
19 : :
20 : : static void ReleaseString(Datum res);
21 : : static char *PrintString(Datum res);
22 : :
23 : : /*
24 : : * A resource that tracks strings and prints the string when it's released.
25 : : * This makes the order that the resources are released visible.
26 : : */
27 : : static const ResourceOwnerDesc string_desc = {
28 : : .name = "test resource",
29 : : .release_phase = RESOURCE_RELEASE_AFTER_LOCKS,
30 : : .release_priority = RELEASE_PRIO_FIRST,
31 : : .ReleaseResource = ReleaseString,
32 : : .DebugPrint = PrintString
33 : : };
34 : :
35 : : static void
36 : 142 : ReleaseString(Datum res)
37 : : {
38 [ + + ]: 142 : elog(NOTICE, "releasing string: %s", DatumGetCString(res));
39 : 142 : }
40 : :
41 : : static char *
42 : 1 : PrintString(Datum res)
43 : : {
44 : 1 : return psprintf("test string \"%s\"", DatumGetCString(res));
45 : : }
46 : :
47 : : /* demonstrates phases and priorities between a parent and child context */
48 : 2 : PG_FUNCTION_INFO_V1(test_resowner_priorities);
49 : : Datum
50 : 2 : test_resowner_priorities(PG_FUNCTION_ARGS)
51 : : {
52 : 2 : int32 nkinds = PG_GETARG_INT32(0);
53 : 2 : int32 nresources = PG_GETARG_INT32(1);
54 : : ResourceOwner parent,
55 : : child;
56 : : ResourceOwnerDesc *before_desc;
57 : : ResourceOwnerDesc *after_desc;
58 : :
59 [ - + ]: 2 : if (nkinds <= 0)
60 [ # # ]: 0 : elog(ERROR, "nkinds must be greater than zero");
61 [ - + ]: 2 : if (nresources <= 0)
62 [ # # ]: 0 : elog(ERROR, "nresources must be greater than zero");
63 : :
64 : 2 : parent = ResourceOwnerCreate(CurrentResourceOwner, "test parent");
65 : 2 : child = ResourceOwnerCreate(parent, "test child");
66 : :
67 : 2 : before_desc = palloc(nkinds * sizeof(ResourceOwnerDesc));
68 [ + + ]: 6 : for (int i = 0; i < nkinds; i++)
69 : : {
70 : 4 : before_desc[i].name = psprintf("test resource before locks %d", i);
71 : 4 : before_desc[i].release_phase = RESOURCE_RELEASE_BEFORE_LOCKS;
72 : 4 : before_desc[i].release_priority = RELEASE_PRIO_FIRST + i;
73 : 4 : before_desc[i].ReleaseResource = ReleaseString;
74 : 4 : before_desc[i].DebugPrint = PrintString;
75 : : }
76 : 2 : after_desc = palloc(nkinds * sizeof(ResourceOwnerDesc));
77 [ + + ]: 6 : for (int i = 0; i < nkinds; i++)
78 : : {
79 : 4 : after_desc[i].name = psprintf("test resource after locks %d", i);
80 : 4 : after_desc[i].release_phase = RESOURCE_RELEASE_AFTER_LOCKS;
81 : 4 : after_desc[i].release_priority = RELEASE_PRIO_FIRST + i;
82 : 4 : after_desc[i].ReleaseResource = ReleaseString;
83 : 4 : after_desc[i].DebugPrint = PrintString;
84 : : }
85 : :
86 : : /* Add a bunch of resources to child, with different priorities */
87 [ + + ]: 37 : for (int i = 0; i < nresources; i++)
88 : : {
89 : 35 : ResourceOwnerDesc *kind = &before_desc[i % nkinds];
90 : :
91 : 35 : ResourceOwnerEnlarge(child);
92 : 35 : ResourceOwnerRemember(child,
93 : 35 : CStringGetDatum(psprintf("child before locks priority %d", kind->release_priority)),
94 : : kind);
95 : : }
96 [ + + ]: 37 : for (int i = 0; i < nresources; i++)
97 : : {
98 : 35 : ResourceOwnerDesc *kind = &after_desc[i % nkinds];
99 : :
100 : 35 : ResourceOwnerEnlarge(child);
101 : 35 : ResourceOwnerRemember(child,
102 : 35 : CStringGetDatum(psprintf("child after locks priority %d", kind->release_priority)),
103 : : kind);
104 : : }
105 : :
106 : : /* And also to the parent */
107 [ + + ]: 37 : for (int i = 0; i < nresources; i++)
108 : : {
109 : 35 : ResourceOwnerDesc *kind = &after_desc[i % nkinds];
110 : :
111 : 35 : ResourceOwnerEnlarge(parent);
112 : 35 : ResourceOwnerRemember(parent,
113 : 35 : CStringGetDatum(psprintf("parent after locks priority %d", kind->release_priority)),
114 : : kind);
115 : : }
116 [ + + ]: 37 : for (int i = 0; i < nresources; i++)
117 : : {
118 : 35 : ResourceOwnerDesc *kind = &before_desc[i % nkinds];
119 : :
120 : 35 : ResourceOwnerEnlarge(parent);
121 : 35 : ResourceOwnerRemember(parent,
122 : 35 : CStringGetDatum(psprintf("parent before locks priority %d", kind->release_priority)),
123 : : kind);
124 : : }
125 : :
126 [ + - ]: 2 : elog(NOTICE, "releasing resources before locks");
127 : 2 : ResourceOwnerRelease(parent, RESOURCE_RELEASE_BEFORE_LOCKS, false, false);
128 [ + - ]: 2 : elog(NOTICE, "releasing locks");
129 : 2 : ResourceOwnerRelease(parent, RESOURCE_RELEASE_LOCKS, false, false);
130 [ + - ]: 2 : elog(NOTICE, "releasing resources after locks");
131 : 2 : ResourceOwnerRelease(parent, RESOURCE_RELEASE_AFTER_LOCKS, false, false);
132 : :
133 : 2 : ResourceOwnerDelete(parent);
134 : :
135 : 2 : PG_RETURN_VOID();
136 : : }
137 : :
138 : 2 : PG_FUNCTION_INFO_V1(test_resowner_leak);
139 : : Datum
140 : 1 : test_resowner_leak(PG_FUNCTION_ARGS)
141 : : {
142 : : ResourceOwner resowner;
143 : :
144 : 1 : resowner = ResourceOwnerCreate(CurrentResourceOwner, "TestOwner");
145 : :
146 : 1 : ResourceOwnerEnlarge(resowner);
147 : :
148 : 1 : ResourceOwnerRemember(resowner, CStringGetDatum("my string"), &string_desc);
149 : :
150 : : /* don't call ResourceOwnerForget, so that it is leaked */
151 : :
152 : 1 : ResourceOwnerRelease(resowner, RESOURCE_RELEASE_BEFORE_LOCKS, true, false);
153 : 1 : ResourceOwnerRelease(resowner, RESOURCE_RELEASE_LOCKS, true, false);
154 : 1 : ResourceOwnerRelease(resowner, RESOURCE_RELEASE_AFTER_LOCKS, true, false);
155 : :
156 : 1 : ResourceOwnerDelete(resowner);
157 : :
158 : 1 : PG_RETURN_VOID();
159 : : }
160 : :
161 : 2 : PG_FUNCTION_INFO_V1(test_resowner_remember_between_phases);
162 : : Datum
163 : 1 : test_resowner_remember_between_phases(PG_FUNCTION_ARGS)
164 : : {
165 : : ResourceOwner resowner;
166 : :
167 : 1 : resowner = ResourceOwnerCreate(CurrentResourceOwner, "TestOwner");
168 : :
169 : 1 : ResourceOwnerRelease(resowner, RESOURCE_RELEASE_BEFORE_LOCKS, true, false);
170 : :
171 : : /*
172 : : * Try to remember a new resource. Fails because we already called
173 : : * ResourceOwnerRelease.
174 : : */
175 : 1 : ResourceOwnerEnlarge(resowner);
176 : 0 : ResourceOwnerRemember(resowner, CStringGetDatum("my string"), &string_desc);
177 : :
178 : : /* unreachable */
179 [ # # ]: 0 : elog(ERROR, "ResourceOwnerEnlarge should have errored out");
180 : :
181 : : PG_RETURN_VOID();
182 : : }
183 : :
184 : 2 : PG_FUNCTION_INFO_V1(test_resowner_forget_between_phases);
185 : : Datum
186 : 1 : test_resowner_forget_between_phases(PG_FUNCTION_ARGS)
187 : : {
188 : : ResourceOwner resowner;
189 : : Datum str_resource;
190 : :
191 : 1 : resowner = ResourceOwnerCreate(CurrentResourceOwner, "TestOwner");
192 : :
193 : 1 : ResourceOwnerEnlarge(resowner);
194 : 1 : str_resource = CStringGetDatum("my string");
195 : 1 : ResourceOwnerRemember(resowner, str_resource, &string_desc);
196 : :
197 : 1 : ResourceOwnerRelease(resowner, RESOURCE_RELEASE_BEFORE_LOCKS, true, false);
198 : :
199 : : /*
200 : : * Try to forget the resource that was remembered earlier. Fails because
201 : : * we already called ResourceOwnerRelease.
202 : : */
203 : 1 : ResourceOwnerForget(resowner, str_resource, &string_desc);
204 : :
205 : : /* unreachable */
206 [ # # ]: 0 : elog(ERROR, "ResourceOwnerForget should have errored out");
207 : :
208 : : PG_RETURN_VOID();
209 : : }
|
