| 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 |
} |