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