/*------------------------------------------------------------------------- * * tupconvert.c * Tuple conversion support. * * These functions provide conversion between rowtypes that are logically * equivalent but might have columns in a different order or different sets of * dropped columns. * * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * * * IDENTIFICATION * src/backend/access/common/tupconvert.c * *------------------------------------------------------------------------- */ #include "postgres.h" #include "access/tupconvert.h" #include "executor/tuptable.h" /* * The conversion setup routines have the following common API: * * The setup routine checks using attmap.c whether the given source and * destination tuple descriptors are logically compatible. If not, it throws * an error. If so, it returns NULL if they are physically compatible (ie, no * conversion is needed), else a TupleConversionMap that can be used by * execute_attr_map_tuple or execute_attr_map_slot to perform the conversion. * * The TupleConversionMap, if needed, is palloc'd in the caller's memory * context. Also, the given tuple descriptors are referenced by the map, * so they must survive as long as the map is needed. * * The caller must supply a suitable primary error message to be used if * a compatibility error is thrown. Recommended coding practice is to use * gettext_noop() on this string, so that it is translatable but won't * actually be translated unless the error gets thrown. * * * Implementation notes: * * The key component of a TupleConversionMap is an attrMap[] array with * one entry per output column. This entry contains the 1-based index of * the corresponding input column, or zero to force a NULL value (for * a dropped output column). The TupleConversionMap also contains workspace * arrays. */ /* * Set up for tuple conversion, matching input and output columns by * position. (Dropped columns are ignored in both input and output.) */ TupleConversionMap * convert_tuples_by_position(TupleDesc indesc, TupleDesc outdesc, const char *msg) { TupleConversionMap *map; int n; AttrMap *attrMap; /* Verify compatibility and prepare attribute-number map */ attrMap = build_attrmap_by_position(indesc, outdesc, msg); if (attrMap == NULL) { /* runtime conversion is not needed */ return NULL; } /* Prepare the map structure */ map = (TupleConversionMap *) palloc(sizeof(TupleConversionMap)); map->indesc = indesc; map->outdesc = outdesc; map->attrMap = attrMap; /* preallocate workspace for Datum arrays */ n = outdesc->natts + 1; /* +1 for NULL */ map->outvalues = (Datum *) palloc(n * sizeof(Datum)); map->outisnull = (bool *) palloc(n * sizeof(bool)); n = indesc->natts + 1; /* +1 for NULL */ map->invalues = (Datum *) palloc(n * sizeof(Datum)); map->inisnull = (bool *) palloc(n * sizeof(bool)); map->invalues[0] = (Datum) 0; /* set up the NULL entry */ map->inisnull[0] = true; return map; } /* * Set up for tuple conversion, matching input and output columns by name. * (Dropped columns are ignored in both input and output.) This is intended * for use when the rowtypes are related by inheritance, so we expect an exact * match of both type and typmod. The error messages will be a bit unhelpful * unless both rowtypes are named composite types. */ TupleConversionMap * convert_tuples_by_name(TupleDesc indesc, TupleDesc outdesc) { AttrMap *attrMap; /* Verify compatibility and prepare attribute-number map */ attrMap = build_attrmap_by_name_if_req(indesc, outdesc, false); if (attrMap == NULL) { /* runtime conversion is not needed */ return NULL; } return convert_tuples_by_name_attrmap(indesc, outdesc, attrMap); } /* * Set up tuple conversion for input and output TupleDescs using the given * AttrMap. */ TupleConversionMap * convert_tuples_by_name_attrmap(TupleDesc indesc, TupleDesc outdesc, AttrMap *attrMap) { int n = outdesc->natts; TupleConversionMap *map; Assert(attrMap != NULL); /* Prepare the map structure */ map = (TupleConversionMap *) palloc(sizeof(TupleConversionMap)); map->indesc = indesc; map->outdesc = outdesc; map->attrMap = attrMap; /* preallocate workspace for Datum arrays */ map->outvalues = (Datum *) palloc(n * sizeof(Datum)); map->outisnull = (bool *) palloc(n * sizeof(bool)); n = indesc->natts + 1; /* +1 for NULL */ map->invalues = (Datum *) palloc(n * sizeof(Datum)); map->inisnull = (bool *) palloc(n * sizeof(bool)); map->invalues[0] = (Datum) 0; /* set up the NULL entry */ map->inisnull[0] = true; return map; } /* * Perform conversion of a tuple according to the map. */ HeapTuple execute_attr_map_tuple(HeapTuple tuple, TupleConversionMap *map) { AttrMap *attrMap = map->attrMap; Datum *invalues = map->invalues; bool *inisnull = map->inisnull; Datum *outvalues = map->outvalues; bool *outisnull = map->outisnull; int i; /* * Extract all the values of the old tuple, offsetting the arrays so that * invalues[0] is left NULL and invalues[1] is the first source attribute; * this exactly matches the numbering convention in attrMap. */ heap_deform_tuple(tuple, map->indesc, invalues + 1, inisnull + 1); /* * Transpose into proper fields of the new tuple. */ Assert(attrMap->maplen == map->outdesc->natts); for (i = 0; i < attrMap->maplen; i++) { int j = attrMap->attnums[i]; outvalues[i] = invalues[j]; outisnull[i] = inisnull[j]; } /* * Now form the new tuple. */ return heap_form_tuple(map->outdesc, outvalues, outisnull); } /* * Perform conversion of a tuple slot according to the map. */ TupleTableSlot * execute_attr_map_slot(AttrMap *attrMap, TupleTableSlot *in_slot, TupleTableSlot *out_slot) { Datum *invalues; bool *inisnull; Datum *outvalues; bool *outisnull; int outnatts; int i; /* Sanity checks */ Assert(in_slot->tts_tupleDescriptor != NULL && out_slot->tts_tupleDescriptor != NULL); Assert(in_slot->tts_values != NULL && out_slot->tts_values != NULL); outnatts = out_slot->tts_tupleDescriptor->natts; /* Extract all the values of the in slot. */ slot_getallattrs(in_slot); /* Before doing the mapping, clear any old contents from the out slot */ ExecClearTuple(out_slot); invalues = in_slot->tts_values; inisnull = in_slot->tts_isnull; outvalues = out_slot->tts_values; outisnull = out_slot->tts_isnull; /* Transpose into proper fields of the out slot. */ for (i = 0; i < outnatts; i++) { int j = attrMap->attnums[i] - 1; /* attrMap->attnums[i] == 0 means it's a NULL datum. */ if (j == -1) { outvalues[i] = (Datum) 0; outisnull[i] = true; } else { outvalues[i] = invalues[j]; outisnull[i] = inisnull[j]; } } ExecStoreVirtualTuple(out_slot); return out_slot; } /* * Perform conversion of bitmap of columns according to the map. * * The input and output bitmaps are offset by * FirstLowInvalidHeapAttributeNumber to accommodate system cols, like the * column-bitmaps in RangeTblEntry. */ Bitmapset * execute_attr_map_cols(AttrMap *attrMap, Bitmapset *in_cols) { Bitmapset *out_cols; int out_attnum; /* fast path for the common trivial case */ if (in_cols == NULL) return NULL; /* * For each output column, check which input column it corresponds to. */ out_cols = NULL; for (out_attnum = FirstLowInvalidHeapAttributeNumber; out_attnum <= attrMap->maplen; out_attnum++) { int in_attnum; if (out_attnum < 0) { /* System column. No mapping. */ in_attnum = out_attnum; } else if (out_attnum == 0) continue; else { /* normal user column */ in_attnum = attrMap->attnums[out_attnum - 1]; if (in_attnum == 0) continue; } if (bms_is_member(in_attnum - FirstLowInvalidHeapAttributeNumber, in_cols)) out_cols = bms_add_member(out_cols, out_attnum - FirstLowInvalidHeapAttributeNumber); } return out_cols; } /* * Free a TupleConversionMap structure. */ void free_conversion_map(TupleConversionMap *map) { /* indesc and outdesc are not ours to free */ free_attrmap(map->attrMap); pfree(map->invalues); pfree(map->inisnull); pfree(map->outvalues); pfree(map->outisnull); pfree(map); }