Debian Codegraph @

src/backend/executor/tstoreReceiver.c

raw
1 /*-------------------------------------------------------------------------
2 *
3 * tstoreReceiver.c
4 * An implementation of DestReceiver that stores the result tuples in
5 * a Tuplestore.
6 *
7 * Optionally, we can force detoasting (but not decompression) of out-of-line
8 * toasted values. This is to support cursors WITH HOLD, which must retain
9 * data even if the underlying table is dropped.
10 *
11 * Also optionally, we can apply a tuple conversion map before storing.
12 *
13 *
14 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
15 * Portions Copyright (c) 1994, Regents of the University of California
16 *
17 * IDENTIFICATION
18 * src/backend/executor/tstoreReceiver.c
19 *
20 *-------------------------------------------------------------------------
21 */
22
23 #include "postgres.h"
24
25 #include "access/detoast.h"
26 #include "access/tupconvert.h"
27 #include "executor/tstoreReceiver.h"
28
29
30 typedef struct
31 {
32 DestReceiver pub;
33 /* parameters: */
34 Tuplestorestate *tstore; /* where to put the data */
35 MemoryContext cxt; /* context containing tstore */
36 bool detoast; /* were we told to detoast? */
37 TupleDesc target_tupdesc; /* target tupdesc, or NULL if none */
38 const char *map_failure_msg; /* tupdesc mapping failure message */
39 /* workspace: */
40 Datum *outvalues; /* values array for result tuple */
41 Datum *tofree; /* temp values to be pfree'd */
42 TupleConversionMap *tupmap; /* conversion map, if needed */
43 TupleTableSlot *mapslot; /* slot for mapped tuples */
44 } TStoreState;
45
46
47 static bool tstoreReceiveSlot_notoast(TupleTableSlot *slot, DestReceiver *self);
48 static bool tstoreReceiveSlot_detoast(TupleTableSlot *slot, DestReceiver *self);
49 static bool tstoreReceiveSlot_tupmap(TupleTableSlot *slot, DestReceiver *self);
50
51
52 /*
53 * Prepare to receive tuples from executor.
54 */
55 static void
56 tstoreStartupReceiver(DestReceiver *self, int operation, TupleDesc typeinfo)
57 {
58 TStoreState *myState = (TStoreState *) self;
59 bool needtoast = false;
60 int natts = typeinfo->natts;
61 int i;
62
63 /* Check if any columns require detoast work */
64 if (myState->detoast)
65 {
66 for (i = 0; i < natts; i++)
67 {
68 CompactAttribute *attr = TupleDescCompactAttr(typeinfo, i);
69
70 if (attr->attisdropped)
71 continue;
72 if (attr->attlen == -1)
73 {
74 needtoast = true;
75 break;
76 }
77 }
78 }
79
80 /* Check if tuple conversion is needed */
81 if (myState->target_tupdesc)
82 myState->tupmap = convert_tuples_by_position(typeinfo,
83 myState->target_tupdesc,
84 myState->map_failure_msg);
85 else
86 myState->tupmap = NULL;
87
88 /* Set up appropriate callback */
89 if (needtoast)
90 {
91 Assert(!myState->tupmap);
92 myState->pub.receiveSlot = tstoreReceiveSlot_detoast;
93 /* Create workspace */
94 myState->outvalues = (Datum *)
95 MemoryContextAlloc(myState->cxt, natts * sizeof(Datum));
96 myState->tofree = (Datum *)
97 MemoryContextAlloc(myState->cxt, natts * sizeof(Datum));
98 myState->mapslot = NULL;
99 }
100 else if (myState->tupmap)
101 {
102 myState->pub.receiveSlot = tstoreReceiveSlot_tupmap;
103 myState->outvalues = NULL;
104 myState->tofree = NULL;
105 myState->mapslot = MakeSingleTupleTableSlot(myState->target_tupdesc,
106 &TTSOpsVirtual);
107 }
108 else
109 {
110 myState->pub.receiveSlot = tstoreReceiveSlot_notoast;
111 myState->outvalues = NULL;
112 myState->tofree = NULL;
113 myState->mapslot = NULL;
114 }
115 }
116
117 /*
118 * Receive a tuple from the executor and store it in the tuplestore.
119 * This is for the easy case where we don't have to detoast nor map anything.
120 */
121 static bool
122 tstoreReceiveSlot_notoast(TupleTableSlot *slot, DestReceiver *self)
123 {
124 TStoreState *myState = (TStoreState *) self;
125
126 tuplestore_puttupleslot(myState->tstore, slot);
127
128 return true;
129 }
130
131 /*
132 * Receive a tuple from the executor and store it in the tuplestore.
133 * This is for the case where we have to detoast any toasted values.
134 */
135 static bool
136 tstoreReceiveSlot_detoast(TupleTableSlot *slot, DestReceiver *self)
137 {
138 TStoreState *myState = (TStoreState *) self;
139 TupleDesc typeinfo = slot->tts_tupleDescriptor;
140 int natts = typeinfo->natts;
141 int nfree;
142 int i;
143 MemoryContext oldcxt;
144
145 /* Make sure the tuple is fully deconstructed */
146 slot_getallattrs(slot);
147
148 /*
149 * Fetch back any out-of-line datums. We build the new datums array in
150 * myState->outvalues[] (but we can re-use the slot's isnull array). Also,
151 * remember the fetched values to free afterwards.
152 */
153 nfree = 0;
154 for (i = 0; i < natts; i++)
155 {
156 Datum val = slot->tts_values[i];
157 CompactAttribute *attr = TupleDescCompactAttr(typeinfo, i);
158
159 if (!attr->attisdropped && attr->attlen == -1 && !slot->tts_isnull[i])
160 {
161 if (VARATT_IS_EXTERNAL(DatumGetPointer(val)))
162 {
163 val = PointerGetDatum(detoast_external_attr((struct varlena *)
164 DatumGetPointer(val)));
165 myState->tofree[nfree++] = val;
166 }
167 }
168
169 myState->outvalues[i] = val;
170 }
171
172 /*
173 * Push the modified tuple into the tuplestore.
174 */
175 oldcxt = MemoryContextSwitchTo(myState->cxt);
176 tuplestore_putvalues(myState->tstore, typeinfo,
177 myState->outvalues, slot->tts_isnull);
178 MemoryContextSwitchTo(oldcxt);
179
180 /* And release any temporary detoasted values */
181 for (i = 0; i < nfree; i++)
182 pfree(DatumGetPointer(myState->tofree[i]));
183
184 return true;
185 }
186
187 /*
188 * Receive a tuple from the executor and store it in the tuplestore.
189 * This is for the case where we must apply a tuple conversion map.
190 */
191 static bool
192 tstoreReceiveSlot_tupmap(TupleTableSlot *slot, DestReceiver *self)
193 {
194 TStoreState *myState = (TStoreState *) self;
195
196 execute_attr_map_slot(myState->tupmap->attrMap, slot, myState->mapslot);
197 tuplestore_puttupleslot(myState->tstore, myState->mapslot);
198
199 return true;
200 }
201
202 /*
203 * Clean up at end of an executor run
204 */
205 static void
206 tstoreShutdownReceiver(DestReceiver *self)
207 {
208 TStoreState *myState = (TStoreState *) self;
209
210 /* Release workspace if any */
211 if (myState->outvalues)
212 pfree(myState->outvalues);
213 myState->outvalues = NULL;
214 if (myState->tofree)
215 pfree(myState->tofree);
216 myState->tofree = NULL;
217 if (myState->tupmap)
218 free_conversion_map(myState->tupmap);
219 myState->tupmap = NULL;
220 if (myState->mapslot)
221 ExecDropSingleTupleTableSlot(myState->mapslot);
222 myState->mapslot = NULL;
223 }
224
225 /*
226 * Destroy receiver when done with it
227 */
228 static void
229 tstoreDestroyReceiver(DestReceiver *self)
230 {
231 pfree(self);
232 }
233
234 /*
235 * Initially create a DestReceiver object.
236 */
237 DestReceiver *
238 CreateTuplestoreDestReceiver(void)
239 {
240 TStoreState *self = (TStoreState *) palloc0(sizeof(TStoreState));
241
242 self->pub.receiveSlot = tstoreReceiveSlot_notoast; /* might change */
243 self->pub.rStartup = tstoreStartupReceiver;
244 self->pub.rShutdown = tstoreShutdownReceiver;
245 self->pub.rDestroy = tstoreDestroyReceiver;
246 self->pub.mydest = DestTuplestore;
247
248 /* private fields will be set by SetTuplestoreDestReceiverParams */
249
250 return (DestReceiver *) self;
251 }
252
253 /*
254 * Set parameters for a TuplestoreDestReceiver
255 *
256 * tStore: where to store the tuples
257 * tContext: memory context containing tStore
258 * detoast: forcibly detoast contained data?
259 * target_tupdesc: if not NULL, forcibly convert tuples to this rowtype
260 * map_failure_msg: error message to use if mapping to target_tupdesc fails
261 *
262 * We don't currently support both detoast and target_tupdesc at the same
263 * time, just because no existing caller needs that combination.
264 */
265 void
266 SetTuplestoreDestReceiverParams(DestReceiver *self,
267 Tuplestorestate *tStore,
268 MemoryContext tContext,
269 bool detoast,
270 TupleDesc target_tupdesc,
271 const char *map_failure_msg)
272 {
273 TStoreState *myState = (TStoreState *) self;
274
275 Assert(!(detoast && target_tupdesc));
276
277 Assert(myState->pub.mydest == DestTuplestore);
278 myState->tstore = tStore;
279 myState->cxt = tContext;
280 myState->detoast = detoast;
281 myState->target_tupdesc = target_tupdesc;
282 myState->map_failure_msg = map_failure_msg;
283 }