?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix xslt_process() to ensure that it inserts a NULL terminator after the
[PostgreSQL.git] / src / backend / optimizer / prep / preptlist.c
blob3550f20d58bb0561d3335a84a937ebd4fc5e5402
1 /*-------------------------------------------------------------------------
2 *
3 * preptlist.c
4 * Routines to preprocess the parse tree target list
5 *
6 * This module takes care of altering the query targetlist as needed for
7 * INSERT, UPDATE, and DELETE queries. For INSERT and UPDATE queries,
8 * the targetlist must contain an entry for each attribute of the target
9 * relation in the correct order. For both UPDATE and DELETE queries,
10 * we need a junk targetlist entry holding the CTID attribute --- the
11 * executor relies on this to find the tuple to be replaced/deleted.
12 * We may also need junk tlist entries for Vars used in the RETURNING list.
13 *
14 *
15 * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
16 * Portions Copyright (c) 1994, Regents of the University of California
17 *
18 * IDENTIFICATION
19 * $PostgreSQL$
20 *
21 *-------------------------------------------------------------------------
22 */
23
24 #include "postgres.h"
25
26 #include "access/heapam.h"
27 #include "access/sysattr.h"
28 #include "catalog/pg_type.h"
29 #include "nodes/makefuncs.h"
30 #include "optimizer/prep.h"
31 #include "optimizer/subselect.h"
32 #include "optimizer/tlist.h"
33 #include "optimizer/var.h"
34 #include "parser/analyze.h"
35 #include "parser/parsetree.h"
36 #include "parser/parse_coerce.h"
37 #include "utils/rel.h"
38
39
40 static List *expand_targetlist(List *tlist, int command_type,
41 Index result_relation, List *range_table);
42
43
44 /*
45 * preprocess_targetlist
46 * Driver for preprocessing the parse tree targetlist.
47 *
48 * Returns the new targetlist.
49 */
50 List *
51 preprocess_targetlist(PlannerInfo *root, List *tlist)
52 {
53 Query *parse = root->parse;
54 int result_relation = parse->resultRelation;
55 List *range_table = parse->rtable;
56 CmdType command_type = parse->commandType;
57
58 /*
59 * Sanity check: if there is a result relation, it'd better be a real
60 * relation not a subquery. Else parser or rewriter messed up.
61 */
62 if (result_relation)
63 {
64 RangeTblEntry *rte = rt_fetch(result_relation, range_table);
65
66 if (rte->subquery != NULL || rte->relid == InvalidOid)
67 elog(ERROR, "subquery cannot be result relation");
68 }
69
70 /*
71 * for heap_form_tuple to work, the targetlist must match the exact order
72 * of the attributes. We also need to fill in any missing attributes. -ay
73 * 10/94
74 */
75 if (command_type == CMD_INSERT || command_type == CMD_UPDATE)
76 tlist = expand_targetlist(tlist, command_type,
77 result_relation, range_table);
78
79 /*
80 * for "update" and "delete" queries, add ctid of the result relation into
81 * the target list so that the ctid will propagate through execution and
82 * ExecutePlan() will be able to identify the right tuple to replace or
83 * delete. This extra field is marked "junk" so that it is not stored
84 * back into the tuple.
85 */
86 if (command_type == CMD_UPDATE || command_type == CMD_DELETE)
87 {
88 TargetEntry *tle;
89 Var *var;
90
91 var = makeVar(result_relation, SelfItemPointerAttributeNumber,
92 TIDOID, -1, 0);
93
94 tle = makeTargetEntry((Expr *) var,
95 list_length(tlist) + 1,
96 pstrdup("ctid"),
97 true);
98
99 /*
100 * For an UPDATE, expand_targetlist already created a fresh tlist. For
101 * DELETE, better do a listCopy so that we don't destructively modify
102 * the original tlist (is this really necessary?).
103 */
104 if (command_type == CMD_DELETE)
105 tlist = list_copy(tlist);
106
107 tlist = lappend(tlist, tle);
108 }
109
110 /*
111 * Add TID targets for rels selected FOR UPDATE/SHARE. The executor uses
112 * the TID to know which rows to lock, much as for UPDATE or DELETE.
113 */
114 if (parse->rowMarks)
115 {
116 ListCell *l;
117
118 /*
119 * We've got trouble if the FOR UPDATE/SHARE appears inside grouping,
120 * since grouping renders a reference to individual tuple CTIDs
121 * invalid. This is also checked at parse time, but that's
122 * insufficient because of rule substitution, query pullup, etc.
123 */
124 CheckSelectLocking(parse);
125
126 /*
127 * Currently the executor only supports FOR UPDATE/SHARE at top level
128 */
129 if (root->query_level > 1)
130 ereport(ERROR,
131 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
132 errmsg("SELECT FOR UPDATE/SHARE is not allowed in subqueries")));
133
134 foreach(l, parse->rowMarks)
135 {
136 RowMarkClause *rc = (RowMarkClause *) lfirst(l);
137 Var *var;
138 char *resname;
139 TargetEntry *tle;
140
141 /* ignore child rels */
142 if (rc->rti != rc->prti)
143 continue;
144
145 /* always need the ctid */
146 var = makeVar(rc->rti,
147 SelfItemPointerAttributeNumber,
148 TIDOID,
149 -1,
150 0);
151
152 resname = (char *) palloc(32);
153 snprintf(resname, 32, "ctid%u", rc->rti);
154
155 tle = makeTargetEntry((Expr *) var,
156 list_length(tlist) + 1,
157 resname,
158 true);
159
160 tlist = lappend(tlist, tle);
161
162 /* if parent of inheritance tree, need the tableoid too */
163 if (rc->isParent)
164 {
165 var = makeVar(rc->rti,
166 TableOidAttributeNumber,
167 OIDOID,
168 -1,
169 0);
170
171 resname = (char *) palloc(32);
172 snprintf(resname, 32, "tableoid%u", rc->rti);
173
174 tle = makeTargetEntry((Expr *) var,
175 list_length(tlist) + 1,
176 resname,
177 true);
178
179 tlist = lappend(tlist, tle);
180 }
181 }
182 }
183
184 /*
185 * If the query has a RETURNING list, add resjunk entries for any Vars
186 * used in RETURNING that belong to other relations. We need to do this
187 * to make these Vars available for the RETURNING calculation. Vars that
188 * belong to the result rel don't need to be added, because they will be
189 * made to refer to the actual heap tuple.
190 */
191 if (parse->returningList && list_length(parse->rtable) > 1)
192 {
193 List *vars;
194 ListCell *l;
195
196 vars = pull_var_clause((Node *) parse->returningList,
197 PVC_INCLUDE_PLACEHOLDERS);
198 foreach(l, vars)
199 {
200 Var *var = (Var *) lfirst(l);
201 TargetEntry *tle;
202
203 if (IsA(var, Var) &&
204 var->varno == result_relation)
205 continue; /* don't need it */
206
207 if (tlist_member((Node *) var, tlist))
208 continue; /* already got it */
209
210 tle = makeTargetEntry((Expr *) var,
211 list_length(tlist) + 1,
212 NULL,
213 true);
214
215 tlist = lappend(tlist, tle);
216 }
217 list_free(vars);
218 }
219
220 return tlist;
221 }
222
223 /*****************************************************************************
224 *
225 * TARGETLIST EXPANSION
226 *
227 *****************************************************************************/
228
229 /*
230 * expand_targetlist
231 * Given a target list as generated by the parser and a result relation,
232 * add targetlist entries for any missing attributes, and ensure the
233 * non-junk attributes appear in proper field order.
234 *
235 * NOTE: if you are tempted to put more processing here, consider whether
236 * it shouldn't go in the rewriter's rewriteTargetList() instead.
237 */
238 static List *
239 expand_targetlist(List *tlist, int command_type,
240 Index result_relation, List *range_table)
241 {
242 List *new_tlist = NIL;
243 ListCell *tlist_item;
244 Relation rel;
245 int attrno,
246 numattrs;
247
248 tlist_item = list_head(tlist);
249
250 /*
251 * The rewriter should have already ensured that the TLEs are in correct
252 * order; but we have to insert TLEs for any missing attributes.
253 *
254 * Scan the tuple description in the relation's relcache entry to make
255 * sure we have all the user attributes in the right order. We assume
256 * that the rewriter already acquired at least AccessShareLock on the
257 * relation, so we need no lock here.
258 */
259 rel = heap_open(getrelid(result_relation, range_table), NoLock);
260
261 numattrs = RelationGetNumberOfAttributes(rel);
262
263 for (attrno = 1; attrno <= numattrs; attrno++)
264 {
265 Form_pg_attribute att_tup = rel->rd_att->attrs[attrno - 1];
266 TargetEntry *new_tle = NULL;
267
268 if (tlist_item != NULL)
269 {
270 TargetEntry *old_tle = (TargetEntry *) lfirst(tlist_item);
271
272 if (!old_tle->resjunk && old_tle->resno == attrno)
273 {
274 new_tle = old_tle;
275 tlist_item = lnext(tlist_item);
276 }
277 }
278
279 if (new_tle == NULL)
280 {
281 /*
282 * Didn't find a matching tlist entry, so make one.
283 *
284 * For INSERT, generate a NULL constant. (We assume the rewriter
285 * would have inserted any available default value.) Also, if the
286 * column isn't dropped, apply any domain constraints that might
287 * exist --- this is to catch domain NOT NULL.
288 *
289 * For UPDATE, generate a Var reference to the existing value of
290 * the attribute, so that it gets copied to the new tuple. But
291 * generate a NULL for dropped columns (we want to drop any old
292 * values).
293 *
294 * When generating a NULL constant for a dropped column, we label
295 * it INT4 (any other guaranteed-to-exist datatype would do as
296 * well). We can't label it with the dropped column's datatype
297 * since that might not exist anymore. It does not really matter
298 * what we claim the type is, since NULL is NULL --- its
299 * representation is datatype-independent. This could perhaps
300 * confuse code comparing the finished plan to the target
301 * relation, however.
302 */
303 Oid atttype = att_tup->atttypid;
304 int32 atttypmod = att_tup->atttypmod;
305 Node *new_expr;
306
307 switch (command_type)
308 {
309 case CMD_INSERT:
310 if (!att_tup->attisdropped)
311 {
312 new_expr = (Node *) makeConst(atttype,
313 -1,
314 att_tup->attlen,
315 (Datum) 0,
316 true, /* isnull */
317 att_tup->attbyval);
318 new_expr = coerce_to_domain(new_expr,
319 InvalidOid, -1,
320 atttype,
321 COERCE_IMPLICIT_CAST,
322 -1,
323 false,
324 false);
325 }
326 else
327 {
328 /* Insert NULL for dropped column */
329 new_expr = (Node *) makeConst(INT4OID,
330 -1,
331 sizeof(int32),
332 (Datum) 0,
333 true, /* isnull */
334 true /* byval */ );
335 }
336 break;
337 case CMD_UPDATE:
338 if (!att_tup->attisdropped)
339 {
340 new_expr = (Node *) makeVar(result_relation,
341 attrno,
342 atttype,
343 atttypmod,
344 0);
345 }
346 else
347 {
348 /* Insert NULL for dropped column */
349 new_expr = (Node *) makeConst(INT4OID,
350 -1,
351 sizeof(int32),
352 (Datum) 0,
353 true, /* isnull */
354 true /* byval */ );
355 }
356 break;
357 default:
358 elog(ERROR, "unrecognized command_type: %d",
359 (int) command_type);
360 new_expr = NULL; /* keep compiler quiet */
361 break;
362 }
363
364 new_tle = makeTargetEntry((Expr *) new_expr,
365 attrno,
366 pstrdup(NameStr(att_tup->attname)),
367 false);
368 }
369
370 new_tlist = lappend(new_tlist, new_tle);
371 }
372
373 /*
374 * The remaining tlist entries should be resjunk; append them all to the
375 * end of the new tlist, making sure they have resnos higher than the last
376 * real attribute. (Note: although the rewriter already did such
377 * renumbering, we have to do it again here in case we are doing an UPDATE
378 * in a table with dropped columns, or an inheritance child table with
379 * extra columns.)
380 */
381 while (tlist_item)
382 {
383 TargetEntry *old_tle = (TargetEntry *) lfirst(tlist_item);
384
385 if (!old_tle->resjunk)
386 elog(ERROR, "targetlist is not sorted correctly");
387 /* Get the resno right, but don't copy unnecessarily */
388 if (old_tle->resno != attrno)
389 {
390 old_tle = flatCopyTargetEntry(old_tle);
391 old_tle->resno = attrno;
392 }
393 new_tlist = lappend(new_tlist, old_tle);
394 attrno++;
395 tlist_item = lnext(tlist_item);
396 }
397
398 heap_close(rel, NoLock);
399
400 return new_tlist;
401 }
PostgreSQL from CVS