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
|
2010-02-26 03:01:40 +01: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.
|
|
|
|
*
|
2012-01-02 00:01:58 +01:00
|
|
|
* Portions Copyright (c) 1996-2012, 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)));
|
|
|
|
|
|
|
|
/*
|
2010-02-26 03:01:40 +01:00
|
|
|
* Check to see if the map is one-to-one and the tuple types are the same.
|
|
|
|
* (We check the latter because if they're not, we want to do conversion
|
|
|
|
* to inject the right OID into the tuple datum.)
|
2009-08-06 22:44:32 +02:00
|
|
|
*/
|
|
|
|
if (indesc->natts == outdesc->natts &&
|
|
|
|
indesc->tdtypeid == outdesc->tdtypeid)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
int n;
|
|
|
|
int i;
|
|
|
|
bool same;
|
|
|
|
|
|
|
|
/* Verify compatibility and prepare attribute-number map */
|
|
|
|
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)
|
2010-02-26 03:01:40 +01:00
|
|
|
continue; /* attrMap[i] is already 0 */
|
2009-08-06 22:44:32 +02:00
|
|
|
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))));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2010-02-26 03:01:40 +01:00
|
|
|
* Check to see if the map is one-to-one and the tuple types are the same.
|
|
|
|
* (We check the latter because if they're not, we want to do conversion
|
|
|
|
* to inject the right OID into the tuple datum.)
|
2009-08-06 22:44:32 +02:00
|
|
|
*/
|
|
|
|
if (indesc->natts == outdesc->natts &&
|
|
|
|
indesc->tdtypeid == outdesc->tdtypeid)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
}
|