2009-08-06 22:44:32 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* 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
|
2014-05-06 18:12:18 +02:00
|
|
|
* of dropped columns. There is some overlap of functionality with the
|
2009-08-06 22:44:32 +02:00
|
|
|
* executor's "junkfilter" routines, but these functions work on bare
|
|
|
|
* HeapTuples rather than TupleTableSlots.
|
|
|
|
*
|
2017-01-03 19:48:53 +01:00
|
|
|
* Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
|
2009-08-06 22:44:32 +02:00
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
2010-09-20 22:08:53 +02:00
|
|
|
* src/backend/access/common/tupconvert.c
|
2009-08-06 22:44:32 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
#include "postgres.h"
|
|
|
|
|
2012-08-30 22:15:44 +02:00
|
|
|
#include "access/htup_details.h"
|
2009-08-06 22:44:32 +02:00
|
|
|
#include "access/tupconvert.h"
|
|
|
|
#include "utils/builtins.h"
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The conversion setup routines have the following common API:
|
|
|
|
*
|
|
|
|
* The setup routine checks 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 do_convert_tuple
|
|
|
|
* 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.)
|
|
|
|
*
|
|
|
|
* Note: the errdetail messages speak of indesc as the "returned" rowtype,
|
|
|
|
* outdesc as the "expected" rowtype. This is okay for current uses but
|
|
|
|
* might need generalization in future.
|
|
|
|
*/
|
|
|
|
TupleConversionMap *
|
|
|
|
convert_tuples_by_position(TupleDesc indesc,
|
|
|
|
TupleDesc outdesc,
|
|
|
|
const char *msg)
|
|
|
|
{
|
|
|
|
TupleConversionMap *map;
|
|
|
|
AttrNumber *attrMap;
|
|
|
|
int nincols;
|
|
|
|
int noutcols;
|
|
|
|
int n;
|
|
|
|
int i;
|
|
|
|
int j;
|
|
|
|
bool same;
|
|
|
|
|
|
|
|
/* Verify compatibility and prepare attribute-number map */
|
|
|
|
n = outdesc->natts;
|
|
|
|
attrMap = (AttrNumber *) palloc0(n * sizeof(AttrNumber));
|
|
|
|
j = 0; /* j is next physical input attribute */
|
|
|
|
nincols = noutcols = 0; /* these count non-dropped attributes */
|
|
|
|
same = true;
|
|
|
|
for (i = 0; i < n; i++)
|
|
|
|
{
|
|
|
|
Form_pg_attribute att = outdesc->attrs[i];
|
|
|
|
Oid atttypid;
|
|
|
|
int32 atttypmod;
|
|
|
|
|
|
|
|
if (att->attisdropped)
|
2010-02-26 03:01:40 +01:00
|
|
|
continue; /* attrMap[i] is already 0 */
|
2009-08-06 22:44:32 +02:00
|
|
|
noutcols++;
|
|
|
|
atttypid = att->atttypid;
|
|
|
|
atttypmod = att->atttypmod;
|
|
|
|
for (; j < indesc->natts; j++)
|
|
|
|
{
|
|
|
|
att = indesc->attrs[j];
|
|
|
|
if (att->attisdropped)
|
|
|
|
continue;
|
|
|
|
nincols++;
|
|
|
|
/* Found matching column, check type */
|
|
|
|
if (atttypid != att->atttypid ||
|
|
|
|
(atttypmod != att->atttypmod && atttypmod >= 0))
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_DATATYPE_MISMATCH),
|
|
|
|
errmsg_internal("%s", _(msg)),
|
|
|
|
errdetail("Returned type %s does not match expected type %s in column %d.",
|
|
|
|
format_type_with_typemod(att->atttypid,
|
|
|
|
att->atttypmod),
|
|
|
|
format_type_with_typemod(atttypid,
|
|
|
|
atttypmod),
|
|
|
|
noutcols)));
|
|
|
|
attrMap[i] = (AttrNumber) (j + 1);
|
|
|
|
j++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (attrMap[i] == 0)
|
|
|
|
same = false; /* we'll complain below */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check for unused input columns */
|
|
|
|
for (; j < indesc->natts; j++)
|
|
|
|
{
|
|
|
|
if (indesc->attrs[j]->attisdropped)
|
|
|
|
continue;
|
|
|
|
nincols++;
|
|
|
|
same = false; /* we'll complain below */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Report column count mismatch using the non-dropped-column counts */
|
|
|
|
if (!same)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_DATATYPE_MISMATCH),
|
|
|
|
errmsg_internal("%s", _(msg)),
|
|
|
|
errdetail("Number of returned columns (%d) does not match "
|
|
|
|
"expected column count (%d).",
|
|
|
|
nincols, noutcols)));
|
|
|
|
|
|
|
|
/*
|
Be more aggressive in avoiding tuple conversion.
According to the comments in tupconvert.c, it's necessary to perform
tuple conversion when either table has OIDs, and this was previously
checked by ensuring that the tdtypeid value matched between the tables
in question. However, that's overly stringent: we have access to
tdhasoid and can test directly whether OIDs are present, which lets us
avoid conversion in cases where the type OIDs are different but the
tuple descriptors are entirely the same (and neither has OIDs). This
is useful to the partitioning code, which can thereby avoid converting
tuples when inserting into a partition whose columns appear in the
same order as the parent columns, the normal case. It's possible
for the tuple routing code to avoid some additional overhead in this
case as well, so do that, too.
It's not clear whether it would be OK to skip this when both tables
have OIDs: do callers count on this to build a new tuple (losing the
previous OID) in such instances? Until we figure it out, leave the
behavior in that case alone.
Amit Langote, reviewed by me.
2017-01-25 03:53:38 +01:00
|
|
|
* Check to see if the map is one-to-one, in which case we need not do
|
|
|
|
* the tuple conversion. That's not enough though if either source or
|
|
|
|
* destination (tuples) contains OIDs; we'd need conversion in that case
|
|
|
|
* to inject the right OID into the tuple datum.
|
2009-08-06 22:44:32 +02:00
|
|
|
*/
|
|
|
|
if (indesc->natts == outdesc->natts &&
|
Be more aggressive in avoiding tuple conversion.
According to the comments in tupconvert.c, it's necessary to perform
tuple conversion when either table has OIDs, and this was previously
checked by ensuring that the tdtypeid value matched between the tables
in question. However, that's overly stringent: we have access to
tdhasoid and can test directly whether OIDs are present, which lets us
avoid conversion in cases where the type OIDs are different but the
tuple descriptors are entirely the same (and neither has OIDs). This
is useful to the partitioning code, which can thereby avoid converting
tuples when inserting into a partition whose columns appear in the
same order as the parent columns, the normal case. It's possible
for the tuple routing code to avoid some additional overhead in this
case as well, so do that, too.
It's not clear whether it would be OK to skip this when both tables
have OIDs: do callers count on this to build a new tuple (losing the
previous OID) in such instances? Until we figure it out, leave the
behavior in that case alone.
Amit Langote, reviewed by me.
2017-01-25 03:53:38 +01:00
|
|
|
!indesc->tdhasoid && !outdesc->tdhasoid)
|
2009-08-06 22:44:32 +02:00
|
|
|
{
|
|
|
|
for (i = 0; i < n; i++)
|
|
|
|
{
|
2010-02-26 03:01:40 +01:00
|
|
|
if (attrMap[i] == (i + 1))
|
2009-08-17 22:34:31 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
2010-02-26 03:01:40 +01:00
|
|
|
* If it's a dropped column and the corresponding input column is
|
|
|
|
* also dropped, we needn't convert. However, attlen and attalign
|
|
|
|
* must agree.
|
2009-08-17 22:34:31 +02:00
|
|
|
*/
|
|
|
|
if (attrMap[i] == 0 &&
|
|
|
|
indesc->attrs[i]->attisdropped &&
|
|
|
|
indesc->attrs[i]->attlen == outdesc->attrs[i]->attlen &&
|
|
|
|
indesc->attrs[i]->attalign == outdesc->attrs[i]->attalign)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
same = false;
|
|
|
|
break;
|
2009-08-06 22:44:32 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
same = false;
|
|
|
|
|
|
|
|
if (same)
|
|
|
|
{
|
|
|
|
/* Runtime conversion is not needed */
|
|
|
|
pfree(attrMap);
|
|
|
|
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 */
|
|
|
|
map->outvalues = (Datum *) palloc(n * sizeof(Datum));
|
|
|
|
map->outisnull = (bool *) palloc(n * sizeof(bool));
|
2010-02-26 03:01:40 +01:00
|
|
|
n = indesc->natts + 1; /* +1 for NULL */
|
2009-08-06 22:44:32 +02:00
|
|
|
map->invalues = (Datum *) palloc(n * sizeof(Datum));
|
|
|
|
map->inisnull = (bool *) palloc(n * sizeof(bool));
|
2010-02-26 03:01:40 +01:00
|
|
|
map->invalues[0] = (Datum) 0; /* set up the NULL entry */
|
2009-08-06 22:44:32 +02:00
|
|
|
map->inisnull[0] = true;
|
|
|
|
|
|
|
|
return map;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up for tuple conversion, matching input and output columns by name.
|
2010-02-26 03:01:40 +01:00
|
|
|
* (Dropped columns are ignored in both input and output.) This is intended
|
2009-08-06 22:44:32 +02:00
|
|
|
* 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,
|
|
|
|
const char *msg)
|
|
|
|
{
|
|
|
|
TupleConversionMap *map;
|
|
|
|
AttrNumber *attrMap;
|
2017-01-09 23:26:58 +01:00
|
|
|
int n = outdesc->natts;
|
2009-08-06 22:44:32 +02:00
|
|
|
int i;
|
|
|
|
bool same;
|
|
|
|
|
|
|
|
/* Verify compatibility and prepare attribute-number map */
|
2017-01-09 23:26:58 +01:00
|
|
|
attrMap = convert_tuples_by_name_map(indesc, outdesc, msg);
|
2009-08-06 22:44:32 +02:00
|
|
|
|
|
|
|
/*
|
Be more aggressive in avoiding tuple conversion.
According to the comments in tupconvert.c, it's necessary to perform
tuple conversion when either table has OIDs, and this was previously
checked by ensuring that the tdtypeid value matched between the tables
in question. However, that's overly stringent: we have access to
tdhasoid and can test directly whether OIDs are present, which lets us
avoid conversion in cases where the type OIDs are different but the
tuple descriptors are entirely the same (and neither has OIDs). This
is useful to the partitioning code, which can thereby avoid converting
tuples when inserting into a partition whose columns appear in the
same order as the parent columns, the normal case. It's possible
for the tuple routing code to avoid some additional overhead in this
case as well, so do that, too.
It's not clear whether it would be OK to skip this when both tables
have OIDs: do callers count on this to build a new tuple (losing the
previous OID) in such instances? Until we figure it out, leave the
behavior in that case alone.
Amit Langote, reviewed by me.
2017-01-25 03:53:38 +01:00
|
|
|
* Check to see if the map is one-to-one, in which case we need not do
|
|
|
|
* the tuple conversion. That's not enough though if either source or
|
|
|
|
* destination (tuples) contains OIDs; we'd need conversion in that case
|
|
|
|
* to inject the right OID into the tuple datum.
|
2009-08-06 22:44:32 +02:00
|
|
|
*/
|
|
|
|
if (indesc->natts == outdesc->natts &&
|
Be more aggressive in avoiding tuple conversion.
According to the comments in tupconvert.c, it's necessary to perform
tuple conversion when either table has OIDs, and this was previously
checked by ensuring that the tdtypeid value matched between the tables
in question. However, that's overly stringent: we have access to
tdhasoid and can test directly whether OIDs are present, which lets us
avoid conversion in cases where the type OIDs are different but the
tuple descriptors are entirely the same (and neither has OIDs). This
is useful to the partitioning code, which can thereby avoid converting
tuples when inserting into a partition whose columns appear in the
same order as the parent columns, the normal case. It's possible
for the tuple routing code to avoid some additional overhead in this
case as well, so do that, too.
It's not clear whether it would be OK to skip this when both tables
have OIDs: do callers count on this to build a new tuple (losing the
previous OID) in such instances? Until we figure it out, leave the
behavior in that case alone.
Amit Langote, reviewed by me.
2017-01-25 03:53:38 +01:00
|
|
|
!indesc->tdhasoid && !outdesc->tdhasoid)
|
2009-08-06 22:44:32 +02:00
|
|
|
{
|
|
|
|
same = true;
|
|
|
|
for (i = 0; i < n; i++)
|
|
|
|
{
|
2010-02-26 03:01:40 +01:00
|
|
|
if (attrMap[i] == (i + 1))
|
2009-08-17 22:34:31 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
2010-02-26 03:01:40 +01:00
|
|
|
* If it's a dropped column and the corresponding input column is
|
|
|
|
* also dropped, we needn't convert. However, attlen and attalign
|
|
|
|
* must agree.
|
2009-08-17 22:34:31 +02:00
|
|
|
*/
|
|
|
|
if (attrMap[i] == 0 &&
|
|
|
|
indesc->attrs[i]->attisdropped &&
|
|
|
|
indesc->attrs[i]->attlen == outdesc->attrs[i]->attlen &&
|
|
|
|
indesc->attrs[i]->attalign == outdesc->attrs[i]->attalign)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
same = false;
|
|
|
|
break;
|
2009-08-06 22:44:32 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
same = false;
|
|
|
|
|
|
|
|
if (same)
|
|
|
|
{
|
|
|
|
/* Runtime conversion is not needed */
|
|
|
|
pfree(attrMap);
|
|
|
|
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 */
|
|
|
|
map->outvalues = (Datum *) palloc(n * sizeof(Datum));
|
|
|
|
map->outisnull = (bool *) palloc(n * sizeof(bool));
|
2010-02-26 03:01:40 +01:00
|
|
|
n = indesc->natts + 1; /* +1 for NULL */
|
2009-08-06 22:44:32 +02:00
|
|
|
map->invalues = (Datum *) palloc(n * sizeof(Datum));
|
|
|
|
map->inisnull = (bool *) palloc(n * sizeof(bool));
|
2010-02-26 03:01:40 +01:00
|
|
|
map->invalues[0] = (Datum) 0; /* set up the NULL entry */
|
2009-08-06 22:44:32 +02:00
|
|
|
map->inisnull[0] = true;
|
|
|
|
|
|
|
|
return map;
|
|
|
|
}
|
|
|
|
|
2017-01-09 23:26:58 +01:00
|
|
|
/*
|
|
|
|
* Return a palloc'd bare attribute map for tuple conversion, matching input
|
|
|
|
* and output columns by name. (Dropped columns are ignored in both input and
|
|
|
|
* output.) This is normally a subroutine for convert_tuples_by_name, but can
|
|
|
|
* be used standalone.
|
|
|
|
*/
|
|
|
|
AttrNumber *
|
|
|
|
convert_tuples_by_name_map(TupleDesc indesc,
|
|
|
|
TupleDesc outdesc,
|
|
|
|
const char *msg)
|
|
|
|
{
|
|
|
|
AttrNumber *attrMap;
|
|
|
|
int n;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
n = outdesc->natts;
|
|
|
|
attrMap = (AttrNumber *) palloc0(n * sizeof(AttrNumber));
|
|
|
|
for (i = 0; i < n; i++)
|
|
|
|
{
|
|
|
|
Form_pg_attribute att = outdesc->attrs[i];
|
|
|
|
char *attname;
|
|
|
|
Oid atttypid;
|
|
|
|
int32 atttypmod;
|
|
|
|
int j;
|
|
|
|
|
|
|
|
if (att->attisdropped)
|
|
|
|
continue; /* attrMap[i] is already 0 */
|
|
|
|
attname = NameStr(att->attname);
|
|
|
|
atttypid = att->atttypid;
|
|
|
|
atttypmod = att->atttypmod;
|
|
|
|
for (j = 0; j < indesc->natts; j++)
|
|
|
|
{
|
|
|
|
att = indesc->attrs[j];
|
|
|
|
if (att->attisdropped)
|
|
|
|
continue;
|
|
|
|
if (strcmp(attname, NameStr(att->attname)) == 0)
|
|
|
|
{
|
|
|
|
/* Found it, check type */
|
|
|
|
if (atttypid != att->atttypid || atttypmod != att->atttypmod)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_DATATYPE_MISMATCH),
|
|
|
|
errmsg_internal("%s", _(msg)),
|
|
|
|
errdetail("Attribute \"%s\" of type %s does not match corresponding attribute of type %s.",
|
|
|
|
attname,
|
|
|
|
format_type_be(outdesc->tdtypeid),
|
|
|
|
format_type_be(indesc->tdtypeid))));
|
|
|
|
attrMap[i] = (AttrNumber) (j + 1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (attrMap[i] == 0)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_DATATYPE_MISMATCH),
|
|
|
|
errmsg_internal("%s", _(msg)),
|
|
|
|
errdetail("Attribute \"%s\" of type %s does not exist in type %s.",
|
|
|
|
attname,
|
|
|
|
format_type_be(outdesc->tdtypeid),
|
|
|
|
format_type_be(indesc->tdtypeid))));
|
|
|
|
}
|
|
|
|
|
|
|
|
return attrMap;
|
|
|
|
}
|
|
|
|
|
2009-08-06 22:44:32 +02:00
|
|
|
/*
|
|
|
|
* Perform conversion of a tuple according to the map.
|
|
|
|
*/
|
|
|
|
HeapTuple
|
|
|
|
do_convert_tuple(HeapTuple tuple, TupleConversionMap *map)
|
|
|
|
{
|
|
|
|
AttrNumber *attrMap = map->attrMap;
|
|
|
|
Datum *invalues = map->invalues;
|
|
|
|
bool *inisnull = map->inisnull;
|
|
|
|
Datum *outvalues = map->outvalues;
|
|
|
|
bool *outisnull = map->outisnull;
|
|
|
|
int outnatts = map->outdesc->natts;
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < outnatts; i++)
|
|
|
|
{
|
|
|
|
int j = attrMap[i];
|
|
|
|
|
|
|
|
outvalues[i] = invalues[j];
|
|
|
|
outisnull[i] = inisnull[j];
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now form the new tuple.
|
|
|
|
*/
|
|
|
|
return heap_form_tuple(map->outdesc, outvalues, outisnull);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Free a TupleConversionMap structure.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
free_conversion_map(TupleConversionMap *map)
|
|
|
|
{
|
|
|
|
/* indesc and outdesc are not ours to free */
|
|
|
|
pfree(map->attrMap);
|
|
|
|
pfree(map->invalues);
|
|
|
|
pfree(map->inisnull);
|
|
|
|
pfree(map->outvalues);
|
|
|
|
pfree(map->outisnull);
|
|
|
|
pfree(map);
|
|
|
|
}
|