PostgreSQL Source Code  git master
attmap.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * attmap.c
4  * Attribute mapping support.
5  *
6  * This file provides utility routines to build and manage attribute
7  * mappings by comparing input and output TupleDescs. Such mappings
8  * are typically used by DDL operating on inheritance and partition trees
9  * to do a conversion between rowtypes logically equivalent but with
10  * columns in a different order, taking into account dropped columns.
11  * They are also used by the tuple conversion routines in tupconvert.c.
12  *
13  * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
14  * Portions Copyright (c) 1994, Regents of the University of California
15  *
16  *
17  * IDENTIFICATION
18  * src/backend/access/common/attmap.c
19  *
20  *-------------------------------------------------------------------------
21  */
22 
23 #include "postgres.h"
24 
25 #include "access/attmap.h"
26 #include "access/htup_details.h"
27 #include "utils/builtins.h"
28 
29 
30 static bool check_attrmap_match(TupleDesc indesc,
31  TupleDesc outdesc,
32  AttrMap *attrMap);
33 
34 /*
35  * make_attrmap
36  *
37  * Utility routine to allocate an attribute map in the current memory
38  * context.
39  */
40 AttrMap *
41 make_attrmap(int maplen)
42 {
43  AttrMap *res;
44 
45  res = (AttrMap *) palloc0(sizeof(AttrMap));
46  res->maplen = maplen;
47  res->attnums = (AttrNumber *) palloc0(sizeof(AttrNumber) * maplen);
48  return res;
49 }
50 
51 /*
52  * free_attrmap
53  *
54  * Utility routine to release an attribute map.
55  */
56 void
58 {
59  pfree(map->attnums);
60  pfree(map);
61 }
62 
63 /*
64  * build_attrmap_by_position
65  *
66  * Return a palloc'd bare attribute map for tuple conversion, matching input
67  * and output columns by position. Dropped columns are ignored in both input
68  * and output, marked as 0. This is normally a subroutine for
69  * convert_tuples_by_position in tupconvert.c, but it can be used standalone.
70  *
71  * Note: the errdetail messages speak of indesc as the "returned" rowtype,
72  * outdesc as the "expected" rowtype. This is okay for current uses but
73  * might need generalization in future.
74  */
75 AttrMap *
77  TupleDesc outdesc,
78  const char *msg)
79 {
80  AttrMap *attrMap;
81  int nincols;
82  int noutcols;
83  int n;
84  int i;
85  int j;
86  bool same;
87 
88  /*
89  * The length is computed as the number of attributes of the expected
90  * rowtype as it includes dropped attributes in its count.
91  */
92  n = outdesc->natts;
93  attrMap = make_attrmap(n);
94 
95  j = 0; /* j is next physical input attribute */
96  nincols = noutcols = 0; /* these count non-dropped attributes */
97  same = true;
98  for (i = 0; i < n; i++)
99  {
100  Form_pg_attribute att = TupleDescAttr(outdesc, i);
101  Oid atttypid;
102  int32 atttypmod;
103 
104  if (att->attisdropped)
105  continue; /* attrMap->attnums[i] is already 0 */
106  noutcols++;
107  atttypid = att->atttypid;
108  atttypmod = att->atttypmod;
109  for (; j < indesc->natts; j++)
110  {
111  att = TupleDescAttr(indesc, j);
112  if (att->attisdropped)
113  continue;
114  nincols++;
115 
116  /* Found matching column, now check type */
117  if (atttypid != att->atttypid ||
118  (atttypmod != att->atttypmod && atttypmod >= 0))
119  ereport(ERROR,
120  (errcode(ERRCODE_DATATYPE_MISMATCH),
121  errmsg_internal("%s", _(msg)),
122  errdetail("Returned type %s does not match expected type %s in column %d.",
123  format_type_with_typemod(att->atttypid,
124  att->atttypmod),
125  format_type_with_typemod(atttypid,
126  atttypmod),
127  noutcols)));
128  attrMap->attnums[i] = (AttrNumber) (j + 1);
129  j++;
130  break;
131  }
132  if (attrMap->attnums[i] == 0)
133  same = false; /* we'll complain below */
134  }
135 
136  /* Check for unused input columns */
137  for (; j < indesc->natts; j++)
138  {
139  if (TupleDescAttr(indesc, j)->attisdropped)
140  continue;
141  nincols++;
142  same = false; /* we'll complain below */
143  }
144 
145  /* Report column count mismatch using the non-dropped-column counts */
146  if (!same)
147  ereport(ERROR,
148  (errcode(ERRCODE_DATATYPE_MISMATCH),
149  errmsg_internal("%s", _(msg)),
150  errdetail("Number of returned columns (%d) does not match "
151  "expected column count (%d).",
152  nincols, noutcols)));
153 
154  /* Check if the map has a one-to-one match */
155  if (check_attrmap_match(indesc, outdesc, attrMap))
156  {
157  /* Runtime conversion is not needed */
158  free_attrmap(attrMap);
159  return NULL;
160  }
161 
162  return attrMap;
163 }
164 
165 /*
166  * build_attrmap_by_name
167  *
168  * Return a palloc'd bare attribute map for tuple conversion, matching input
169  * and output columns by name. (Dropped columns are ignored in both input and
170  * output.) This is normally a subroutine for convert_tuples_by_name in
171  * tupconvert.c, but can be used standalone.
172  *
173  * If 'missing_ok' is true, a column from 'outdesc' not being present in
174  * 'indesc' is not flagged as an error; AttrMap.attnums[] entry for such an
175  * outdesc column will be 0 in that case.
176  */
177 AttrMap *
179  TupleDesc outdesc,
180  bool missing_ok)
181 {
182  AttrMap *attrMap;
183  int outnatts;
184  int innatts;
185  int i;
186  int nextindesc = -1;
187 
188  outnatts = outdesc->natts;
189  innatts = indesc->natts;
190 
191  attrMap = make_attrmap(outnatts);
192  for (i = 0; i < outnatts; i++)
193  {
194  Form_pg_attribute outatt = TupleDescAttr(outdesc, i);
195  char *attname;
196  Oid atttypid;
197  int32 atttypmod;
198  int j;
199 
200  if (outatt->attisdropped)
201  continue; /* attrMap->attnums[i] is already 0 */
202  attname = NameStr(outatt->attname);
203  atttypid = outatt->atttypid;
204  atttypmod = outatt->atttypmod;
205 
206  /*
207  * Now search for an attribute with the same name in the indesc. It
208  * seems likely that a partitioned table will have the attributes in
209  * the same order as the partition, so the search below is optimized
210  * for that case. It is possible that columns are dropped in one of
211  * the relations, but not the other, so we use the 'nextindesc'
212  * counter to track the starting point of the search. If the inner
213  * loop encounters dropped columns then it will have to skip over
214  * them, but it should leave 'nextindesc' at the correct position for
215  * the next outer loop.
216  */
217  for (j = 0; j < innatts; j++)
218  {
219  Form_pg_attribute inatt;
220 
221  nextindesc++;
222  if (nextindesc >= innatts)
223  nextindesc = 0;
224 
225  inatt = TupleDescAttr(indesc, nextindesc);
226  if (inatt->attisdropped)
227  continue;
228  if (strcmp(attname, NameStr(inatt->attname)) == 0)
229  {
230  /* Found it, check type */
231  if (atttypid != inatt->atttypid || atttypmod != inatt->atttypmod)
232  ereport(ERROR,
233  (errcode(ERRCODE_DATATYPE_MISMATCH),
234  errmsg("could not convert row type"),
235  errdetail("Attribute \"%s\" of type %s does not match corresponding attribute of type %s.",
236  attname,
237  format_type_be(outdesc->tdtypeid),
238  format_type_be(indesc->tdtypeid))));
239  attrMap->attnums[i] = inatt->attnum;
240  break;
241  }
242  }
243  if (attrMap->attnums[i] == 0 && !missing_ok)
244  ereport(ERROR,
245  (errcode(ERRCODE_DATATYPE_MISMATCH),
246  errmsg("could not convert row type"),
247  errdetail("Attribute \"%s\" of type %s does not exist in type %s.",
248  attname,
249  format_type_be(outdesc->tdtypeid),
250  format_type_be(indesc->tdtypeid))));
251  }
252  return attrMap;
253 }
254 
255 /*
256  * build_attrmap_by_name_if_req
257  *
258  * Returns mapping created by build_attrmap_by_name, or NULL if no
259  * conversion is required. This is a convenience routine for
260  * convert_tuples_by_name() in tupconvert.c and other functions, but it
261  * can be used standalone.
262  */
263 AttrMap *
265  TupleDesc outdesc,
266  bool missing_ok)
267 {
268  AttrMap *attrMap;
269 
270  /* Verify compatibility and prepare attribute-number map */
271  attrMap = build_attrmap_by_name(indesc, outdesc, missing_ok);
272 
273  /* Check if the map has a one-to-one match */
274  if (check_attrmap_match(indesc, outdesc, attrMap))
275  {
276  /* Runtime conversion is not needed */
277  free_attrmap(attrMap);
278  return NULL;
279  }
280 
281  return attrMap;
282 }
283 
284 /*
285  * check_attrmap_match
286  *
287  * Check to see if the map is a one-to-one match, in which case we need
288  * not to do a tuple conversion, and the attribute map is not necessary.
289  */
290 static bool
292  TupleDesc outdesc,
293  AttrMap *attrMap)
294 {
295  int i;
296 
297  /* no match if attribute numbers are not the same */
298  if (indesc->natts != outdesc->natts)
299  return false;
300 
301  for (i = 0; i < attrMap->maplen; i++)
302  {
303  Form_pg_attribute inatt = TupleDescAttr(indesc, i);
304  Form_pg_attribute outatt = TupleDescAttr(outdesc, i);
305 
306  /*
307  * If the input column has a missing attribute, we need a conversion.
308  */
309  if (inatt->atthasmissing)
310  return false;
311 
312  if (attrMap->attnums[i] == (i + 1))
313  continue;
314 
315  /*
316  * If it's a dropped column and the corresponding input column is also
317  * dropped, we don't need a conversion. However, attlen and attalign
318  * must agree.
319  */
320  if (attrMap->attnums[i] == 0 &&
321  inatt->attisdropped &&
322  inatt->attlen == outatt->attlen &&
323  inatt->attalign == outatt->attalign)
324  continue;
325 
326  return false;
327  }
328 
329  return true;
330 }
void free_attrmap(AttrMap *map)
Definition: attmap.c:57
AttrMap * make_attrmap(int maplen)
Definition: attmap.c:41
AttrMap * build_attrmap_by_position(TupleDesc indesc, TupleDesc outdesc, const char *msg)
Definition: attmap.c:76
AttrMap * build_attrmap_by_name_if_req(TupleDesc indesc, TupleDesc outdesc, bool missing_ok)
Definition: attmap.c:264
static bool check_attrmap_match(TupleDesc indesc, TupleDesc outdesc, AttrMap *attrMap)
Definition: attmap.c:291
AttrMap * build_attrmap_by_name(TupleDesc indesc, TupleDesc outdesc, bool missing_ok)
Definition: attmap.c:178
int16 AttrNumber
Definition: attnum.h:21
#define NameStr(name)
Definition: c.h:682
signed int int32
Definition: c.h:430
int errmsg_internal(const char *fmt,...)
Definition: elog.c:993
int errdetail(const char *fmt,...)
Definition: elog.c:1039
int errcode(int sqlerrcode)
Definition: elog.c:695
int errmsg(const char *fmt,...)
Definition: elog.c:906
#define _(x)
Definition: elog.c:90
#define ERROR
Definition: elog.h:35
#define ereport(elevel,...)
Definition: elog.h:145
char * format_type_with_typemod(Oid type_oid, int32 typemod)
Definition: format_type.c:358
char * format_type_be(Oid type_oid)
Definition: format_type.c:339
int j
Definition: isn.c:74
int i
Definition: isn.c:73
void pfree(void *pointer)
Definition: mcxt.c:1306
void * palloc0(Size size)
Definition: mcxt.c:1230
NameData attname
Definition: pg_attribute.h:41
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:207
unsigned int Oid
Definition: postgres_ext.h:31
Definition: attmap.h:35
int maplen
Definition: attmap.h:37
AttrNumber * attnums
Definition: attmap.h:36
Oid tdtypeid
Definition: tupdesc.h:82
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92